Interface
1. introduction
2. interface declaration and implementation
3. extends vs implements
4. interface methods
5. interface variables
6. interface naming conflicts
a. method naming conflict
b. variable naming conflicts
7. marker interface
8. adapter classes
9. interface vs abstract class vs concrete class.
10. differences between interface and abstract class.
11. conclusion
Definition 1 :Any service requirement specification(SRS) is considered as an interface.
Example 1. jdbc api acts as requirement specification to develop database driver database vendor is responsible to implement JDBC API
Example 1.Servlet API acts as requirement specification to develop web server web server vendor is responsible to implement servlet API.
Definition 2 : from client point of view an interface defines a set of services what he is expecting from service provider and from service provider point of view an interface defines the set of services what he is offering, Hence any contract between client and service provider is considered as an interface.
Example 1. Throw bank ATM GUI screen bank people are highlighting the set of services what they are offering at same time the same GUI Screen represents the set of services what customer is expecting hence this GUI screen acts as contract between customer and bank people.
Definition 3 : Inside interface every method is always abstract whether we are declaring or not. Hance interface is considered as 100% pure abstract class.
Summery Definition: Any service requirement specification or any contract between client or service provider are 100% pure abstract class is nothing but interface.
Whenever we are implementing an interface, for each and every method of that interface we have to provide implementation, otherwise we have to declare class as abstract, then next level child class is responsible to provide implementation.
Every interface method is always public and abstract whether we are declaring or not. Hence whenever we are implementing an interface method compulsory we should declare as public otherwise we will get compile time error.
A class can extends only one class at a time.
An interface can extends any number of interfaces simultaneously.
interface A{
}
interface B{
}
interface C extends A,B{
}
A class can implement any number of interfaces simultaneously.
A class extend another class and can implement any number of interfaces simultaneously.
Class A extends B implements C, D, E{
}
Q. Which of the following is true or valid?
A class can extend any number of classes at a time.
A class can implement only one interface at a time.
interface can extends only one interface at a time.
An interface can implement any number of interfaces simultaneously.
A class can extend another class or can implement an interface but not simultaneously.
None of the above.
Ans. 6
Q. Consider the following expression
X extends Y
for which of the following possibility of X and Y the above expression is valid.
Both X and Y should be only Classes.
Both X and Y should be only interfaces.
Both X and Y should be either Classes or interfaces.
No restriction.
Ans. 3
Q. Consider the following expression
X extends Y, Z
for which of the following possibility of X and Y the above expression is valid.
Both X and Y should be only Classes.
Both X and Y should be only interfaces .
Both X and Y should be either Classes or interfaces.
No restriction.
Ans. 2
Q. Consider the following expression
X implements Y, Z
Ans. x should be Class and y, z Interface
Q. Consider the following expression
X extends Y implements Z
Ans. X and Y classes and Z interface
Q. Consider the following expression
X implements Y extends Z
Ans. CompileTimeError: because we have to take extends first and then implements.
Every method present inside interface is always public and abstract whether we are declaring or not.
interface Intref{
void m1();
}
public: To make this method available to every implementation class.
abstract : Implementation class is responsible to provide implementation
Hence inside interface the following method declarations are equal.
void m1();
public void m1();
abstract void m1();
public abstract void m1();
all above method declarations are equal inside interface.
As every interface method is always public and abstract. So we can't declare interface method with the following modifiers
1. private 2. protected
3. static 4. final 5. synchronized 6. strictfp 7. native 8. abstract.
Q. Which of the following method declarations are allowed inside Interface.
public void m1(){}
private void m1();
protected void m1();
static void m1();
public abstract native void m1();
abstract public void m1();
Ans. 6
An interface can contain variables the main purpose of interface variable is to define requirement level constants.
Every interface variable is always public static final whether we are declaring or not.
interface Intref{
int x = 10;
}
public: To make this variable available to every implementation class.
static: without existing object also implementation class has to access this variable.
final : If one implementation class changes value then remaining classes will be affected. To restrict this every interface variable is always final.
Hence within the interface the following variable declarations are equal.
int x = 10;
public int x = 10;
static int x = 10;
public static int x = 10;
public final int x = 10;
public final int x = 10;
static final int x = 10;
public static final int x = 10;
all above lines are equal in interface.
As every interface variable is always public, static, final we can't declare with the following modifiers.
a. private b. protected c. transient d. volatile.
For interface variables compulsory we should perform initialization at the time of declaration otherwise we will get compile time error.
interface Interef{
int x; // CE : = expected.
}
Q. Inside interface which of the following variable declarations allowed.
a. int x; //invalid
b. private int x = 10; //invalid
c. protected int x = 10; //invalid
d. volatile int x = 10; //invalid
e. transient int x = 10; //invalid
f. public static int x = 10; //valid
Ans. f
inside implementation class we can access interface variables but we can't modify it's value.
interface Interf{
int x = 10;
}
class Test implements Interf
{
public static void main(String[] args){
x = 777; // CE : can't assign value to final variable X.
}
}
class Test implements Interf{
public static void main(String[] args){
int x = 777; //Valid local variable
sopln(x);
}
}
Case 1 : if two interfaces contains a method with same signature and same return type then in the implementation class we have to provide implementation for only one method.
interface Left{
public void m1();
}
interface Right {
public void m1();
}
class Test implements Left, Right{
public void m1(){
}
}
Case 2 : If two interfaces contains a method with same name but different argument types then in the implementation class we have to provide implementation for both methods and these methods acts as overloaded methods.
interface Left{
public void m1();
}
interface Right {
public void m1(int x);
}
class Test implements Left, Right{
public void m1(){
}
public void m1(int x){
}
}
Note:- If two interfaces contains a method with same signature but different return types then it is impossible to implement both interfaces simultaneously (if return types are not co-variant).
interface Left{
public void m1();
}
interface Right {
public int m1();
}
we can't right any java class which implements both interfaces simultaneously.
Q. Is a java class can implement any interfaces simultaneously?
Ans. Yes except a particular case.
If two interfaces contains a method with same signature but different return types then it is impossible to implement both interfaces simultaneously.
Two interfaces can contain a variable with same name and there may be a chance of variable naming conflicts but we can solve this problem by using interface names.
interface Left{ int x = 100;
}
interface Right{
int x = 888;
}
class Test implements Left, Right{
public static void main(String[] args){
//System.out.println(x);//CE : reference
to x is ambiguous.
System.out.println(Left.x); //100
System.out.println(Right.x); //888
}
}
If an interface doesn't contain any methods and by implementing that interface if our objects will get some ability such type of interfaces are called marker interfaces or ability interface or tag interface.
Example: Serializable, Clonable, RandomeAccess, SingleThreadModel etc.
these are marked for some ability
Example:-
By implementing serializable interface our objects can be saved to the file and can travel across network.
By implementing clonable interface our objects are in a position to produce exactly duplicate cloned objects.
Q. Without having any methods how the object will get some ability in marker interfaces?
Ans. internally JVM is responsible to provide required ability.
Q. Why JVM is providing required ability in marker interfaces?
Ans. To reduce complexity of programming and to make java language as simple.
Q. Is it possible to create our own marker interface?
Ans. Yes, but customization of JVM is required.
Adapter class is a simple java class that implements an interface with only empty implementation.
interface intrf
{
void m1();
void m2();
void m3();
void m4();
.
.
.
void mn();
}
class Adaptorx implements intrf
{
void m1(){}
void m2(){}
void m3(){}
void m4(){}
.
.
.
void mn(){}
}
If we implement an interface, for each and every method of that interface compulsory we should provide implementation whether it is required or not required.
class Test implements Interf{
m1(){}
m2(){}
m3(){}
m4(){}
.
.
.
mn(){}
}
The problem in this approach is it increases length of the code and reduces readability. We can solve this problem by using adapter classes.
Instead of implementing interface if we extend adapter class we have to provide implementation only for required methods and we are not responsible to provide implementation for each and every method of interface so that length of the code will be reduced.
class Test extends Adapterx{
m3{
_
_
_
}
}
class Demo extends Adapterx{
m10{
_
_
_
}
}
class SampleOperations extends Adapterx{
m5{
_
_
_
}
m7{
_
_
_
}
}
Example: we can develop a servlet in the following 3 ways.
By implementing Servlet Interface
By extending GenericServlet.
By extending HttpServlet
If we implement servlet interface for each and every method of that interface we should provide implementation.
It increases length of the code and reduces readability
Instead of implementing servlet interface directly if we extend GenericServlet we have to provide implementation only for service method and for all remaining methods we are not required to provide implementation. Hence more or less generic servlet acts as adapter class for servlet interface.
Note : marker interface and adapter classes simplifies complexity of programming and these are best utilities to the programmer and programmers life will become simple.
If we don't know anything about implementation just we have requirement specification then we should go for interface
Example- Servlet
If we are talking about implementation but not completely(Partial implementation). Then we should go for abstract class.
Example: GenericServlet, HttpServlet etc.
if we are talking about implementation completely and ready to provide service then we should go for concrete class.
Example: MyOwnServlet
Interface
If we don't know anything about implementation and just we have requirement specification then we should go for interface.
Inside interface every method is always public and abstract whether we are declaring or not, hence interface is considered as 100% pure abstract class.
As every interface method is always public and abstract and hence we can't use modifiers.
a. private b. protected c. final d. static d. synchronized e. native f. strictfp
Every variable present inside interface is always public static final whether we are declaring or not.
As every interface variable is always public static final we can't declare modifiers.
a. private, b. protected c. volatile d. transient.
For interface variables compulsory we should perform initialization at the time of declaration only, otherwise we will get compile time error.
inside interface we can't declare static and instance blocks.
Inside interface we can't declare constructors.
Abstract Class
If we are talking about implementation but not completely (partial implementation) then we should go for abstract class.
Every method present inside abstract class need not be public and abstract and we can take concrete methods also.
There are no restriction on abstract class methods modifiers.
Every variable present inside abstract class need not be public static final.
There are no restrictions on abstract class variable modifiers.
For abstract class variables we are not required to perform initialization at the time of declaration.
Inside abstract class we can declare static and instance blocks.
Inside abstract class we can declare constructor.
Q. Any way we can't create object for abstract class but abstract class can contain constructor. what is the need?
Ans. a. Abstract class constructor will be executed whenever we are creating child class object to perform initialization of child object.
abstract class Person{
String name;
String gender;
//100 properties.
}
class Student extends Person{
int rollNo;
Stucent(100 properties){
this.name = name;
this.age=age;
.
.
.
this.rollNo = rollno;
}
}
Student student = new Student(101 properties);
as like above we created 1000 classes - by above code, code redundancy problem is there.
abstract class Person{
String name;
String gender;
//100 properties.
Person(100 properties){
this.name = name;
this.gender = gender;
.
100 lines of code; // this code will work for every child object
.
}
}
class Student extends Person{
int rollNo;
Student(100 properties){
super(100 properties);
this.rollNo = rollno;
}
}
Student s1 = new Student(101 properties);
less code and code re-usability.
Note : 1. Either directly or indirectly we can't create object for abstract class.
Q. anyway we can't create objects for abstract class and interface but abstract class can contain constructor but interface doesn't contain constructor. What is the reason?
Ans : The main purpose of constructor is to perform initialization of instance variables.
abstract class can contain instance variables which are required for child object. To perform initialization initialization of child those instance variables constructor is required for abstract class.
But every variable present inside interface is always public static final whether we are declaring or not and there is no chance of existing instance variable inside interface. Hence constructor concept is not required for interface.
Whenever we are creating child class object parent object won't be created just parent class constructor will be executed for child object purpose only.
class P{
P(){
sopln(this.hashCode()); //output : 100
}
}
class C extends P{
C(){
sopln(this.hashCode()); //output : 100
}
}
class Test{
public static void main(String[] args){
C c = new C();
sopln(c.hashCode()); //output : 100
}
}
Q. inside interface every method is always abstract and we can take only abstract methods in abstract class also then what is difference between interface and abstract class i.e is it possible to replace interface with abstract class?
We can replace interface with abstract class but it is not a good programming practice
this is something like recruiting an IAS officer for swiping activity.
if every thing is abstract then it is highly recommended to go for interface but not for abstract class.
1. While extending abstract class it is not possible to extends any other class and hence we are missing inheritance benefit.
while implementing interface we can extend some other class and hence we won't miss any inheritance benefit.
in abstract class case object creation is costly.
e.g Test t = new Test(); //2 minutes execution time;
in interface case object creation is not costly.
Test t = new Test(); //2 seconds execution time.