0. Fazit zuerst

Klassenvererbung mit Typparameter T.
Der tatsächliche Typ von T kann erhalten werden, indem dem Konstruktor ein Argument mit variabler Länge vom Typ T gegeben wird.

1. Herausforderung

Der Typ der Elemente des Arrays kann später mit array.getClass (). GetComponentType (), gefunden werden. Mit Listen wie ArrayList und LinkedList ist es schwierig, dasselbe zu tun!

2. Zielgruppe

Personen, die die Klasse "Class" in Java verwendet haben
Personen, die an Typparametern interessiert sind

3. Schlechtes Beispiel

Vorbereitung

class Hoge
{
    public static void main(String[] args)
    {
        ArrayList<Number> inteList = new ArrayList<>();
        System.out.println(new ParamGetter(inteList).get());
        //Holen Sie sich von ParamGetter Klasse()In der Methode
        //Ich möchte "Nummer" usw. anzeigen.
    }
}

3.1 T.class ist nicht möglich

class ParamGetter
{
    Class paramClass;
    <T> ParamGetter(List<T> list)
    {
        this.paramClass = T.class;
        //× Dies ist NG
    }
    Class get(){return paramClass;}
}

3.2 Reflexion schlägt fehl [1]

//(Für diejenigen, die nachgedacht haben)
class ParamGetter
{
    Type paramType;
    <T> ParamGetter(List<T> list)
    {
        this.paramType = ((ParameterizedType)new ArrayList<T>(){}.getClass().getGenericSuperclass()).getActualTypeArguments()[0];
    }
    Type get(){return paramType;}
}

Ergebnis: "T" wird angezeigt Gleiches gilt für die Methode [2], die die Methode "getGenericType ()" der Klasse "Field" verwendet.

3.3 Array mit `toArray ()` fehlgeschlagen

class ParamGetter
{
    Object array;
    <T>ParamGetter(List<T> list)
    {
        this.array = (T[])list.toArray();
        //☆System.out.println((T[])list.toArray());
    }

    Type get() throws NoSuchFieldException, SecurityException
    {
        return this.array.getClass().getComponentType();
    }
}

Ergebnis (main): "Klasse java.lang.Object" wird angezeigt.

<!--

Serpentin Die Idee, "ein Element aus einer Liste zu nehmen und seinen Typ zu untersuchen", ist zwar möglich, aber tatsächlich unangemessen.

Sie können "Integer []" aus "List ", aber nicht "Number []" ausführen
In einigen Fällen beträgt die Anzahl der Elemente 0 -->

4. Grundursache

Die Typinformationen verschwinden in der Phase der Übergabe an die Methode

In 3.3 wird zunächst das tatsächliche Argument vom Typ "ArrayList " an das Dummy-Argument vom Typ "List " übergeben. Als nächstes wird es in ein Array vom Typ "T" konvertiert und in einem Feld vom Typ "Objekt" gespeichert. Wenn dann get () aufgerufen wird, wird der "Laufzeittyp" (Array-Typ) erhalten und der Typ des Elements des Arrays wird überprüft.

Weil das Ergebnis "Objekt" ist Dies bedeutet, dass "T" = "Objekt" anstelle von "T" = "Zahl".

Wenn ich den Code von ☆ ausführe, wird tatsächlich angezeigt, dass er vom Typ Object [] ist. → Immerhin T [] = Object []

System.out.println((T[])list.toArray());//Object[]Es kommt mit einer Form heraus.

Daraus ist ersichtlich, dass die Typparameterinformationen verschwunden sind, während sie als Argument übergeben wurden. Wird beim Kompilieren tatsächlich gelöscht (wird zum abstraktesten Typ, der empfangen werden kann) [3]

5. Lösung

Was zur Laufzeit verschwindet, kann nicht einmal durch Reflexion entfernt werden (Reflexion ist eine Technologie zur Laufzeit [4]). →

Wenn Sie anrufen, schreiben Sie an einen Ort, der nicht verschwindet
Geben Sie der Klasse selbst einen Typparameter und verwenden Sie ihn im Konstruktor

5.1 Ersetzen Sie den Typparameter durch ein Argument

class Hoge<T>	Fuga Überleben	Fuga as
new Hoge();	×	Geben Sie Parameter von Instanzmethoden ein
new Hoge<Fuga>();	〇	Geben Sie die Parameter der Klasse ein[5]
new Hoge(Fuga.class)	△	Klassentyp-Argument

△ ･･･ Es ist nicht unmöglich, aber es wird überflüssig.

5.2 ArrayList<T>
→ ArrayList_<T>

Was Sie tun möchten: new ArrayList_ <Number> (Object ...); new ArrayList <Number> (Object ...); und Machen Sie es fast die gleiche Bedeutung Und machen Sie Number zur Laufzeit verfügbar

Hat fast die gleiche Bedeutung → Realisierbar durch Vererbung Schreiben Sie unter Bezugnahme auf den Kommentar von Herrn saka1029 in diesem Artikel

public class ArrayList_<T> extends ArrayList<T> {

    public final Class<?> clazz;

    public ArrayList_(T... dummy) {
        if (dummy.length > 0)
            throw new IllegalArgumentException(
                "Geben Sie kein Dummy-Argument an");
        clazz = dummy.getClass().getComponentType();
    }

    public Class getComponentClass() {
        return clazz;
    }
}

6 (Bonus) Aktiviert `new Hoge <t.getClass ()>`

Eine Instanz des generischen Typs "Hoge " kann nicht aus einer Variablen vom Typ "Klasse " erstellt werden.

Kurz gesagt, new Hoge <t.getClass ()> kann nicht durchgeführt werden. Wenn Sie es in die Methode schreiben, ist es bis zu einem gewissen Grad als "new Hoge <?>" Hoge<t.getClass()>.getClass().getDeclaredConstructor().newInstance() Es ist nirgendwo möglich, eine generische Instanz zu erstellen.

Wenn Sie dies tun möchten, übergeben Sie eine Variable vom Typ Class <?> Type als Argument.

public class ArrayList_<T> extends ArrayList<T> {

    public final Class<?> clazz;

    public ArrayList_(T... dummy) {
        if (dummy.length > 0)
            throw new IllegalArgumentException(
                "Geben Sie kein Dummy-Argument an");
        clazz = dummy.getClass().getComponentType();
    }

    public ArrayList_(Class<T> clazz)//Füge das hinzu
    {
        this.clazz = clazz;
    }

    public Class getComponentClass() {
        return clazz;
    }
}

Referenz

[1]http://unageanu.hatenablog.com/entry/20071105/1194264963 [2]https://codeday.me/jp/qa/20181216/16785.html [3]https://qiita.com/pebblip/items/1206f866980f2ff91e77 Der "akzeptabelste Typ" im Text bedeutet die "Obergrenze" in [3]. [4]https://java.keicode.com/lang/reflection.php [5] Der Punkt von Herrn saka1029 in diesem Artikel Andere: https://java-beginner.com/thread-thread-and-runnable/

[Java] Um die Typinformationen der Typparameter zur Laufzeit zu kennen