InstanceOfJava

Constructors in java

Posted by: Instanceofjava Posted date: 5:25 PM / comment : 0 concept and program

Constructors will be executed when the object is created.
Constructors should have same name of class name.
Executed once per object.
Basically used to assign instance variables
We can overload constructors.
We can call super class constructor form sub class constructor.

package instanceofjava;
class A{
A(){
}
}
}

while creating object constructor will be executed so we can assign instance variables to some default values.

package instanceofjava;
class A{
int a,b
A(int x, int y){
a=x;
b=y;
}
public static void main(String[] args){
A a=new A(10,20);
}
}

Types of constructors:

There are two types of constructors
Default constructors
Parameterized constructor.

Default constructor:

Default constructor will not have any arguments.
If we not defined any constructor in our class. JVM automatically defines a default constructor to our class.

package instanceofjava;
class Sample{
int a,b
Sample(){
a=37;
b=46;
}
public static void main(String[] args){
Sample obj=new Sample();
System.out.println(obj.a);
System.out.println(obj.b);
}
}

Output:

Parameterized constructor

package instanceofjava;
class Sample{
int a,b
Sample(int x, int y){
a=x;
b=y;
}
public static void main(String[] args){
Sample obj=new Sample(37,46);
System.out.println(obj.a);
System.out.println(obj.b);
}
}

Output:

Constructor overloading:

package instanceofjava;
class Sample{
int a,b
Sample(){
this(1,2);
System.out.println("Default constructor");
}
Sample(int x , int y){
this(1,2,3);
a=x;
b=y;
System.out.println("Two argument constructor");
}
Sample(int a , int b,int c){
System.out.println("Three argument constructor")
}
public static void main(String[] args){
Sample obj=new Sample();
System.out.println(obj.a);
System.out.println(obj.b);
}
}

Output:

Three argument constructor
Two argument constructor
Default argument constructor
1
2

This and Super Keywords

Posted by: Instanceofjava Posted date: 3:04 PM / comment : 0 concept and program

this keyword used to store current object reference.
super keyword used to store super class reference in subclass object.

this keyword:

Predefined instance variable to hold current object reference.

It must used explicitly if non-static variable and local variable name is same.

Output:

Without this keyword if variable names are same we can not assign instance variables so this problem will solve by using this keyword

package com.instanceofjava;
public class ThisDemo {
int a, b;
ThisDemo(int a, int b){
this.a=a;
this.b=b;
}
public static void main(String[] args){
ThisDemo obj= new ThisDemo(1,2);
System.out.println(obj.a);
System.out.println(obj.b);
}
}

Output:

Used to invoke current class constructor:

package com.instanceofjava;
public class ThisDemo {
int a, b;
ThisDemo(){
System.out.println("Default constructor called");
}
ThisDemo(int a, int b){
this();
this.a=a;
this.b=b;
}
public static void main(String[] args){
ThisDemo obj= new ThisDemo(1,2);
System.out.println(obj.a);
System.out.println(obj.b);
}
}

Output:

Default constructor called
1
2

Used to call current class method:

package com.instanceofjava;
public class Sample{
int a, b;
Sample(int a, int b){
this.a=a;
this.b=b;
}
void show(){
System.out.println("Show() method called");
}
void print(){
this.show();
System.out.println(obj.a);
System.out.println(obj.b);
}
public static void main(String[] args){
Sample obj= new Sample(1,2);
obj.print()
}
}

Output:

Show() method called
1
2

super keyword:

Predefined instance variable used to hold super class object reference through sub class object.

Super keyword interview questions java

Used to call super class constructor:

package com.instanceofjava;
public class A{
int a, b;
A(int a, int b){
a=a;
b=b;
System.out.println("super class constructor called");
}
}

package com.instanceofjava;
public class B extends A{
int a, b;
A(int a, int b){
super(a,b);
a=a;
b=b;
}
public static void main(String[] args){
B obj= new B(1,2);
}
}
}

Output:

super class constructor called
1
2

Used to call super class methods from subclass:

package com.instanceofjava;
public class A{
int a, b;
A(int a, int b){
a=a;
b=b;
System.out.println("super class constructor called");
}
void add(){
System.out.println("super class method called");
}
}

