Lors de la programmation, je souhaite implémenter des classes et des méthodes avec plusieurs types. Il est facile de voir, par exemple, qu'il est ridicule d'implémenter ArrayList pour int, pour double et pour String. Très utile. Créer une classe ou une méthode avec plusieurs paramètres de type inclus dans \ <> comme ArrayList \ <T > est appelé Programmation générique.
Cet article explique d'abord l'implémentation de base et l'utilisation de GenericClass et GenericMethod. Ensuite, il explique comment limiter GenericPrograming et comment le gérer de manière flexible. Enfin, il résume les points à noter sur GenericProgramming en Java.
Generic Class Une implémentation simple de Generic Class.
Entry.java
public class Entry<K, V>{ // point 1
private K key; // point 2
private V value;
public Entry(K key, V value){ // point 2
this.key=key;
this.value=value;
}
public K key(){return key;} // point 2
public V value(){return value;}
}
Client.java
Entry<Integer, String> id = new Entry<String, Integer>(1001, "hitoshi watanabe"); //1
Entry<Integr, String> id2 = new Entry<>(1002, "taro yamada"); //2
var id3 = new Entry<Integer, String>(1003, "hideo kojima"); //3
Les types primitifs ne peuvent pas être utilisés pour les paramètres de type, donc des entiers encadrés sont utilisés à la place des entiers.
Generic Method Les paramètres de type dépendent de l'instance, donc si vous souhaitez utiliser des paramètres de type dans une méthode statique, vous devez déclarer des paramètres de type indépendants de l'instance.
Arrays.java
public class Arrays {
public static <T> void swap(T[] array, int i, int j){ // point 1
T tmp = array[i]; //point 2
array[i]=array[j];
array[j]=tmp;
}
}
Client.java
String[] member = ...;
Arrays.<String>swap(member, 0, 1); //1
Arrays.swap(member, 0, 1); //2
Des opérations suffisamment abstraites comme Array.swap peuvent déclarer un paramètre de type appelé \ <T > qui ne limite pas le type. Mais lorsque vous souhaitez effectuer des opérations plus restrictives, remplissez les conditions requises pour le paramètre de type Il est nécessaire de définir une limite pour que seuls les sous-types du type soient inclus. À titre d'exemple, nous présenterons l'implémentation lorsque vous souhaitez fermer tous les éléments en prenant ArrayList de la classe qui implémente l'interface AutoClosable comme argument.
Sample1.java
public static <T extends AutoClosable> void closeAll(ArrayList<T> elems) throws Exception{ // point 1
for(T e : elems) e.close(); // point 2
}
Lorsque \ <T > est déclaré, le compilateur complète \ <T étend Object >. En java, toutes les classes ont une classe Object dans leurs ancêtres, donc les méthodes fournies par la classe Object peuvent être utilisées.
La méthode closeAll n'a pas besoin d'être GenericMethod
Sample.java
public static void closeAll(AutoClosable[] elems){
for(AutoClosable e : elems) e.close();
}
##Flexibilité accrue dans la programmation générique
Lorsque vous souhaitez implémenter une méthode qui prend une instance avec un paramètre de type comme argument,Sous-type d'instance à prendre comme argument,Il est normal de vouloir également autoriser les supertypes comme arguments..pourtant,
#### **`BadSample.java`**
```java
public static void printName(ArrayList<Employee> staff){
for(Employee e : staff) System.out.println(e.getName());
}
BadSample.ArrayList comme argument comme java
###SubType WildCard BadSample.En java, je ne pouvais pas prendre une classe qui héritait de Employee comme argument.,Le caractère générique de sous-type est utilisé pour résoudre ce problème..
Sample2.java
public static void printName(ArrayList<? extends Emplyee> staff){ // point 1
for(Employee e : staff) System.out.println(e.getName());
}
<? extends hoge>Acceptera une instance du paramètre de sous-type de hoge comme argument.le sous-type hoge peut être traité comme hoge dans le polymorphisme.À ce moment-là,Si la méthode utilisée est remplacée,La méthode remplacée est appelée.
Recommended Posts