Java泛型 ＜E＞ 或 ＜T＞

一、泛型的概述

1. JDK5.0以后的新特性：泛型

2. 泛型这种语法机制，只在程序编译阶段起作用，只是给编译器参考的(运行阶段泛型没用)

3. 使用泛型的优点：
       集合中存储的元素类型统一了
       大部分情况下集合中元素的类型还是统一的。
       从集合中取出来的类型是泛型指定的数据类型，这样就不用频繁的进行数据的强制类型转换

4. 使用泛型的缺点：
       导致集合中存储的元素缺乏多样性

5. 减少了向下转型的操作

public class GenericTest01 {
    public static void main(String[] args) {
       /* List list = new ArrayList();
        Cat c = new Cat();
        Bird b = new Bird();

        Iterator it = list.iterator();
        while (it.hasNext()){
            Object oo =it.next();
            if (oo instanceof Animal){
                Animal animal = (Animal) oo;
                animal.move();
            }
        }*/
        List<Animal> list = new ArrayList<Animal>();
        Cat c = new Cat();
        Bird b = new Bird();

        list.add(c);
        list.add(b);

        Iterator<Animal> it = list.iterator();
        while (it.hasNext()){
            //使用泛型之后，返回的迭代器是指定的类型，就不用强制类型转换了
            Animal oo =it.next();
            oo.move();
            if (oo instanceof Cat){
                Cat cat = (Cat) oo;
                cat.catchMouse();
            }
            if (oo instanceof Bird){
                Bird bird = (Bird) oo;
                bird.fly();
            }
        }
    }
}

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("鸟在飞翔");
    }
}

二、自动类型推断机制。(砖石表达式)diamond

【注】：JDK8之后引入了：自动类型推断机制。(砖石表达式)diamond

public class GenericTest02 {
    public static void main(String[] args) {
        //ArrayList<Animal>()里面的Animal可以省略不写，前提是JDK8以后才允许
        //自动类型推断，砖石表达式
        List<Animal> list = new ArrayList<>();
        list.add(new Cat());
        list.add(new Animal());
        list.add(new Bird());

        //遍历
        Iterator<Animal> it = list.iterator();
        while (it.hasNext()){
            Animal animal = it.next();
            if (animal instanceof Cat){
                Cat cat = (Cat)animal;
                cat.catchMouse();
            }else if (animal instanceof Bird){
                Bird bird = (Bird)animal;
                bird.fly();
            }else {
                animal.move();
            }
        }
    }
}

 三、自定义泛型

public class GenericTest03<标识符随便写> {
    public void doSome(标识符随便写 yourena){
        System.out.println(yourena);
    }

    public static void main(String[] args) {
        //new对象的时候指定泛型,指定为String
        GenericTest03<String> gt = new GenericTest03<String>();
        gt.doSome("dddd");
        //类型不匹配
        //gt.doSome(100);

        GenericTest03<Integer> gt2 = new GenericTest03<Integer>();
        gt2.doSome(100);
        /*类型不匹配
        gt2.doSome("dddd");
         */


        //不用泛型，默认Object类型
        GenericTest03 gt3 = new GenericTest03();
        gt3.doSome(100);

    }
}