Variable Declaration

  interface A
    {
      int x = 0; //public, static and final by default
    }

interface learn
   {	
	public int X = 10;		// Valid
	int y;				// Invalid (Must be initialized)
	public static final int Z = 20;	// Valid
	public static int A = 30;		// Valid
	private int B = 40;		// Invalid
	private static final int C = 50;	// Invalid
	protected int D = 60;		// Invalid
	int E = Z + X;			// Valid
	int F = Z + F;			// Invalid   (Forward Reference)
   }    

interface A
   {	
	int x = 10;
   }
interface B
   {
	int y = 20 + A.x;	// Using variable of interface A
   }
class C
   {
	public static void main(String args[])
	    {
		int z = A.x + B.y;
		System.out.println(z);
	    }
   }

Method Declaration:

interface A
   {	
	void fun();
   }
interface B
   {
	void fun();
   }
class C implements A, B
   {
	public void fun() //overridden once
	    {
		System.out.println(“Hello”);
	    }
   }

interface Shape
   {	void area(int L, int B);
   }
class Rect implements Shape
     {	     
     public void area (int L, int B)
		{	
		     System.out.println(“Area of Rect = ” + L * B);
		}
	 }
class IDemo
	{   public static void main (String args[])
	    	{	
            		Shape S = new Rect(); //valid 	
			S.area (10, 20);       // Area of Rect = 200
			}
	}

Multiple Inheritance

Multiple Implementation

interface A
  {	
  int x = 10;
  void show();
  }
interface B
      {	   int x = 20;
	   void show();
      }
class C implements A, B
   { 
    public void show()
	{    
 	       System.out.println(“ x =  ”  + x);    // Error of Ambiguity
			//Using fully qualified name
	       System.out.println(“ x =  ”  + A.x);    // Ok (x = 10)
	       System.out.println(“ x  = ”  + B.x);    // Ok (x = 20)
	}
   }

Difference Between Abstract Class and Interface

• Java interfaces are used to decouple the interface of some components from the implementation. Abstract classes are typically used as base classes for extension by subclasses.
• Opposite to abstract class, variables declared inside an interface are public, static and final by default.
• In comparison with abstract class, methods declared inside an interface are public and abstract by default.
• An abstract class can have abstract as well as concrete methods, whereas , an interface can have only abstract methods.
• An interface can be implemented using keyword “implements” but an abstract class can be extended using keyword “extends” .
• Abstract class can have constructors but interface can’t have constructors.
• Abstract class methods can have access modifiers as public, private, protected & static but in interfaces, methods are implicitly public and abstract; we can’t use any other access modifi ers with interface methods.
• An abstract class can extend another class and implement multiple interfaces but an interface can only extend other interfaces.
• An interface can extend multiple interfaces, whereas, an abstract class can extend only one class.

Default Method - JDK 8

Static Method - JDK 8

Marker Interface - JDK 8