Java 中的泛型机制

泛型

• JDK5.0之后推出的新特性：泛型
• 泛型这种语法机制，只在程序编译阶段起作用，只给编译器参考的（运行阶段没用）
• 使用泛型的好处：集合中存储的元素统一了
• 从集合中取出来的元素类型是泛型指定的类型，不需要进行大量的“向下转型”
• 泛型的缺点：集合中的元素缺乏多样性

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/*
* JDK5.0之后推出的新特性：泛型
* 泛型这种语法机制，只在程序编译阶段起作用，只给编译器参考的（运行阶段没用）
* 使用泛型的好处：集合中存储的元素统一了
* 从集合中取出来的元素类型是泛型指定的类型，不需要进行大量的“向下转型”
* 泛型的缺点：集合中的元素缺乏多样性
* */
public class GenericTest {
    public static void main(String[] args) {
        //不使用泛型机制 ，分析程序存在的缺点
        List mylist = new ArrayList();
        // 准备对象
        Cat c = new Cat();
        Bird b = new Bird();

        mylist.add(c);
        mylist.add(b);

        //遍历集合，取出Cat让它抓老鼠，取出Bird让他飞
        Iterator it = mylist.iterator();
        while(it.hasNext()){
            //没有这个语法，通过迭代器取出来的就是Object
            // Animal a = it.next();
            Object obj = it.next();
            // obj中没有move方法，无法调用，需要向下转型！
            if(obj instanceof Animal){
                Animal a = (Animal) obj;
                a.move();
            }
        }

        // 使用JDK5.0之后的泛型机制
        // 使用泛型List<Animal> 之后，表示List集合中只允许存储Animal类型的数据。
        List<Animal> myList = new ArrayList<Animal>();

        // 指定List集合中只能存储Animal，那么存储String就编译报错了。
        //这样用了泛型之后，集合中元素的数据类型更加统一了。
        //myList.add("abc");

        Cat c1 = new Cat();
        Bird b1 = new Bird();

        mylist.add(c1);
        mylist.add(b1);

        //遍历集合，取出Cat让它抓老鼠，取出Bird让他飞
        Iterator<Animal> it1 = mylist.iterator();
        while(it1.hasNext()){

           Animal a =  it1.next();
           a.move();
           //调用子类型特有的方法啊hi是需要向下转换的

        }


    }
}

class Animal{
    public void move(){
        System.out.println("动物在移动！");
    }

}
class Cat extends Animal{
    public void catchMouse(){
        System.out.println("猫抓老鼠！");
    }
}

class Bird extends Animal{
    public void fly(){
        System.out.println("鸟儿在飞！");
    }
}

泛型的自动类型推断机制（钻石表达式）

• ArrayList<这里的类型会自动类型推断>()，JDK8之后

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/*
* 在JDK8之后引入了：自动类型推断机制（又称钻石表达式）*/
public class GentericTest02 {
    public static void main(String[] args) {
        // ArrayList<这里的类型会自动类型推断>()，JDK8之后
        List<Animal> myList = new ArrayList<>();
        myList.add(new Animal());
        myList.add(new Cat());

        Iterator<Animal> it = myList.iterator();
        while(it.hasNext()){
            Animal a = it.next();
            a.move();
        }

    }
}

自定义泛型

• 自定义泛型的时候 <> 尖括号中的是一个标识符，随便写
• java源代码中经常出现的是 E T 分别表示Element Type

/*
* 自定义泛型
自定义泛型的时候 <> 尖括号中的是一个标识符，随便写
java源代码中经常出现的是   E T   分别表示Element  Type

 */
public class GentericTest03<标识符随便写> {
    public void dosame(标识符随便写 o) {
        System.out.println(o);

    }

    public static void main(String[] args) {
        //new对象的时候指定了泛型是：String类型
        GentericTest03<String> gt = new GentericTest03<>();
        gt.dosame("sss");
        //类型不匹配
        //gt.dosame(11);
    }
}