¿Cómo hacer que un método genérico de Java sea estático?

El siguiente es un fragmento sobre cómo hacer que una clase genérica de Java agregue un solo elemento a una matriz. ¿Cómo puedo hacer appendToArray un método estático? Agregar estática a la firma del método da como resultado errores de compilación.

public class ArrayUtils<E> {

        public E[] appendToArray(E[] array, E item) {
            E[] result = (E[])new Object[array.length+1];
            result[array.length] = item;
            return result;
        }
}

lo único que puede hacer es cambiar su firma a

public static <E> E[] appendToArray(E[] array, E item)

Detalles importantes:

Las expresiones genéricas que preceden al valor de retorno siempre introducen (declaran) una nueva variable de tipo genérico.

Además, las variables de tipo entre los tipos ( ArrayUtils) y los métodos estáticos ( appendToArray) nunca interfieren entre sí.

Por lo tanto, ¿qué significa esto: En mi respuesta <E>sería ocultar la Ede ArrayUtils<E>si el método no sería static. Y <E>no tiene nada que ver con el Ede ArrayUtils<E>.

Para reflejar mejor este hecho, una respuesta más correcta sería:

public static <I> I[] appendToArray(I[] array, I item)

public static <E> E[] appendToArray(E[] array, E item) { ...

Tenga en cuenta el <E>.

Los métodos genéricos estáticos necesitan su propia declaración genérica ( public static <E>) separada de la declaración genérica de la clase ( public class ArrayUtils<E>).

Si el compilador se queja de una ambigüedad de tipo al invocar un método genérico estático (de nuevo no es probable en su caso, pero, en general, por si acaso), a continuación se explica cómo invocar explícitamente un método genérico estático utilizando un tipo específico ( _class_.<_generictypeparams_>_methodname_):

String[] newStrings = ArrayUtils.<String>appendToArray(strings, "another string");

Esto solo sucedería si el compilador no puede determinar el tipo genérico porque, por ejemplo, el tipo genérico no está relacionado con los argumentos del método.

Debe mover el parámetro de tipo al nivel de método para indicar que tiene un método genérico en lugar de una clase genérica:

public class ArrayUtils {
    public static <T> E[] appendToArray(E[] array, E item) {
        E[] result = (E[])new Object[array.length+1];
        result[array.length] = item;
        return result;
    }
}

Lo explicaré de una manera simple.

Los genéricos definidos a nivel de clase están completamente separados de los genéricos definidos a nivel de método (estático).

class Greet<T> {

    public static <T> void sayHello(T obj) {
        System.out.println("Hello " + obj);
    }
}

Cuando vea el código anterior en cualquier lugar, tenga en cuenta que la T definida en el nivel de clase no tiene nada que ver con la T definida en el método estático. El siguiente código también es completamente válido y equivalente al código anterior.

class Greet<T> {

    public static <E> void sayHello(E obj) {
        System.out.println("Hello " + obj);
    }
}

¿Por qué el método estático necesita tener sus propios genéricos separados de los de la Clase?

Esto se debe a que se puede llamar al método estático sin siquiera instanciar la Clase. Entonces, si la Clase aún no está instanciada, aún no sabemos qué es T. Esta es la razón por la cual los métodos estáticos deben tener sus propios genéricos.

Entonces, cada vez que llama al método estático,

Greet.sayHello("Bob");
Greet.sayHello(123);

JVM lo interpreta de la siguiente manera.

Greet.<String>sayHello("Bob");
Greet.<Integer>sayHello(123);

Ambos dan las mismas salidas.

Hello Bob
Hello 123