12.Java-Grundlagen – Platzhalter-javaLernprogramm-php.cn

12.Java-Grundlagen – Platzhalter

黄舟

Freigeben： 2017-02-27 10:46:04

Original

1442 Leute haben es durchsucht

Grundlegende Konzepte

Platzhalter, der ein Fragezeichen zur Darstellung von Typparametern verwendet, ist eine Methode , das die [Typbeschränkung] von [unbekannter Typ] darstellt.

Generika definieren den Datentyp als Parameter, und wir können bei Verwendung den spezifischen Typ angeben. Wenn der spezifische Typ jedoch bei der Verwendung nicht bestimmt werden kann, müssen Sie sich zur Lösung auf Platzhalter verlassen.

Abstrakt gesehen werden Platzhalter eingeführt, um generische Typen kovariant zu machen, da Generika keine Kovarianz unterstützen.

Die Rolle von Platzhaltern

Im Folgenden wird anhand von zwei Beispielen die Rolle von Platzhaltern untersucht.

1. Verwenden Sie keine Platzhalter

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;

Nach dem Login kopieren

Beim Beobachten des Codes haben wir Folgendes festgestellt:

Die gespeicherten Elemente in der ArrayList Es unterstützt die Aufwärtskonvertierung von String -> Object, da String eine Unterklasse von Object ist.
Bei der Konvertierung des Parametertyps ArrayList von String -> ist ein Kompilierungsfehler aufgetreten, da Generika keine Kovarianz unterstützen.

2. Verwenden Sie das Platzhalterzeichen

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);

Nach dem Login kopieren

, um den Code zu beobachten und zu finden:

Nach der Verwendung von Platzhaltern ist es möglich, jede Art von Transformation zu akzeptieren, wodurch lediglich die Einschränkung aufgehoben wird, dass Generika keine Kovarianz unterstützen.
Aber es verliert auch das Recht, Objekte jeglicher Art hinzuzufügen.

Wildcard-Typen

Es gibt drei Formen von Wildcards, nämlich:

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

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

Nach dem Login kopieren

1. Platzhalter für Obergrenze

Beobachten Sie das folgende Beispiel: Es werden drei Klassen mit Vererbungsbeziehungen definiert, nämlich 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);
    }
}

Nach dem Login kopieren

2. Unterer Platzhalter

// 省略相同代码...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);
    }
}

Nach dem Login kopieren

3. Unbegrenzter Platzhalter

// 省略相同代码...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); 
    }
}

Nach dem Login kopieren

Das Obige ist der Inhalt von 12. Java Basics - Wildcards. Weitere verwandte Inhalte finden Sie auf der chinesischen PHP-Website (m.sbmmt.com).