extends T> représente la limite supérieure du type, indiquant que le type paramétré peut être T ou une sous-classe de T. ;
super T> représente la limite inférieure du type (appelée qualification de super type dans Java Core), indiquant que le type paramétré est le super type (type parent ) de ce type, jusqu'à ce que l'objet ;
import java.util.LinkedList; import java.util.List; public class test { public static void main(String[] args) { List<? extends Father> list = new LinkedList<>(); list.add(new Son()); } } class Human{ } class Father extends Human{ } class Son extends Father{ } class LeiFeng extends Father { }
#🎜 🎜#List extends Father> hérité de Son". Le compilateur ne peut pas déterminer le type détenu par List, il ne peut donc pas y ajouter d'objets en toute sécurité. Vous pouvez ajouter null car null peut représenter n'importe quel type. Ainsi, la méthode add de List ne peut ajouter aucun élément significatif, mais elle peut accepter les affectations de sous-types List existantes.
Vous pouvez essayer de faire ceci :
List<? extends Father> list = new LinkedList<Son>(); list.add(new Son());
Même si vous spécifiez le type Son, vous ne pouvez pas ajouter d'objet Son à l'aide de la méthode add.
Pourquoi la classe Père et les sous-classes de la classe Père ne peuvent-elles pas être ajoutées à la liste ?
List extends Father> signifie que la limite supérieure est Father, et les affectations suivantes sont légales
List<? extends Father> list1 = new ArrayList<Father>(); List<? extends Father> list2 = new ArrayList<Son>(); List<? extends Father> list3 = new ArrayList<LeiFeng>();
If List 🎜 🎜#
list1 peut ajouter Père et toutes les sous-classes de Père ;list1.add(new Father());//error list1.add(new Son());//error
public <T> List<T> fill(T... t);
List<? extends Father> list1 = getFatherList();//getFatherList方法会返回一个Father的子类的list
List<? extends Father> list1 = new ArrayList<>(); Father father = list1.get(0);//读取出来的东西只能存放在Father或它的基类里。 Object object = list1.get(0);//读取出来的东西只能存放在Father或它的基类里。 Human human = list1.get(0);//读取出来的东西只能存放在Father或它的基类里。 Son son = (Son)list1.get(0);
La limite inférieure est déclarée avec super, indiquant que le type paramétré peut être le type spécifié, ou un type parent de ce type, jusqu'à Object.
//super只能添加Father和Father的子类,不能添加Father的父类,读取出来的东西只能存放在Object类里 List<? super Father> list = new ArrayList<>(); list.add(new Father()); list.add(new Human());//compile error list.add(new Son()); Father person1 = list.get(0);//compile error Son son = list.get(0);//compile error Object object1 = list.get(0);
Étant donné que la limite inférieure spécifie la limite inférieure de la granularité minimale de l'élément, elle assouplit en fait le contrôle de type de l'élément conteneur. Puisque l’élément est la classe de base de Father, il peut être stocké dans une granularité plus petite que celle de Father. Pour des raisons de sécurité de type, nous pouvons ajouter un objet Father ou l'une de ses sous-classes (telles que Son). Cependant, comme le compilateur ne sait pas à quelle superclasse de Father appartient le contenu de la liste, il n'est pas autorisé à ajouter une superclasse spécifique. . Classe (comme Humain). Et lorsque nous le lisons, le compilateur ne peut renvoyer que l'objet Object sans savoir de quel type il s'agit, car Object est la classe ancêtre ultime de toute classe Java. Mais dans ce cas, toutes les informations de type de l’élément sont perdues.
Enfin, regardons ce qu'est le principe PECS (Producer Extends Consumer Super), déjà bien compris :
#🎜🎜 #Si vous lisez fréquemment du contenu de l'extérieur, il convient d'utiliser la limite supérieure Extends. Il convient d'utiliser Nether Super si vous l'insérez souvent.
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!