package com.instanceofjava;
public class B extends A{
int a, b;
A(int a, int b){
super(a,b);
a=a;
b=b;
}
void print(){
super.add();
System.out.println(this.a);
System.out.println(this.b);
}
public static void main(String[] args){
B obj= new B(1,2);
obj.print();
}
}
}

Output:

super class method called
1
2

Abstraction

Posted by: Instanceofjava Posted date: 1:42 PM / comment : 2 concept and program

Abstraction is fundamental principle of modeling. A system model is created at different levels, starting at the higher levels and adding more levels with more details as more is understood about the system. When complete, the model can be viewed at several levels.
So abstraction is about,

Looking only at the information that is relevant at that time
Hiding details so as not to confuse the bigger picture

Abstraction is a process of developing a class by hiding or removing non essential details relevant to user. here non essential details means method body and logic
Basically Abstraction provides a contract between a service provider and clients.
we can achieve this by using abstract class

package Abstraction;
public abstract class AbstractDemo {
abstract void add(); // abstract method
void show(){ // normal method
System.out.println("this is concrete method present in abstract class");
}
}

Abstract class can not be instantiated directly.
Means we can not create object for abstract class directly

package Abstraction;
public abstract class AbstractDemo {
abstract void add(); // abstract method
void show(){ // normal method
System.out.println("this is concrete method present in abstract class");
}
public static void main(String[] args){
AbstractDemo obj= new AbstractDemo();
// ERROR: Cannot instantiate the type AbstractDemo
}
}

Can we declare abstract methods as static?

package Abstraction;
public abstract class AbstractDemo {
static abstract void add(); // ERROR: illegal combination of modifiers
void show(){ // normal method
System.out.println("this is concrete method present in abstract class");
}
}

No, we are not allowed to declare method as static . It leads to compile time error.

Can we declare abstract methods as final?

package Abstraction;
public abstract class AbstractDemo {
final abstract void add(); // ERROR: illegal combination of modifiers
void show(){ // normal method
System.out.println("this is concrete method present in abstract class");
}
}

No, we are not allowed to declare method as static . It leads to compile time error.
Because it should be inherited to sub class.

Can we declare abstract methods as private?

package Abstraction;
public abstract class AbstractDemo {
final abstract void add(); // ERROR: illegal combination of modifiers
void show(){ // normal method
System.out.println("this is concrete method present in abstract class");
}
}

No, we are not allowed to declare method as static . It leads to compile time error.
Because it should be inherited to sub class.

Legal modifiers allowed in combination with abstract

1.native

package Abstraction;
public abstract class AbstractDemo {
native abstract void add(); // ERROR: illegal combination of modifiers
void show(){ // normal method
System.out.println("this is concrete method present in abstract class");
}
}

2.protected

package Abstraction;
public abstract class AbstractDemo {
protected abstract void add();
void show(){ // normal method
System.out.println("this is concrete method present in abstract class");
}
}

3.public

package Abstraction;
public abstract class AbstractDemo {
public abstract void add();
void show(){ // normal method
System.out.println("this is concrete method present in abstract class");
}
}

4.default

package Abstraction;
public abstract class AbstractDemo {
abstract void add();
void show(){ // normal method
System.out.println("this is concrete method present in abstract class");
}
}

How it works:

package Abstraction;
public abstract class AbstractDemo {
abstract void add();
void show(){ // normal method
System.out.println("this is concrete method present in abstract class");
}
}

package Abstraction;
public abstract class Example extends AbstractDemo {
abstract void add(){
System.out.println("this is implemented method in sub class");
}
}

Polymorphism

Posted by: Instanceofjava Posted date: 8:32 PM / comment : 0 concept and program

Defining multiple methods with same name
Static polymorphism and dynamic polymorphism

Static polymorphism:

Its a process of defining multiple methods with the same name and with different parameter types or list or order is called static polymorphism
Compile time itself we can say which method is going to get executed based on parameters types.
So its also called compile time polymorphism.
This will be achieved by method overloading.
Method overloading means defining multiple methods with same name and different parameters.
If two methods have same method name , But different parameter types those methods are considered as overloaded methods.
Will see example program on method overloading.

Example program on method overloading:

package instanceofjava;
public class OverloadingDemo {
void add(){
System.out.println("No-arg method");
}
void add(int i){
System.out.println("int-arg method");
}
void add(String str){
System.out.println("String-arg method");
}
void add(float d){
System.out.println("float-arg method");
}
void add(int a, int b){
System.out.println("2 int-arg method");
}
public static void main(String[] args){
OverloadingDemo obj= new OverloadingDemo();
obj.add();
obj.add(10);
obj.add(1.2f);
obj.add("java");
obj.add(1, 2);
}
}

