Explication détaillée des génériques en Java

Les soi-disant génériques : ils permettent de spécifier des paramètres de type lors de la définition des classes et des interfaces. Ce paramètre de type sera déterminé lors de la déclaration des variables et de la création d'objets (c'est-à-dire en transmettant des paramètres de type réels, qui peuvent également être appelés arguments de type).

Classe ou interface générique

Syntaxe "Diamond"

//定义
 
public interface List<E> extends Collection<E>  
 
public class HashMap<K,V> extends AbstractMap<K,V>  implements Map<K,V>, Cloneable, Serializable 
//使用
 
List<String> list = new ArrayList();
 
//Java7以后可以省略后面尖括号的类型参数
 
List<String> list = new ArrayList<>();

Dérivation d'une sous-classe à partir d'une classe générique

//方式1
 
public class App extends GenericType<String>
 
//方式2
 
public class App<T> extends GenericType<T>
 
//方式3
 
public class App extends GenericType

Pseudo-générique

Il n'y a pas de véritable classe générique. Les classes génériques sont transparentes pour la machine virtuelle Java. La JVM ne connaît pas l'existence des classes génériques et des classes ordinaires. Par conséquent, les paramètres de type ne sont pas autorisés dans les méthodes statiques, les blocs d’initialisation statiques et les variables statiques.
- Les méthodes suivantes sont toutes fausses

private static T data;
 
static{
 
    T f;
 
}
 
public static void func(){
 
    T name = 1;
 
}

L'exemple suivant peut vérifier de côté qu'il n'y a pas de classe générique

public static void main(String[] args){
 
        List<String> a1 = new ArrayList<>();
        List<Integer> a2 = new ArrayList<>();  
    System.out.println(a1.getClass() == a2.getClass());
 
    System.out.println(a1.getClass());
 
    System.out.println(a2.getClass());
 
}

Sortie

true
 
class java.util.ArrayList
 
class java.util.ArrayList

Tapez le caractère générique

Tout d'abord, il doit être clair que si Foo est la classe parent de Bar, mais List4ee996100bf04ab273e687539c860625 n'est pas la classe parent de Listad40e550a33cb99ea30eede96e03e60e. classes parentes, Java utilise "? " pour représenter les caractères génériques. Autrement dit, List6b3d0130bba23ae47fe2b8e8cddf0195 représente la classe parent de diverses listes génériques avec ce caractère générique ne peut pas définir (définir) des éléments, mais peut uniquement obtenir (obtenir) éléments. Le programme ne pouvant pas déterminer le type dans la liste, il ne peut pas ajouter l'objet. Mais l’objet obtenu doit être de type Objet.

Les méthodes suivantes compileront les erreurs :

List<?> list = new ArrayList<>();
 
list.add(new Object());

Quelques idées :

1. Les objets Listf7e83be87db5cd2d9a8a0b8117b38cd4 est Say : La classe Listf7e83be87db5cd2d9a8a0b8117b38cd4 n'est pas une sous-classe de la classe Lista87fdacec66f0909fc0757c19f2d2b1d

2. Les tableaux et les génériques sont différents : en supposant que Foo est un sous-type (sous-classe ou sous-interface) de Bar, alors Foo[] est toujours un sous-type de Bar[] mais G4ee996100bf04ab273e687539c860625 ;Barre>.

3. Afin de représenter la classe parent de diverses listes génériques, nous devons utiliser des caractères génériques de type est un point d'interrogation (?). , écrivant : Listc344555b90c740e0d12635e07ea03035 (signifiant Liste d'éléments de type inconnu). Ce point d'interrogation (?) est appelé caractère générique et son type d'élément peut correspondre à n'importe quel type.

La limite supérieure des caractères génériques

List41e72a075beaa92298ffb490fa164613 représente la classe parent de toutes les listes génériques SuperType ou elle-même. Les génériques avec des limites supérieures génériques ne peuvent pas avoir de méthodes définies, ils obtiennent uniquement des méthodes.

Définir la limite supérieure des caractères génériques peut résoudre les problèmes suivants : Dog est une sous-classe d'Animal, et il existe une méthode getSize pour obtenir le nombre de listes entrantes. Le code est le suivant

