Possibilité d'attribuer un type spécifique à une méthode de classe qui accepte n'importe quel type et de générer une classe spécifique au type **
Vous pouvez maintenant ** garantir le type d'élément membre au moment de la compilation **
Définir un type générique
** nom de classe de classe <paramètre de type, ...> {classe} **
ex: Déclarez le paramètre de type E La classe publique ArrayList <E> étend AbstractList <E> {
** Paramètre de type **: partie de la déclaration <...> pour recevoir un type spécifique
Attribuer un type arbitraire à l'instance
** T (Type) ** ・ ** E (Élément) ** ・ ** K (Clé) **, ** V (Valeur) **
** Variable de type **: le type déclaré dans le paramètre type
Argument de membre d'instance / valeur de retour
Type de variable locale
Type imbriqué
Dans Generics, ArrayList
** Erasure **: Conversion des informations de type inutiles au moment de l'exécution en type d'objet au moment de la compilation de cette manière
** Paramètre de type réel (argument de type) **: Type spécifique spécifié lors de l'instanciation d'un type générique (Integer, etc.)
new ArrayList**<Integer>**：
** Type paramétré **: type générique auquel un type spécifique est affecté par un argument de type (tel que ArrayList ).
new **ArrayList<Integer>**：
Contraintes de paramètre de type
** Je veux supposer que la méthode a des arguments **
Dans l'exemple ci-dessous, une erreur se produira car les variables de type T x et y n'ont pas toujours de méthode compareTo.
Classes telles que String, Integer, File qui implémentent l'interface = Comparable avec la méthode compareTo
//Erreur
public class GenericConstraint <T> {
public int Hoge(T x, T y) {
return x.compareTo(y);
}
}
→ ** Ajouter une contrainte (type de limite) avec le paramètre de type **
<Le paramètre de type étend le type de limite, ..>
Les paramètres de type avec le type de limite ingBuilder sont ** convertis en type de limite au lieu du type d'objet au moment de la compilation **
Les types de chaîne qui implémentent l'interface Comparable comme indiqué ci-dessous peuvent être passés à la classe GenericConstraint.
//Un exemple de reconnaissance de la méthode compareTo
public class GenericConstraint <T extends Comparable<T>> {
public int Hoge(T x, T y) {
return x.compareTo(y);
}Shi
}
Le type de limite est ** la classe / l'interface peut être spécifiée **
étend ** au lieu de * implémente
** Plusieurs interfaces peuvent être spécifiées **
** Une seule classe ** (ou 0)
** Décrit dans l'ordre de classe → interface **
public class MyGeneric <T extends Hoge & Bar $ Foo> {
Constructeur de méthode générique
Une méthode ou un constructeur qui détermine ** les types tels que les arguments / les valeurs de retour / les variables locales au moment de l'appel **
Les méthodes génériques sont ** indépendantes des types génériques, donc des types non génériques peuvent également être définis **
[Qualificatif]<Paramètres de type>Nom de la méthode de type de retour(Type d'argument Nom de l'argument, ...)
[clause throw]{
Corps de la méthode
}
Type de caractère générique de limite
** ** Covariant **: ** Array ** peut affecter une classe dérivée à la classe de base Child [] peut être affecté à Parent [] si Parent / Child a une relation d'héritage
* Object[] data = new String[5];
Étant donné que Object / String a une relation d'héritage, un tableau String peut être affecté pour entrer le type Object.
Puisque l'état réel des données dans data [1] = 10; est String [], ArrayStoreException
** invariant **: ** Collection génériques **
ArrayList ne peut pas être assigné à ArrayList même si Parent / Child a une relation d'héritage
ArrayList <Object> data = new ArrayList <String> (); // Erreur
//Exemple NG
import java.util.List;
public class GenericBounded {
//List<Parent>Reçoit et génère une liste de types
public void show(List<Parent> list) {
for (var p : list) {
System.out.println(p.getName());
}
}
}
import java.util.ArrayList;
import java.util.Arrays;
public class GenericBoundedBasic {
public static void main(String[] args) {
var cli = new GenericBounded();
var data1 = new ArrayList<Parent>(Arrays.asList(
new Parent("Grenouille"), new Parent("Niwatori"), new Parent("Libellule")));
var data2 = new ArrayList<Child>(Arrays.asList(
new Child("Otamajakushi"), new Child("Poussin"), new Child("Yago")));
cli.show(data1); //OK
//List<Parent>Liste comme argument de type<Child>Les valeurs de type ne peuvent pas être transmises
cli.show(data2); //Erreur de compilation
}
}
Puisque show est une méthode qui fait référence au contenu de la liste, aucune attribution de valeur n'a lieu.
→ ** Boundary wildcard ** autorise le type Parent ou son type dérivé (covariant)
Le type List peut être passé comme argument de type List
Les éléments ne peuvent pas être ajoutés ou mis à jour
Le type générique de limite ne peut faire référence qu'aux valeurs avec ** type de bordure **
import java.util.List;
public class GenericBounded {
//Caractère générique de limite
public void show(List<? extends Parent> list) {
for (var p : list) {
System.out.println(p.getName());
}
}
}
Exemple de bibliothèque standard
ArrayList.java
public boolean addAll(Collection<? extends E> c){
Object[] a = c.toArray();
//Abréviation
}
Les valeurs telles que ArrayList , type ArrayList ne peuvent pas être ajoutéesAll au type ArrayList s'il est défini comme addAll (Collection <E> c"
En utilisant le joker de limite ** Le type d'élément de la liste passé en argument peut accepter CharSequence / son type dérivé **
Type générique de limite inférieure
** Caractère générique de limite de limite supérieure : la limite supérieure du type de limite spécifié et les types subordonnés sont également acceptés ( <? Etend E> **)
** ** Caractère générique de limite inférieure : le type de base peut être passé au type de manille = ** Inversion ** ( <? Super T> **)
Dans la méthode addAll, le type générique de limite inférieure Collection <? Super T> peut passer une collection qui a ** type T ou son type supérieur comme élément **
Si addAll n'avait pas de type générique de limite inférieure, l'ajout d'un élément de type String devrait être ArrayList <String>
Pour les arguments (producteur) qui n'obtiennent que la valeur ** Caractère générique de limite supérieure **
Pour les arguments (consommateurs) qui ne définissent qu'une valeur ** Caractère générique de limite inférieure **
java:java.util.Collections.addAll.java
public static <T> boolean addAll(Collection<? super T> c, T... elements) {
boolean result = false;
for (T element : elements)
result |= c.add(element);
return result;
}
//ArrayList<Object>Permet l'ajout d'éléments de type String pour
import java.util.ArrayList;
import java.util.Collections;
public class LowerBoundedBasic {
public static void main(String[] args) {
var list = new ArrayList<Object>();
Collections.addAll(list, "neko", "inu", "tori");
System.out.println(list); //[neko, inu, tori]
}
}
Type de caractère générique sans limite
N'a pas de type de bordure
Spécifiez comme Liste <?>
Remarque: pour garantir la sécurité des moisissures
** Impossible d'appeler la méthode qui prend T comme argument **
** Tout T qui est la valeur de retour de la méthode est de type objet **
import java.util.List;
public class UnBounded {
public static void showList(List<?> list) {
for (var item : list) {
System.out.println(item);
}
//list.add("Hoge");//La valeur ne peut pas être transmise car le type n'est pas fixe
//list.add(null); //Exceptionnellement nul est OK
// Object obj = list.get(0); //Le résultat obtenu n'est pas un type String mais un type Object!!
}
}