Hola.

 

Gracias igualmente por la ayuda, el problema es que necesito que devuelva un tipo genérico. En ocasiones necesitaré que sea un tipo que no tiene nada que ver con las clases Integer, Double, etc.

Creo que simplemente renunciaré a las versiones estáticas y lo haré todo a partir de métodos no estáticos, que con eso me funciona bien.

Gracias. Un saludo.

interface Group<T> {
    T sum(T num1, T num2);
}
 
public class HolaMundo implements Group<Double> {
 
    Function<Integer, Integer> function = (a) -> 1 + a;
    IntUnaryOperator function1MoreSpecialized = (a) -> a + 1;
 
    public HolaMundo() {
        final int result1 = function.apply(2);
        final int result2 = function1MoreSpecialized.applyAsInt(2);
 
        System.out.println(result1);
        System.out.println(result2);
 
    }
 
    public static void main(String[] args) {
        new HolaMundo();
    }
 
    @Override
    public Double sum(Double num1, Double num2) {
        return num1 + num2;
    }
}

interface Group {
 
    static Integer sumaStatica(Integer number, Integer number2) {
        return number + number2;
    }
 
    default Integer sumaDefault(Integer number, Integer number2) {
        return number + number2;
    }
}
 
public class HolaMundo implements Group {
 
    public HolaMundo() {
        final Integer sumaPeroEnConstructor = sumaDefault(1,3);
        System.out.println("Resultado por metodo por default: " + sumaPeroEnConstructor);
    }
 
    public void otroMetodoMas() {
        sumaDefault(1,2);
        Group.sumaStatica(1, 2);
    }
 
    public static void otroMetodoMas2() {
        //Error
        sumaDefault(1, 2);
        Group.sumaStatica(1, 2);
    }
 
    public static void main(String[] args) {
        new HolaMundo();
        //Usando metodo estatico aqui
        final Integer resultado = Group.sumaStatica(1, 2);
        System.out.println("Resultado por metodo por static: " + resultado);
    }
 
}