Interface

Interface in Java

Interface is similar to class which is collection of public static final variables (constants) and abstract methods.

The interface is a mechanism to achieve fully abstraction in java. There can be only abstract methods in the interface. It is used to achieve fully abstraction and multiple inheritance in Java.

Why we use Interface ?

• It is used to achieve fully abstraction.
• By using Interface, you can achieve multiple inheritance in java.
• It can be used to achieve loose coupling.

properties of Interface

• It is implicitly abstract. So we no need to use the abstract keyword when declaring an interface.
• Each method in an interface is also implicitly abstract, so the abstract keyword is not needed.
• Methods in an interface are implicitly public.
• All the data members of interface are implicitly public static final.

How interface is similar to class ?

Whenever we compile any Interface program it generate .class file. That means the bytecode of an interface appears in a .class file.

How interface is different from class ?

• You can not instantiate an interface.
• It does not contain any constructors.
• All methods in an interface are abstract.
• Interface can not contain instance fields. Interface only contains public static final variables.
• Interface is can not extended by a class; it is implemented by a class.
• Interface can extend multiple interfaces. It means interface support multiple inheritance

Behavior of compiler with Interface program

In the above image when we compile any interface program, by default compiler added public static final before any variable and public abstract before any method. Because Interface is design for fulfill universal requirements and to achieve fully abstraction.

Declaring Interfaces:

The interface keyword is used to declare an interface.

Example

interface Person
{  
 datatype variablename=value;
 //Any number of final, static fields
 returntype methodname(list of parameters or no parameters)
 //Any number of abstract method declarations
}  

Explanations

In the above syntax Interface is a keyword interface name can be user defined name the default signature of variable is public static final and for method is public abstract. JVM will be added implicitly public static final before data members and public abstract before method.

Example

public static final datatype variable name=value; ----> for data member
public abstract returntype methodname(parameters)---> for method

Implementing Interfaces:

A class uses the implements keyword to implement an interface. The implements keyword appears in the class declaration following the extends portion of the declaration.

Example

interface Person
{  
void run();
}  
class Employee implements Person
{
public void run()
{
System.out.println("Run fast");
} 
}

When we use abstract and when Interface

If we do not know about any things about implementation just we have requirement specification then we should be go for Interface

If we are talking about implementation but not completely (partially implemented) then we should be go for abstract

Rules for implementation interface

• A class can implement more than one interface at a time.
• A class can extend only one class, but implement many interfaces.
• An interface can extend another interface, similarly to the way that a class can extend another class.

Relationship between class and Interface

• Any class can extends another class

• Any Interface can extends another Interface.

• Any class can Implements another Interface

• Any Interface can not extend or Implements any class.

Difference between Abstract class and Interface

	Abstract class	Interface
1	It is collection of abstract method and concrete methods.	It is collection of abstract method.
2	There properties can be reused commonly in a specific application.	There properties commonly usable in any application of java environment.
3	It does not support multiple inheritance.	It support multiple inheritance.
4	Abstract class is preceded by abstract keyword.	It is preceded by Interface keyword.
5	Which may contain either variable or constants.	Which should contains only constants.
6	The default access specifier of abstract class methods are default.	There default access specifier of interface method are public.
7	These class properties can be reused in other class using extend keyword.	These properties can be reused in any other class using implements keyword.
8	Inside abstract class we can take constructor.	Inside interface we can not take any constructor.
9	For the abstract class there is no restriction like initialization of variable at the time of variable declaration.	For the interface it should be compulsory to initialization of variable at the time of variable declaration.
10	There are no any restriction for abstract class variable.	For the interface variable can not declare variable as private, protected, transient, volatile.
11	There are no any restriction for abstract class method modifier that means we can use any modifiers.	For the interface method can not declare method as strictfp, protected, static, native, private, final, synchronized.

Example of Interface

interface Person
{  
void run();  // abstract method
}  
class A implements Person
{  
public void run()
{
System.out.println("Run fast");
}   
public static void main(String args[])
 {  
 A obj = new A();  
 obj.run();  
 }  
}  

Output

Run fast

Multiple Inheritance using interface

Example

interface Developer
{  
void disp();
}  
interface Manager
{
void show();
} 

class Employee implements Developer, Manager
{
public void disp()
{
System.out.println("Hello Good Morning");  
}
public void show()
{
System.out.println("How are you ?");  
}
public static void main(String args[])
{
Employee obj=new Employee();
obj.disp();
obj.show();
}  
} 

Output

Hello Good Morning
How are you ?

Marker or tagged interface

An interface that have no member is known as marker or tagged interface. For example: Serializable, Cloneable, Remote etc. They are used to provide some essential information to the JVM so that JVM may perform some useful operation.

Example

//Way of writing Serializable interface  
public interface Serializable
{  
}  

Why interface have no constructor ?

