Data variable in an interface

An interface can contain only constants. That means the variables are-

• public
• final
• static

As they are constants, they cannot be changed by the subclasses.

Syntax-

public static final type variable name= value;

What is Implementing an Interface?

While a class implements an interface, it makes a contract with the interface to perform specific behaviour of the interface. If the class fails to perform all behaviours of the interface, the class must declare itself abstract.

A class uses the implements keyword to implement an interface. The implement keyword is placed in the class deceleration following the extends portion of the deceleration.

An interface can extend another interface but not a class. Java does not support multiple inheritances but it supports multiple interface inheritance.

The class has to override all the abstract methods defined in the interface. There are few rules around. They are as follows:

• Checked Exceptions should not be declared on implementation methods other than the ones declared by the interface method or subclass of those declared by the interface method.
• The signature of the interface method and the same return type or subtype should be maintained when overriding the methods.
• An implementation class itself can be abstract and if so, the interface methods need not be implemented.
• A class can implement more than one interface at a time but can extend only one class.
• An interface can extend to another interface.

Class structure implementing the interface:

class MyClass extends SuperClass implements interface1,interface2,interface3......intefaceN{
//body of the class
}
 

The member variables present in an interface should be static and final.
Example:

interface Pet{
public void test();
}
public class Cat implements Pet{
public void test()
{
System.out.println("Interface method implemented in the child class");
}
public static void main(String args[])
{
Pet p=new Cat();
p.test();
}
}
 

The output of the code:
$javac Cat.java
$java -Xmx128M -Xms16M Cat
Interface method implemented in the child class

Accessing implementing class objects through interface reference:-

A variable can be declared as an object reference. This variable uses an interface instead of a class type. If an instance of any class implements the declared interface can also be refused by such variable. When a call is made through one of this reference, the actual correct version is called based on the actual instance.

One more example:

interface Area{
    final static float PI=3.14F;
    float compute(float x,float y);
}
class Rectangle implements Area{
    public float compute(float x,float y)
    {
        return x*y;
    }
}
class Circle implements Area{
    public float compute(float x,float y)
    {
        return PI*x*y;
    }
}
public class MYInterfaceTest{
    public static void main(String args[])
    {
        Rectangle rect=new Rectangle();
        Circle cir=new Circle();
        Area area;
        area=rect;
        System.out.println("Area of the rectangle "+area.compute(10,20));
        area=cir;
        System.out.println("Area of the rectangle "+area.compute(10,20));
    }
}
 

The output of the code:
$javac MYInterfaceTest.java
$java -Xmx128M -Xms16M MYInterfaceTest
Area of the rectangle 200.0
Area of the rectangle 628.0

A more real-time example:

Assume that there are two classes for an organization

• One PermanentEmployee
• One Vendor Employee

Now each class has their unique components called Qualification,MainCompany,Current_Project,Current_Project,Experience(),Next_Project().

Now if the Organization wants to have a resume for both types of Employees. So the Organization class define an interface called Resume.

interface Resume{
....
void EmpResume();
}
class  PermanentEmployee Extends Employee implements Resume{
Qualification;//member variables
Current_Project;//member variables
Experience(){};//member function
public void EmpResume()
{
....
//code to implement the resume
}
}
class VendorEmployee implements Resume{
MainCompany;//member variables
Current_Project;//member variables
Next_Project(){}//member function
public void EmpResume()
{
....
//code to implement the resume
}
}
//so the implementation of the code goes like
PermanentEmployee pe=new PermanentEmployee();
pe.EmpResume();
VendorEmployee ve=new VendorEmployee();
ve.EmpResume();
//Futher more we can implement an array of Resume. This is possible as both implement Resume hence they become same type.
Resume listOfResume=new Resume[10];
listOfResume[0]=new PermanentEmployee;
listOfResume[0]=new VendorEmployee;
....
.....

Interface methods

Interface methods are those methods that are abstract methods appearing in the interface. If a class implements an interface but does not implement one or more of the interface methods, the whole class becomes an abstract class and can not be instantiated.

Methods are abstract in the interface. So they do not have anybody. The methods main content parameter list followed by the semicolon. All methods are public and have an abstract modifier. A static method cannot be declared inside an interface.

The interface of a method consists of the name of the method, it returns type and number and types of its parameters.

