--Héritage de classe avec le paramètre de type T
Le type des éléments du tableau peut être trouvé plus tard avec ʻarray.getClass (). GetComponentType () `, Il est difficile de faire la même chose avec des listes telles que ArrayList et LinkedList!
--Les personnes qui ont utilisé la classe Class
en java
--Les personnes intéressées par les paramètres de type
Préparation
class Hoge
{
public static void main(String[] args)
{
ArrayList<Number> inteList = new ArrayList<>();
System.out.println(new ParamGetter(inteList).get());
//Obtention de la classe ParamGetter()Dans la méthode
//Je veux afficher "Numéro", etc.
}
}
class ParamGetter
{
Class paramClass;
<T> ParamGetter(List<T> list)
{
this.paramClass = T.class;
//× C'est NG
}
Class get(){return paramClass;}
}
//(Pour ceux qui ont réfléchi)
class ParamGetter
{
Type paramType;
<T> ParamGetter(List<T> list)
{
this.paramType = ((ParameterizedType)new ArrayList<T>(){}.getClass().getGenericSuperclass()).getActualTypeArguments()[0];
}
Type get(){return paramType;}
}
Résultat: "T" s'affiche
La même chose s'applique à la méthode [2] utilisant la méthode getGenericType ()
de la classe Field
.
toArray ()
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();
}
}
Résultat (principal): "class java.lang.Object" s'affiche.
Serpentin L'idée de «prendre un élément d'une liste et d'examiner son type» est peut-être possible, mais elle est en fait inappropriée.
--De List <Number>
, ʻInteger [] peut être fait, mais
Number [] `ne le peut pas.
Les informations de type disparaissent au stade du passage à la méthode
Dans 3.3, d'abord, l'argument factice de type List <T>
est passé à l'argument réel de type ʻArrayList . Ensuite, il est converti en un tableau de type «T» et stocké dans un champ de type «Objet». Ensuite, quand
get ()` est appelé, il trouve le "type d'exécution" (type de tableau) et vérifie le type des éléments de ce tableau.
Le résultat est ʻObject`, Au lieu de «T» = «Number», cela signifie «T» = «Object».
En fait, quand j'exécute le code de ☆, il s'affiche qu'il est de type ʻObject [] . → Après tout
T []= ʻObjet []
System.out.println((T[])list.toArray());//Object[]Il sort avec un moule.
À partir de là, on peut voir que les informations de paramètre de type ont disparu lors de leur passage en argument. En fait effacé au moment de la compilation (devient le type le plus abstrait pouvant être reçu) [3]
Ce qui disparaît à l'exécution ne peut pas être supprimé même par réflexion (la réflexion est une technologie à l'exécution [4]) →
class Hoge<T> | Survie de Fuga | Fuga as |
---|---|---|
new Hoge(); | × | Paramètres de type des méthodes d'instance |
new Hoge<Fuga>(); | 〇 | Paramètres de type de la classe[5] |
new Hoge(Fuga.class) | △ | Argument de type de classe |
△ ・ ・ ・ Ce n'est pas impossible, mais ce sera redondant.
5.2 ArrayList<T>
→ ArrayList_<T>
Chose que vous voulez faire:
new ArrayList_ <Number> (Object ...);
new ArrayList <Number> (Object ...);
et
Donnez-lui presque la même signification
Et rendre Number
disponible au moment de l'exécution
A presque la même signification → Réalisable par héritage Ecrire en référence au commentaire de M. saka1029 dans cet article
public class ArrayList_<T> extends ArrayList<T> {
public final Class<?> clazz;
public ArrayList_(T... dummy) {
if (dummy.length > 0)
throw new IllegalArgumentException(
"Ne spécifiez pas d'argument factice");
clazz = dummy.getClass().getComponentType();
}
public Class getComponentClass() {
return clazz;
}
}
new Hoge <t.getClass ()>
Une instance de type générique «Hoge
En bref, new Hoge <t.getClass ()>
ne peut pas être fait.
Si vous l'écrivez dans la méthode, il est possible dans une certaine mesure en tant que new Hoge <?>
,
Hoge<t.getClass()>.getClass().getDeclaredConstructor().newInstance()
Il n'est pas possible de créer une instance de type générique n'importe où.
Si vous voulez faire cela, passez une variable de type Classe <?>
Comme argument.
public class ArrayList_<T> extends ArrayList<T> {
public final Class<?> clazz;
public ArrayList_(T... dummy) {
if (dummy.length > 0)
throw new IllegalArgumentException(
"Ne spécifiez pas d'argument factice");
clazz = dummy.getClass().getComponentType();
}
public ArrayList_(Class<T> clazz)//Ajoute ça
{
this.clazz = clazz;
}
public Class getComponentClass() {
return clazz;
}
}
[1]http://unageanu.hatenablog.com/entry/20071105/1194264963 [2]https://codeday.me/jp/qa/20181216/16785.html [3]https://qiita.com/pebblip/items/1206f866980f2ff91e77 Le "type le plus abstrait qui peut être reçu" dans le texte signifie la "limite supérieure" dans [3]. [4]https://java.keicode.com/lang/reflection.php [5] L'argument de M. saka1029 dans cet article Autres: https://java-beginner.com/thread-thread-and-runnable/