Java泛型机制 类型自动推断 自定义泛型

JDK5.0推出的新特性：泛型，这种语法机制旨在编译阶段起作用，运行阶段没用！ 优点：集合中存储的元素类型统一，从集合中取出的元素类型是泛型指定的类型，不需要进行大量的“向下转型” 缺点：集合中存储的元素缺乏多样性 不使用泛型：

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

public class GenericTest {
    public static void main(String[] args) {
        List list = new ArrayList();
        // 准备对象
        Dog d = new Dog();
        Cat c = new Cat();
        // 将对象添加到集合当中
        list.add(d);
        list.add(c);

        // 遍历集合，取出Dog吃骨头，取出Cat吃鱼
        Iterator iterator = list.iterator();
        while (iterator.hasNext()){
            Object obj = iterator.next();
            if (obj instanceof Dog){
                Dog dog = (Dog)obj;
                dog.eatBone();
            }else if(obj instanceof Cat){
                Cat cat = (Cat)obj;
                cat.eatFish();
            }
        }
    }

}
class Animal{ }
class Dog extends Animal{
    public void eatBone(){
        System.out.println("狗吃骨头");
    }
}
class Cat extends Animal{
    public void eatFish(){
        System.out.println("猫吃鱼");
    }
}

使用泛型：

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

public class GenericTest {
    public static void main(String[] args) {
        // 使用泛型，List集合中只允许存储Animal类型的数据
        // 用泛型来指定List集合中存储的数据类型
        List<Animal> list = new ArrayList<Animal>();
        // 准备对象
        Dog d = new Dog();
        Cat c = new Cat();
        // 将对象添加到集合当中
        list.add(d);
        list.add(c);

        // 迭代器迭代Animal类型
        Iterator<Animal> iterator = list.iterator();
        while (iterator.hasNext()){
            // 调用Animal父类的方法不需要转型
            Animal obj = iterator.next();
            // 调用子类特有的方法需要转型
            if (obj instanceof Dog){
                Dog dog = (Dog)obj;
                dog.eatBone();
            }
            if (obj instanceof Cat){
                Cat cat = (Cat)obj;
                cat.eatFish();
            }
        }
    }

}
class Animal{ }
class Dog extends Animal{
    public void eatBone(){
        System.out.println("狗吃骨头");
    }
}
class Cat extends Animal{
    public void eatFish(){
        System.out.println("猫吃鱼");
    }
}

JDK8之后引入：自动类型推断机制（钻石表达式）

public class GenericTest {
    public static void main(String[] args) {
        // ArrayList<>类型会自动推断
        List<Animal> list = new ArrayList<>();
    }
}

自定义泛型：

public class GenericTest<abc> {
    public static void main(String[] args) {
        // 创建对象的时候指定泛型 String
        GenericTest<String> gt = new GenericTest<>();
        // 参数类型String
        gt.doSome("sm");
    }

    public void doSome(abc o){
        System.out.println(o);
    }
}

自定义泛型的时候，尖括号里面可以随便写，一般写E/T都可以！