All methods present in an interface are public by default. This means when we implement an interface, we need to define the methods.

This is the reason why we need to define them as public. Otherwise a default or friendly will restrict the accessibility of the method during inheritance.(not allowed in java).

A class must define all the methods of the interfaces it is implementing. Additionally, the class may define extra methods of its own. These methods are not part of the interfaces it is implementing. These extra methods are called non-interface methods.

interface MyInterface{
public abstractvoid function1();
public abstractvoid function2();
}
class class1 implements MyInterface{
public void function1(){
...
...
}
}
class class2 extends class1{
public void function2(){
...
...
}
}

The interface contains two methods function1() and function2().class1 implements the interface but does not contain the function2() which is a part of the interface. This means that class1 becomes an abstract class.

It can not be instantiated. However, once we create a subclass class2 of class1 and define function2(). That means class2 has successfully implemented all methods of interface-MyInterface.So class2 can be instantiated.
When to use interface and when to use an abstract class?
We need to use an abstract class when a template needs to be defined for a group of subclasses. But we need to use interface when a role needs to be defined for other classes regardless of the inheritance tree of these classes.

interface Response{
static final int yes=1;
static final int No=2;
}
class Enquire implements Response{
public int ask(){
System.out.println("Have you seen google -Type your response: yes-1 No-2");
int type=0;
try{
type=System.in.read();
}
catch(Exception e){}
return type;
}
}
public class MyServey implements Response{
public static void main(String args[])
{
Enquire myResp=new Enquire();
reply(myResp.ask());
reply(myResp.ask());
}
static void reply(int type)
{
switch(type){
case yes:
System.out.println("You have seen google.Thanks!");
break;
case No:
System.out.println("You have not seen google.Thanks!");
break;
default:
System.out.println("You have given a valid input!");
}
}
}

import java.awt.Graphics;
interface BoxDimention{
int top;
int bottom;
int left;
int right;
}
interface DrawBox extends BoxDimention{
void draw(int a,int b,int c,int d);
}
class Box implements BoxDimention{
public void Area(){
....
//code
}
}
class ShowBox implements BrawBox{
int x,y,z,w;
void draw(int a,int b,int c,int d){
x=a;
y=b;
z=c;
w=d;
void paint(Graphics g){
g.drawRect(x,y,z,w);
}
}
}
 

import java.awt.Graphics;
interface BoxDimention{
int top;
int bottom;
int left;
int right;
}
interface DrawBox{
void draw(int a,int b,int c,int d);
}
interface Box extends BoxDimention,DrawBox{
void area();
}
class ShowBox implements Box{
//code for area
//code for draw
}
 

Drawable figure;//declare a variable of type interface-Drawable.It can refer to any object 
//that implement Drawable interface.
figure=new Line();// figure refers to Line object
figure.draw(g);//calls the draw() method of class Line
figure=new Circle();// figure refers to Circle object
figure.draw(g);//calls the draw() method of class Circle
 

package test
public class TestInterfaceDemo
public static void main(String[] args)
TestInterface testInterface = new TestInterfaceImpl()
//... calling Object class process - toString - Alright
System.out.println(testInterface.toString())
//... calling the interface technique - testMethod - Ok
testInterface.testMethod()
//... calling the implementing class method - implClassMethod - error
//testInterface.implClassMethod()
//... calling the same approach after casting the reference - Okay
((TestInterfaceImpl)testInterface).implClassMethod()
}
}
package Test;
public class TestInterfaceImpl implements TestInterface{
public void testMethod(){
System.out.println("Examination Technique if the Interface")
public void implClassMethod(){
system.out.println("Exam Interface Impl Course Technique")
}
}

Interface Printer {
Void display ( int x);
}
Class Laptop implements Printer {
Public void display ( int x)
{
System.Out.println(" laptops printer"+" port"+x);
}
}
Class desktop implements printer {
public void display ( int x){
System. Out.printh(" desktopss printer"+" port"+x);
     }
}

public static void main(String args[ ]){
Printer P1= new Laptop( );
Printer P2= new Desktop( );
P1. display (8080);
P2. display (7880);
Printer P3;
P3 = P1;
P3.display(5555);
P3 = P2
P2.display(8888);
 }
}