Java 8 Interface Static and Default Methods

• Java 8 introduced two new methods in interface they are
  1.default methods
  2.static methods
• By this interfaces and abstract class are same but still having lot differences like abstract class can have a constructor etc will discuss more before that we need to know about these Java 8 features of interfaces.
• Defaults methods are also called as defender methods can be implemented inside the interface
• Like normal class now with java 8 we can declare static methods in side a interface.
• Lets jump deep into Java 8 default and static methods 

Interface Default Methods in Java 8

• Before Java 8 in interfaces we can and able to declare only abstract methods only.
• If we declare a method without abstract that will be treated as abstract by default.
• As we know all methods in interfaces are by default abstract methods.
• These methods wont have body means implementations
• The class which is implementing this interface need to provide body / implementation for this abstract methods.
• Now with java 8 default methods we can add methods to interface without disturbing existing functionality.
• So instead of overriding now we can inherit these default methods from interfaces
• Defaults methods are also  known as defender methods or virtual extension methods
• Default methods will help us to avoid utility classes.
• We can define utility methods inside the interface and use it in all classes which is implementing.
• One of the major reason to introduce this default methods in java 8 is to support lambda expressions in collections API and to enhance.

1. 
   
2. package com.instanceofjava;
3. interface Java8Interface{
4.  
5. abstract void show();
6.   
7. default void display(){
8.  
9. System.out.println("default method of interface");
10.  
11. }
12. }

1. 
   
2. package com.instanceofjava;
3. class Sample implements Java8Interface {
4.  
5. void show(){
6. System.out.print("overridden method ")
7.  }
8. public static void main(String[] args){
9.   
10. Sample obj= new Sample();
11.  
12. obj.show(); // calling implemented method
13. obj.display(); // calling inherited method
14. Java8Interface.display(); calling using interface name
15.  
16. }
17. }

Output:

1. overridden method
2. default method of interface
3. default method of interface

How to call default methods:

• We can all these default methods by using interface name and also by using object of the class which is implementing.
• From above example
• obj.show(); // calling implemented method
• obj.display(); // calling inherited method
• Java8Interface.display(); calling using interface name

Can we override java 8 default method

• As we discussed above default methods in interfaces are implemented methods with bodies
• Yes we can override same method in class which is implementing this interface.
• Lets see one sample program how to override and what happens if we override

1. 
   
2. package com.instanceofjava;
3. interface InterfaceWithDefault{
4.  
5. default void defMethod(){
6.  
7. System.out.println("default method of interface");
8.  
9. } 
10. }

1. 
   
2. package com.instanceofjava;
3. class Demo implements InterfaceWithDefault{
4.  
5. void defMethod(){
6.  
7. System.out.print("overridden method in class Demo ") 
8.  
9.  }
10. public static void main(String[] args){
11.   
12. Demo obj= new Demo();
13.  
14. obj.defMethod(); // calling overridden method
15. Java8Interface.defMethod(); calling using interface name : interface defMethod will be called
16.  
17. }
18. }

Output:

1. overridden method in class Demo
2. default method of interface

What happens if we implement two interfaces having same default methods

• Now lets see if a class implementing two interfaces which are having same default methods
• Whatever the implementation in the two interfaces defined if we implementing two interfaces which are having a default method in both then compilation error will come if two methods have same signature. works fine if two methods have same name with different arguments.
• Check the below example programs to understand more.

1. 
   
2. package com.instanceofjava;
3. interface A{
4.  
5. default void defMethod(){
6.  
7. System.out.println("default method of interface: A");
8.  
9. }
10.  
11. }

1. 
   
2. package com.instanceofjava;
3. interface B{
4.  
5. default void defMethod(){
6.  
7. System.out.println("default method of interface: B");
8.  
9. } 
10. }

1. package com.instanceofjava;
2. class Demo implements A, B{ // compilation error will come
3.  
4. public static void main(String[] args){
5.   
6. Demo obj= new Demo();
7.   
8. }
9. }

• If we implement two interfaces which are having same method with same parameters then compilation error will occur.
• Duplicate default methods named "defMethod" with the parameters () and () are inherited from the types A and B.
• If we define two methods with different type of parameters then we can work with both interfaces.

1. 
   
2. package com.instanceofjava;
3. interface A{
4.  
5. default void defMethod(){
6.  
7. System.out.println("Default method of interface: A");
8.  
9. }
10.  
11. }

1. 
   
2. package com.instanceofjava;
3. interface B{
4.  
5. default void defMethod(String str){
6.  
7. System.out.println("Default method of interface: B");
8. System.out.println(str);
9.  
10. }
11. }

1. package com.instanceofjava;
2. class Demo implements A, B{ // compilation error will come
3.  
4. public static void main(String[] args){
5.   
6. Demo obj= new Demo();
7. obj.defMethod();
8. obj.defMethod("Java 8")
9.  
10. }
11. }

Output:

1. 
   
2. Default method of interface: A
3. Default method of interface: B 
4. Java 8

Interface Static Methods in Java 8

• Another Java 8 interface method is static method.
• Now we can define static methods inside interface but we can not override these static methods.
• These static method will act as helper methods.
• These methods are the parts of interface not belongs to implementation class objects.

1. 
   
2. package com.instanceofjava;
3. interface StaticInterface{
4.  
5. Static void print(String str){
6.  
7. System.out.println("Static method of interface:"+str);
8.  
9. }
10. }

1. package com.instanceofjava;
2. class Demo implements StaticInterface{
3.  
4. public static void main(String[] args){
5.   
6.  StaticInterface.print("Java 8")
7.  
8. } 
9. }

Output:

1. 
   
2. Static method of interface: Java 8