Because, constructor are used for eliminate the default values by user defined values, but in case of interface all the data members are public static final that means all are constant so no need to eliminate these values.

Other reason because constructor is like a method and it is concrete method and interface does not have concrete method it have only abstract methods that's why interface have no constructor.

Overriding

Method Overriding in Java

Whenever same method name is existing in both base class and derived class with same types of parameters or same order of parameters is known as method Overriding. Here we will discuss about Overriding in Java.

Note: Without Inheritance method overriding is not possible.

Advantage of Java Method Overriding

• Method Overriding is used to provide specific implementation of a method that is already provided by its super class.
• Method Overriding is used for Runtime Polymorphism

Rules for Method Overriding

• method must have same name as in the parent class.
• method must have same parameter as in the parent class.
• must be IS-A relationship (inheritance).

Understanding the problem without method overriding

Lets understand the problem that we may face in the program if we do not use method overriding.

Example Method Overriding in Java

class Walking
{  
void walk()
{
System.out.println("Man walking fastly");
}  
}  
class OverridingDemo
{  
public static void main(String args[])
{  
Man obj = new Man();  
obj.walk();  
}
}

Output

Man walking

Problem is that I have to provide a specific implementation of walk() method in subclass that is why we use method overriding.

Example of method overriding in Java

In this example, we have defined the walk method in the subclass as defined in the parent class but it has some specific implementation. The name and parameter of the method is same and there is IS-A relationship between the classes, so there is method overriding.

Example

class Walking
{  
void walk()
{
System.out.println("Man walking fastly");
}  
}  
class Man extends walking
{  
void walk()
{
System.out.println("Man walking slowly");
}
}

class OverridingDemo
{  
public static void main(String args[])
{  
Man obj = new Man();  
obj.walk();  
}
}

Output

Man walking slowly

Note: Whenever we are calling overridden method using derived class object reference the highest priority is given to current class (derived class). We can see in the above example high priority is derived class.

Note: super. (super dot) can be used to call base class overridden method in the derived class.

Accessing properties of base class with respect to derived class object

class A
{
int x;
void f1()
{
x=10;
System.out.println(x);
}
void f4()
{
System.out.println("this is f4()");
System.out.println("-----------------");
}
};
class B extends A
{
int y;
void f1()
{
int y=20;
System.out.println(y);
System.out.println("this is f1()");
System.out.println("------------------");
}
};
class C extends A
{
int z;
void f1()
{
z=10;
System.out.println(z);
System.out.println("this is f1()");
}
};
class Overide
{
public static void main(String[] args)
{
A a1=new B();
a1.f1();
a1.f4();
A c1=new C();
c1.f1();
c1.f4();
}
}

Example of Implement overriding concept

class Person
{
String name;
void sleep(String name)
{
this.name=name;
System.out.println(this.name +"is sleeping+8hr/day");
}
void walk()
{
System.out.println("this is walk()");
System.out.println("-----------------");
}
};
class Student extends Person
{
void writExams()
{
System.out.println("only student write the exam");
}
void sleep(String name)
{
super.name=name;
System.out.println(super.name +"is sleeping 6hr/day");
System.out.println("------------------");
}
};
class Developer extends Person
{
public void designProj()
{
System.out.println("Design the project");
}
void sleep(String name)
{
super.name=name;
System.out.println(super.name +"is sleeping 4hr/day");
System.out.println("------------------");
}
};
class OverideDemo
{
public static void main(String[] args)
{
Student s1=new Student();
s1.writExams();
s1.sleep("student");
s1.walk();
Developer d1=new Developer();
d1.designProj();
d1.sleep("developer");
}
}

Difference between Overloading and Overriding

	Overloading	Overriding
1	Whenever same method or Constructor is existing multiple times within a class either with different number of parameter or with different type of parameter or with different order of parameter is known as Overloading.	Whenever same method name is existing multiple time in both base and derived class with same number of parameter or same type of parameter or same order of parameters is known as Overriding.
2	Arguments of method must be different at least arguments.	Argument of method must be same including order.
3	Method signature must be different.	Method signature must be same.
4	Private, static and final methods can be overloaded.	Private, static and final methods can not be override.
5	Access modifiers point of view no restriction.	Access modifiers point of view not reduced scope of Access modifiers but increased.
6	Also known as compile time polymorphism or static polymorphism or early binding.	Also known as run time polymorphism or dynamic polymorphism or late binding.
7	Overloading can be exhibited both are method and constructor level.	Overriding can be exhibited only at method label.
8	The scope of overloading is within the class.	The scope of Overriding is base class and derived class.
9	Overloading can be done at both static and non-static methods.	Overriding can be done only at non-static method.
10	For overloading methods return type may or may not be same.	For overriding method return type should be same.

Note: In overloading we have to check only methods names (must be same) and arguments types (must be different) except these the remaining like return type access modifiers etc. are not required to check 
But in overriding every things check like method names arguments types return types access modifiers etc.