Output

No-arg method
int-arg method
float-arg method
String-arg method
2 int-arg method

Method overloading with reference types:

We can also overload method with reference types, check below program.

package instanceofjava;
public class Test {
void show(){
System.out.println("test class show() method");
}
}

package instanceofjava;
public class Example {
void method(String s){
System.out.println("String-arg");
}
void method(Test obj){
System.out.println("method(Test obj)-arg");
obj.show();
}
public static void main(String[] args){
Example obj= new Example();
obj.method("polymorphism definition in oops");
obj.method(new Test());
}
}

Output:

String-arg
method(Test obj)-arg
test class show() method

Dynamic polymorphism:

Redefining the super class method in sub class is called "method overriding" .
Method overriding is a language feature that allows a sub class to provide a specific implementation of a method that is already provided by one of its super class.
The implementation in the sub class overrides the implementation in the super class.
This is also called dynamic polymorphism / runtime polymorphism.

package instanceofjava;
public class A{
void show(String s){
System.out.println("super class method");
}
}

package instanceofjava;
public class B extends A{
void show(String s){
System.out.println("sub class method");
}
public static void main(String[] args){
B obj =new B();
obj.show();
}
}

Output:

sub class method

We can not override static methods:

Actually static variables and static methods are class level. they are not instance level.
So if you try to override a static method will throw compile error

package instanceofjava;
public class Super {
int a,b;
static void add(){
System.out.println("super class add() method");
}
}

package instanceofjava;
public class Sub extends Super {
void add(){ // ERROR:This instance method cannot override the static method
System.out.println("this is sub class add() method");
}
public static void main(String [] args){
Sub obj= new Sub();
}
}

Static methods are class level so we need to access by using class name.

package instanceofjava;
public class Sub extends Super {
static void add(){// works fine
System.out.println("this is sub class add() method");
}
public static void main(String [] args){
Super.add();
Sub.add();
}
}

Output:

super class add() method
sub class add() method

Method Overriding - Exceptions:

When we overriding a method from super class to sub class. we need to follow some rules
Whenever sub class method throws checked exception then super class method must be declared throws with same exception or super class of that checked exception.

package instanceofjava;
public class Super {
int a,b;
void add(){
System.out.println("super class add() method");
}
}

package instanceofjava;
public class Sub extends Super {
void add() throws IOException{ // ERROR: - Exception IOException is not compatible with
//throws clause in Super.add()
System.out.println("this is sub class add() method");
}
public static void main(String [] args){
Sub obj= new Sub();
}
}

package instanceofjava;
public class Super {
int a,b;
void add()throws IOException{
System.out.println("super class add() method");
}
}

package instanceofjava;
public class Sub extends Super {
void add() throws IOException{// works fine
System.out.println("this is sub class add() method");
}
public static void main(String [] args){
Sub obj= new Sub();
}
}

Inheritance Definition and Programs

Posted by: Instanceofjava Posted date: 2:55 PM / comment : 0 concept and program

Getting the properties from one class object to other class is known as inheritance.
In this inheritance will have parent class and child class so getting the properties of parent class object to child class object known as inheritance.
Inheritance means to take something that already made.
Inheritance can be implemented in java by using "extends" and "implements' keywords
In this we have two types.
Multilevel inheritance
Multiple inheritance

Multilevel inheritance:

Getting the properties from super class object to sub class object level wise with different priorities known as multiple inheritance.

Super class:

package instanceofjava;
public class Super {
int a,b;
void add(){
System.out.println((a+b));
}
}

Sub class:

package instanceofjava;
public class Sub extends Super {
void show(){
System.out.println("this is sub class show() method");
}
public static void main(String [] args){
Sub obj= new Sub();
obj.a=1;
obj.b=2;
obj.add();
obj.show();
}
}

Output:

3
this is sub class show() method

Example program #2:

package instanceofjava;
public class A {
int a,b;
public void show(){
System.out.println("A class show method");
}
}

package instanceofjava;
public class B extends A{
public void print(){
System.out.println("B class print method");
}
}

