Metoda rodzajowych bez argumentów

Question

powiedzmy mam metody takie jak to:

static class Example 
{ 
    public static <N extends Number> Number getOddBits(N type) 
    { 
     if (type instanceof Byte) return (byte)0xAA; 
     else if (type instanceof Short) return (short)0xAAAA; 
     else if (type instanceof Integer) return 0xAAAAAAAA; 
     else if (type instanceof Float) return Float.intBitsToFloat(0xAAAAAAAA); 
     else if (type instanceof Long) return 0xAAAAAAAAAAAAAAAAL; 
     else if (type instanceof Double) return Double.longBitsToDouble(0xAAAAAAAAAAAAAAAAL); 
     throw new IllegalArgumentException(); 
    } 
} 

Rzeczywiste specyfika metoda ta jest bardzo ważna. Jednakże, aby wywołać tę metodę używamy:

Example.<Float>getOddBits(0f); 

Moje pytanie brzmi, czy jest możliwe, aby napisać taki sposób bez konwencjonalnych parametrów. Bez przeciążania, a ostatecznie bez Boxing.

Idealnie wywołany przez:

Example.<Byte>getOddBits(); 

Answer 1

Jako akcesorium do sugestii KennyTM użytkownika, można połączyć argument Ćwiczenia metodą generycznych, aby powrócić rodzaj specjalistycznego:

@SuppressWarnings("unchecked") 
public static <N extends Number> N getOddBits(Class<N> cls) { 
    Number out; 
    if (cls == Byte.class) { 
     out = (byte)0xAA; 
    } else if (cls == Short.class) { 
     out = (short)0xAAAA; 
    } else if (cls == Integer.class) { 
     out = 0xAAAAAAAA; 
    } else if (cls == Float.class) { 
     out = Float.intBitsToFloat(0xAAAAAAAA); 
    } else if (cls == Long.class) { 
     out = 0xAAAAAAAAAAAAAAAAL; 
    } else if (cls == Double.class) { 
     out = Double.longBitsToDouble(0xAAAAAAAAAAAAAAAAL); 
    } else { 
     throw new IllegalArgumentException(); 
    } 
    return (N)out; 
} 

To pozwoli Ci przypisać następujące polecenie, a uniknąć oddanych na każde wezwanie:

float result = Example.getOddBits(Float.class); 

Answer 2

Jak o prostu wziąć .class?

public static Number getOddBits(Class<? extends Number> cls) 
{ 
    if (cls == Byte.class) { 
     return (byte)0xAA; 
    } else if (cls == Short.class) { 
     return (short)0xAAAA; 
    } else if (cls == Integer.class) { 
     return 0xAAAAAAAA; 
    } else if (cls == Float.class) { 
     return Float.intBitsToFloat(0xAAAAAAAA); 
    } else if (cls == Long.class) { 
     return 0xAAAAAAAAAAAAAAAAL; 
    } else if (cls == Double.class) { 
     return Double.longBitsToDouble(0xAAAAAAAAAAAAAAAAL); 
    } 
    throw new IllegalArgumentException(); 
} 

... 

Example.getOddBits(Float.class); 

Answer 3

nie jestem pewien, czy to pomoże, ale użyłem tego w przeszłości do deserializacji i powrocie przedmiot odpowiedniego typu.

public <T> T deserialize(String xml){ 
    T object=null; 
    ... 
    //pull type information from method param 
    ... 
    return object=(T)type.newInstance(); //helper to instantiate class 
} 

Jednak nie jestem do końca pewien, co należy zrobić. Prostszym i czystszym sposobem na osiągnięcie tego może być stworzenie interfejsu konwertera dla potrzebnych typów i posiadanie jakiejkolwiek klasy potrzebnej do jej implementacji. Wtedy to, czegokolwiek potrzebujesz, można wywołać bezpośrednio w samym obiekcie. na przykład:

inerface Convertor<T>{ 

    T convert(); 

    void set(T value); 

} 





class Something implements Converter<Long,ByteArray>{ 

    ... 

    public ByteArray convert(){...} 

    public void set(ByteArray value){...} 

}