Implicit method declaration in Java Interfaces

-

Ever noted that in the Comparator<T> interface we have two abstract methods:

·         static compare(T o1, T o2);
·         boolean equals(Object obj);

Yet the interface is declared as a functional interface. We can create an instance of the Comparator<T> even without extending the method “equals”, because all classes the methods in the class Object  is declared implicitly in an interface, and the method “equals” is the member of the class “Object”. If you choose you can override it or else leave it. You would always have a concrete implementation of the method “equals”. The question now arises, why was it declared in the Comparator <T> interface in the first place? Logically speaking there was no need to do so. The only reason it is there is for documentation inside the javadoc so that you know that equals forms an integral part of the Comparator interface. Nothing else. If you do not override, there is no harm done.

Let us see a point in the interface member declaration from Java:
If an interface has no direct superinterfaces, then the interface implicitly declares a public abstract member method m with signature s, return type r, and throws clause t corresponding to each public instance method m with signature s, return type r, and throws clause t declared in Object, unless an abstract method with the same signature, same return type, and a compatible throws clause is explicitly declared by the interface.

This actually says that if there are no direct superinterfaces for an interface, then all the methods of the class Object are declared abstract implicitly in the interface. This is done so that if you take a reference as that of the interface you could still invoke the methods of Object class such as “equals” or “toString” or any other. Let us look at the interface declaration below:


public interface MyInterface {
      
       // abstract method
       public void foo();
      
              // methods which have same signature
       // as the methods in the Object class
       boolean equals(Object obj);     
       public String toString();
}

In this interface we have an abstract method “foo” and two abstract methods which (have exact signature) belong to the class “Object”. We can only override the method “foo” if we so wish, without overriding “equals” and “toString”. Since the latter two methods were already implicitly declared we can use them even when we refer to them as the interface.


public class MyInterfaceProcessor implements MyInterface {

       @Override
       public void foo() {       
              // do something
              System.out.println("Printing MyInterface .... !!!");
       }
             
       public static void main(String... args) {
             
              // the processor is taken as MyInterface
              MyInterface mfi = new MyInterfaceProcessor();
             
              // executing foo() method
              mfi.foo();
             
              // it can also call toString() method
              // even if the method is not declared in the
              // MyInterface interface
              System.out.println("To String = " + mfi.toString());
       }
}


Comments

Post a Comment

Popular posts from this blog

Java Generics - 7. Upper and Lower Bounds

-
Image
This is part 7 of the 9 part series on Java Generics  Prev Topic Typed Classes as method parameters Topics 1. Introduction 2. Bounding 3. Multiple bounding 4. Generic Methods 5. Wildcards 6. Typed Classes as method parameters 7. Upper and Lower Bounds 8. Target Types 9. Type Erasure Next Topic Target Types Java Generics - Upper and Lower Bounds This is going to be a really long blog, so please bear with me. Declaring Generic Variables You can also use generics to declare the variables. In other work you can choose which types can be assigned to a variable. The rules are more or less the same as for methods. You cannot define a type variable, like you could for the methods. Thus the declaration below makes no sense.         // invalid        private <E extends Fruit> E var1 = null ;      ...
Read more

Java Functional Programming : 3. The java.util.function Library

-
Image
This is the multi part series on Java Functional Programming 3. The java.util.function Library In most cases you might not need to declare your own functional interface as Java gives you a standard set of interfaces to save your time. In case you’d like to work with a function of two parameters of the same type, you could probably use the interface java.util.function.BinaryOperator<T> for the same activity. (More on the package java.util.function is to follow). As a shortcut, you’d probably prefer to keep things simple without the need of an extra interface declaration. Lets look at the constructs below:        BinaryOperator<Integer> binAdd = ( a , b ) -> a + b ;        System. out .println( "Bin Add 2, 3 = " + binAdd .apply(2, 3)); The lambda expressions can be passed as a parameter into the methods. Let us define a method which doubles the value given by the lambda ex...
Read more

Java Generics - 3. Multiple bounding

-
Image
This is part 3 of the 9 part series on Java Generics  Prev Topic Bounding Topics 1. Introduction 2. Bounding 3. Multiple bounding 4. Generic Methods 5. Wildcards 6. Typed Classes as method parameters 7. Upper and Lower Bounds 8. Target Types 9. Type Erasure Next Topic Generic Methods Java Generics - Multiple bounding Refer back to out Fruit and Grain hierarchy. Remember few of the Grains and Fruits also implement the interface Exportable . What if you wanted the generic class to be used only with the type Exportable? We already discussed that earlier. The declaration extends makes no distinction whether the F extends a class or an interface. The generics give us even more flexibility. Say you wanted you generic class to be used with a type Fruit which is Exportable ? Here the class to be used with the Generic types should be both – Fruit & Exportable . Is that possible with generics? Yes of cou...
Read more