Java – Inner Class Diamond Operator

Java Diamond Operator

The diamond operator was introduced in Java 7 to make code more readable for . A generic is a type of argument. Using generic we can pass any kind of object to be processed by the . For example, if we are creating a list of before Java 7, then we”ve to use the following syntax to instantiate a list of strings with an object.

List<String> listOfStrings = new ArrayList<String>();

From Java 7 onwards, we can use diamond operator to simplify the above syntax as following −

List<String> listOfStrings = new ArrayList<>();

But it could not be used with inner classes. For example, we cannot omit the object type from diamond operator in below syntax prior to Java 9.

Handler<Integer> intHandler = new Handler<Integer>(1) {
   @Override
   public void handle() {
      System.out.println(content);
   }
};

Diamond Operator in Anonymous Class

In Java 9, the diamond operator can be used with an anonymous class as well to simplify code and improve readability.

Handler<Integer> intHandler = new Handler<>(1) {
 @Override
 public void handle() {
	System.out.println(content);
 }
};

Diamond Operator in Java 7, Java 8

In below example, we”ve created anonymous classes for an abstract class Handler accepting a generic argument and pass the object type while creating the anonymous class as we have to pass the type argument otherwise program won”t compile.

Example

public class Tester {
   public static void main(String[] args) {
      // create an Anonymous class to handle 1
	  // Here we need to pass Type arguments in diamond operator 
	  // before Java 9 otherwise compiler will complain error
      Handler<Integer> intHandler = new Handler<Integer>(1) {
         @Override
         public void handle() {
            System.out.println(content);
         }
      };
      intHandler.handle();
      // create an Anonymous class to handle 2	  
      Handler<? extends Number> intHandler1 = new Handler<Number>(2) {
         @Override
         public void handle() {
            System.out.println(content);
         }
      };
      intHandler1.handle();
      Handler<?> handler = new Handler<Object>("test") {
         @Override
         public void handle() {
            System.out.println(content);
         }
      };
      handler.handle();    
   }  
}
abstract class Handler<T> {
   public T content;

   public Handler(T content) {
      this.content = content; 
   }
   
   abstract void handle();
}

Output

Let us compile and run the above program, this will produce the following result −

1
2
Test

Diamond Operator Java 9 Onwards

With Java 9, we can use <> operator with anonymous class as well as shown below.

Example

In below example, we”ve created anonymous classes for an abstract class Handler accepting a generic argument but without the object type while creating the anonymous class as we need not to pass the type argument. Compiler infers the type itself.

public class Tester {
   public static void main(String[] args) {
      // create an Anonymous class to handle 1
	  // Here we do not need to pass Type arguments in diamond operator 
	  // as Java 9 compiler can infer the type automatically
      Handler<Integer> intHandler = new Handler<>(1) {
         @Override
         public void handle() {
            System.out.println(content);
         }
      };
      intHandler.handle();
      Handler<? extends Number> intHandler1 = new Handler<>(2) {
         @Override
         public void handle() {
            System.out.println(content);
         }
      };
      intHandler1.handle();
      Handler<?> handler = new Handler<>("test") {
         @Override
         public void handle() {
            System.out.println(content);
         }
      };

      handler.handle();    
   }  
}

abstract class Handler<T> {
   public T content;

   public Handler(T content) {
      this.content = content; 
   }
   
   abstract void handle();
}

Output

Let us compile and run the above program, this will produce the following result −

1
2
Test