Como tornar estático um método Java Generic?

A seguir, é apresentado um trecho de como criar uma classe genérica java para anexar um único item a uma matriz. Como posso tornar appendToArray um método estático. Adicionar estático à assinatura do método resulta em erros de compilação.

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;
        }
}

a única coisa que você pode fazer é mudar sua assinatura para

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

Detalhes importantes:

Expressões genéricas que precedem o valor de retorno sempre introduzem (declaram) uma nova variável de tipo genérico.

Além disso, variáveis ​​de tipo entre types ( ArrayUtils) e métodos estáticos ( appendToArray) nunca interferem entre si.

Então, o que isso significa: na minha resposta <E>ocultaria o Ede ArrayUtils<E>se o método não fosse static. E <E>não tem nada a ver com o Ede ArrayUtils<E>.

Para refletir melhor esse fato, uma resposta mais correta seria:

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

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

Observe o <E>.

Métodos genéricos estáticos precisam de sua própria declaração genérica ( public static <E>) separada da declaração genérica da classe ( public class ArrayUtils<E>).

Se o compilador reclamar de uma ambiguidade de tipo ao invocar um método genérico estático (novamente provavelmente não no seu caso, mas, de maneira geral, apenas no caso), veja como chamar explicitamente um método genérico estático usando um tipo específico ( _class_.<_generictypeparams_>_methodname_):

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

Isso aconteceria apenas se o compilador não puder determinar o tipo genérico porque, por exemplo, o tipo genérico não está relacionado aos argumentos do método.

Você precisa mover o parâmetro type para o nível do método para indicar que você tem um método genérico em vez de classe 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;
    }
}

Vou explicar de uma maneira simples.

Os genéricos definidos no nível da classe são completamente separados dos genéricos definidos no nível do método (estático).

class Greet<T> {

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

Quando você vir o código acima em qualquer lugar, observe que o T definido no nível da classe não tem nada a ver com o T definido no método estático. O código a seguir também é completamente válido e equivalente ao código acima.

class Greet<T> {

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

Por que o método estático precisa ter seus próprios genéricos separados dos da classe?

Isso ocorre porque, o método estático pode ser chamado sem sequer instanciar a classe. Portanto, se a Classe ainda não foi instanciada, ainda não sabemos o que é T. Essa é a razão pela qual os métodos estáticos precisam ter seus próprios genéricos.

Portanto, sempre que você estiver chamando o método estático,

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

A JVM interpreta como a seguir.

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

Ambos dando as mesmas saídas.

Hello Bob
Hello 123