Java 9: ​​clases internas anónimas y operador Diamond

En esta publicación, discutiremos el mejora del operador de diamantes introducido en Java SE 9.

¿Qué es un comerciante de diamantes?

El operador de diamante se introdujo como una nueva característica en Java SE 7. El propósito del operador de diamante es evitar el código redundante dejando el tipo genérico en el lado derecho de la expresión.

// This is before Java 7. We have to explicitly mention generic type 
// in the right side as well. 
List<String> myList = new ArrayList<String>();

// Since Java 7, no need to mention generic type in the right side
// instead we can use diamond operator. Compiler can infer type.
List<String> myList = new ArrayList<>();

Problema con el operador de diamantes al trabajar con clases internas anónimas

Java 7 nos permitió usar el operador de diamante en clases normales, pero no nos permitió usarlo en clases internas anónimas. Tomemos un ejemplo:

abstract class MyClass<T>{  
    abstract T add(T num, T num2);  
}  
public class JavaExample {  
    public static void main(String[] args) {  
        MyClass<Integer> obj = new MyClass<>() {  
            Integer add(Integer x, Integer y) {  
                return x+y;   
            }  
        };    
        Integer sum = obj.add(100,101);  
        System.out.println(sum);  
    }  
}

Producción:

$javac JavaExample.java
JavaExample.java:7: error: cannot infer type arguments for MyClass
        MyClass obj = new MyClass<>() {  
                                        ^
  reason: cannot use '<>' with anonymous inner classes
  where T is a type-variable:
    T extends Object declared in class MyClass
1 error

Recibimos un error de compilación cuando ejecutamos el código anterior en Java SE 8.

Java 9: ​​mejoras del operador Diamond

Java 9 ha mejorado el uso del operador de diamante y nos permite usar el operador de diamante con clases internas anónimas. Tomemos el mismo ejemplo que vimos anteriormente.
Ejecutando este código en Java SE 9

abstract class MyClass<T>{  
    abstract T add(T num, T num2);  
}  
public class JavaExample {  
    public static void main(String[] args) {  
        MyClass<Integer> obj = new MyClass<>() {  
            Integer add(Integer x, Integer y) {  
                return x+y;   
            }  
        };    
        Integer sum = obj.add(100,101);  
        System.out.println(sum);  
    }  
}

Producción:

201

Captura de pantalla del código anterior en Eclipse Oxygen usando jdk 9