abstract class Animal {
    public abstract void run();
}
class Dog extends Animal {
    public void run() {
        System.out.println("Dog run");
    }
}
public class App {
    public static void getSize(List<Animal> list) {
        System.out.println(list.size());
    }
    public static void main(String[] args) {
        List<Dog> list = new ArrayList<>();
        getSize(list); // 这里编译报错
    }
}

<.>La raison de l'erreur de programmation ici est que List4cfe4bcd4d110814d5bcb5b26c812079 n'est pas la classe parent de Lista6240277e46d54dc29cc58bc214c4982. La première solution consiste à modifier le paramètre formel List4cfe4bcd4d110814d5bcb5b26c812079 dans la méthode getSize en List6b3d0130bba23ae47fe2b8e8cddf0195, mais dans ce cas, une conversion de type forcée est requise à chaque fois que l'objet est obtenu, ce qui est plus gênant. L'utilisation de la limite supérieure générique résout très bien ce problème. Vous pouvez remplacer List4cfe4bcd4d110814d5bcb5b26c812079 par Listc4a7544c1592b077f46e4950c994be85 Les génériques avec des limites supérieures génériques ne peuvent pas avoir de méthodes get, mais uniquement des méthodes set.

Méthodes génériques

Si vous définissez des classes et des interfaces sans utiliser de paramètres de type, mais que vous souhaitez définir vous-même les paramètres de type lors de la définition des méthodes, cela est également possible dans JDK1.5. . La signature de méthode d'une méthode générique contient plus de déclarations de paramètres de type que la signature de méthode d'une méthode ordinaire. Les déclarations de paramètres de type sont placées entre crochets. Plusieurs paramètres de type sont séparés par des virgules (,). modificateurs et types de valeurs de retour de méthode. Le format de syntaxe est le suivant :

修饰符 返回值类型 方法名（类形列表）{
 
//方法体
 
}

Les méthodes génériques permettent d'utiliser des paramètres de type pour exprimer les dépendances de type entre un ou plusieurs paramètres de la méthode, ou la dépendance de type entre les méthodes. valeur de retour et paramètres. S’il n’existe pas de dépendance de type, les méthodes génériques ne doivent pas être utilisées. La méthode de copie de Collections utilise la méthode générique :

 public static <T> void copy(List<? super T> dest, List<? extends T> src){ ...}

Cette méthode nécessite que le type src soit une sous-classe du type dest ou lui-même.

Effacer et convertir

Dans le code générique strict, les classes avec des déclarations génériques doivent toujours porter des paramètres de type. Cependant, afin d'être cohérent avec l'ancien code Java, il est également autorisé d'utiliser des classes avec des déclarations génériques sans spécifier de paramètres de type. Si aucun paramètre de type n'est spécifié pour cette classe générique, le paramètre de type est appelé type brut et prend par défaut le premier type de limite supérieure spécifié lors de la déclaration du paramètre.

Lors de l'affectation d'un objet avec des informations génériques à une autre variable sans informations génériques, toutes les informations de type entre crochets angulaires sont supprimées. Par exemple, si un type Listf7e83be87db5cd2d9a8a0b8117b38cd4 est converti en List, la vérification de type des éléments de collection de List devient la limite supérieure de la variable de type (c'est-à-dire Object). Cette situation est appelée effacement.

Exemple

class Apple<T extends Number>
 
{
 
 T size;
 
 public Apple()
 
 {
 
 }
 
 public Apple(T size)
 
 {
 
  this.size = size;
 
 }
 
 public void setSize(T size)
 
 {
 
  this.size = size;
 
 }
 
 public T getSize()
 
 {
 
  return this.size;
 
 }
 
}
 
public class ErasureTest
 
{
 
 public static void main(String[] args)
 
 {
 
  Apple<Integer> a = new Apple<>(6);    // ①
 
  // a的getSize方法返回Integer对象
 
  Integer as = a.getSize();
 
  // 把a对象赋给Apple变量，丢失尖括号里的类型信息
 
  Apple b = a;      // ②
 
  // b只知道size的类型是Number
 
  Number size1 = b.getSize();
 
  // 下面代码引起编译错误
 
  Integer size2 = b.getSize();  // ③
 
 }
 
}

Pour des articles plus détaillés sur les génériques en Java, veuillez faire attention au site Web PHP chinois !