12.Bases de Java - Caractères génériques-javaDidacticiel-php.cn

12.Bases de Java - Caractères génériques

黄舟

Libérer： 2017-02-27 10:46:04

original

1444 Les gens l'ont consulté

Concepts de base

Wildcard, utilisant un point d'interrogation pour représenter les paramètres de type, est une méthode qui représente la [contrainte de type] de [type inconnu].

Les génériques définissent le type de données en tant que paramètre, et nous pouvons spécifier le type spécifique lorsqu'il est utilisé. Mais si le type spécifique ne peut pas être déterminé lors de son utilisation, vous devez vous fier aux caractères génériques pour le résoudre.

De manière abstraite, comme les génériques ne prennent pas en charge la covariance, des caractères génériques sont introduits pour rendre les types génériques covariants.

Le rôle des caractères génériques

Ce qui suit utilise deux exemples pour explorer le rôle des caractères génériques.

1. N'utilisez pas de caractères génériques

ArrayList<Object> list_obj = null;
ArrayList<String> list_str = new ArrayList<String>();
// ArrayList 的元素支持  String -> Object 的强制转换list_str.add("hello");
System.out.println((Object)list_str.get(0));// 编译错误，泛型不支持协变list_obj = list_str;

Copier après la connexion

En observant le code, nous avons constaté que :

Les éléments stockés dans ArrayList, il prend en charge la conversion ascendante de String -> Object, car String est une sous-classe d'Object.
Une erreur de compilation s'est produite lorsque le type de paramètre de ArrayList a été converti à partir de String -> Object, car les génériques ne prennent pas en charge la covariance.

2. Utilisez les caractères génériques

ArrayList<String> list_str = new ArrayList<String>();
list_str.add("hello");

ArrayList<Integer> list_int = new ArrayList<Integer>();
list_int.add(100);

ArrayList<?> list = null;
list = list_str;
System.out.println(list.get(0));    // hellolist = list_int;
System.out.println(list.get(0));    // 100//编译错误list.add("hello");
list.add(100);

Copier après la connexion

pour observer le code et trouver :

Après avoir utilisé des caractères génériques, cela lui permet d'accepter tout type de transformation, ce qui résout simplement la limitation selon laquelle les génériques ne prennent pas en charge la covariance.
Mais il perd également le droit d'y ajouter des objets de tout type.

Types de caractères génériques

Il existe trois formes de caractères génériques, à savoir :

//1、无限定通配符 Demo<?>//2、上边界限定通配符 Demo< ? extends Number>   

//3、下边界限定通配符    Demo< ? super Number>

Copier après la connexion

1. Caractère générique de limite supérieure

Observez l'exemple suivant : trois classes avec des relations d'héritage sont définies, à savoir Person ->

class Person{    void print(){
    }
}

class Man extends Person{    void paly(){
    }
}

class Worker extends Man{    void say(){
    }
}public class Test {
    public static void main(String[] args)  {        
    // 创建了三个 ArrayList 数组
        ArrayList<Person> personList = new ArrayList<Person>();
        ArrayList<Man> manList= new ArrayList<Man>();
        ArrayList<Worker> workerList = new ArrayList<Worker>();        
        // 限定了上界， ？ 代表 Man 以及继承 Man 的类
        ArrayList<? extends Man> list  = null;

        list = manList;
        list = workerList;        // 编译错误，因为 Person 是 Man 的父类
        list = personList;        // 编译错误，因为使用了通配符就不能添加对象
        list.add(new Man());
        list.add(new Worker());        for(Man man : list){
            man.print();
            man.paly();
        }        for(Person per : list){
            per.print();
        }        // 编译错误，因为 ？ 也可以代表 Man
        // 从继承我们可以知道 Worker 肯定是 Man，但 Man 不一定是 Worker。
        // for(Worker worker : list);
    }
}

Copier après la connexion

2. Caractère générique de limite inférieure

// 省略相同代码...public class Test {
    public static void main(String[] args)  {
        ArrayList<Person> personList = new ArrayList<Person>();
        ArrayList<Man> manList= new ArrayList<Man>();
        ArrayList<Worker> workList = new ArrayList<Worker>();        
        // 限定了下届， ？ 代表 Man 以及 Man 的父类
        ArrayList<? super Man> list  = null;

        list = personList;
        list = manList;        // 编译错误，因为 Worker 是 Man 的子类
        list = workList;        // 编译错误，无法确定其父类对象
        // Person 继承子 Cell 类，那么用 Person 遍历就是错误的
        // for(Man man : list);
        // for(Person per : list);

        // 因为 Object 是所有类的根类,所以可以用Object来遍历
        // for(Object obj : list);
    }
}

Copier après la connexion

3. > Ce qui précède est le contenu de 12.Java Basics - Wildcards Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (m.sbmmt.com) !

// 省略相同代码...public class Test {
    public static void main(String[] args)  {
        ArrayList<Person> personList = new ArrayList<Person>();
        ArrayList<Man> manList= new ArrayList<Man>();
        ArrayList<Worker> workList = new ArrayList<Worker>();        //无边界通配符
        ArrayList<?> list  = null;        //可以代表一切类型
        list = personList;
        list = manList;
        list = workList;        //为了避免类型混淆，只允许使用 Object 遍历
        for(Object obj : list); 
    }
}

Copier après la connexion