package instanceofjava;
public class C extends B{
public void display(){
System.out.println("C class display method");
}
public static void main(String [] args){
C obj= new C();
obj.print();
obj.show();
obj.display();
}
}

Output:

B class print() method
A class show method
Class C display method

Multiple inheritance:

Multiple inheritance means getting the properties from one class object to multiple class object with different priority.
Multiple inheritance concept is not supported by java

package instanceofjava;
public class A {
public void show(){
System.out.println("A class show method");
}
}

package instanceofjava;
public class b {
public void show(){
System.out.println("B class show method");
}
}

package instanceofjava;
public class C extends A,B { // not supported by java
public void print(){
System.out.println("C class print method");
}
}

Why java does not supports multiple inheritance check this for more information.

You Might Like:

1. Java Interview Programs On Core Java

2. Java Interview Programs On Collections

3. What is The Output Of Following Programs Java Interview:

4. Java Concept and Example Program

Encapsulation in java with example program

Posted by: Instanceofjava Posted date: 10:17 AM / comment : 2 concept and program

What is meant by encapsulation in java?

Binding the data with its related functionalities known as encapsulation
Here data means variables and functionalities means methods.
So keeping the variable and related methods in one place.
That place is "class". class is the base for encapsulation.
Lets see example program on encapsulation, how the variables and methods defined in a class

What is encapsulation in object oriented programming?

Basic java example program on data encapsulation:

package com.instanceofjava;
public class EncapsulationDemo {
String name;
int rno;
String address;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getRno() {
return rno;
}
public void setRno(int rno) {
this.rno = rno;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public void showInfo(){
System.out.println("Name: "+getName());
System.out.println("R.No: "+getRno());
System.out.println("Name: "+getAddress());
}
}

Class:

The above example program shows how the variables and methods will be there in a class.
So class is the base for encapsulation
class is user defined data type in java means by using class we can structure our own programs.
Lest see a example program on class.

package com.instanceofjava;
public class ClassDemo {
//variables of a class
String empName;
int empId;
String Designation;
//getter and setter methods for variables
//by using these methods we can set the value to the variable and gat the value from the
//variables
public String getEmpName() {
return empName;
}
public void setEmpName(String empName) {
this.empName = empName;
}
public int getEmpId() {
return empId;
}
public void setEmpId(int empId) {
this.empId = empId;
}
public String getDesignation() {
return Designation;
}
public void setDesignation(String designation) {
Designation = designation;
}
}

Object:

Instance of class is known as object.
Instance means dynamic memory allocation. So dynamic memory allocation to class is called object.
By using "new" keyword the object will be created dynamically.
Class is a template. By using object we will get memory for all variables so that we can use them.

We can create number of objects for one class based on our requirements.
Below an example program on class and object.

package com.instanceofjava;
public class User {
String Name;
int Id;
String address;
public String getName() {
return Name;
}
public void setName(String name) {
Name = name;
}
public int getId() {
return Id;
}
public void setId(int id) {
Id = id;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public static void main(String [] args){
User obj= new User();
obj.setName("sai");
obj.setId(1);
obj.setAddress("xyz");
System.out.println(obj.getName());
System.out.println(obj.getId());
System.out.println(obj.getAddress());
}
}

Output:

Subscribe to: Posts ( Atom )

Constructors in java

Types of constructors:

Default constructor:

Output:

Parameterized constructor

Output:

Constructor overloading:

Output:

This and Super Keywords

this keyword:

It must used explicitly if non-static variable and local variable name is same.

Top 10 Java interview questions and programs on this keyword

Output:

Output:

Used to invoke current class constructor:

Output:

Used to call current class method:

Output:

super keyword:

Used to call super class constructor:

Output:

Used to call super class methods from subclass:

Output:

Abstraction

Can we declare abstract methods as static?

Can we declare abstract methods as final?

Can we declare abstract methods as private?

Legal modifiers allowed in combination with abstract

1.native

2.protected

3.public

4.default

How it works:

Polymorphism

Static polymorphism:

Example program on method overloading:

Output

Method overloading with reference types:

Output:

Dynamic polymorphism:

Output:

We can not override static methods:

Output:

Method Overriding - Exceptions:

Inheritance Definition and Programs

Multilevel inheritance:

Super class:

Sub class:

Output:

Example program #2:

Output:

Multiple inheritance:

Encapsulation in java with example program

Class:

Object:

Output: