Java基础(七) | 你不知道的泛型

Java泛型，有效的提高代码的安全性，是时候好好的总结一番。

一、为什么引入泛型

    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("Hello");
        list.add("Xidian");
        list.add(80);
        
        for(int i=0;i

• 集合List默认为Object类型，其并不记忆存储对象的类型，在获取对象时，需要进行显示的强制类型转换，即使预知对象类型信息时，也容易出现Java.Lang.ClassCastException；

• 是否有方法可以使集合记忆对象类型信息，仅在编译时期正确，运行时便不会出现Java.Lang.ClassCastException?答案是，泛型；

二、小试牛刀

    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(80);
        list.add(85);
//      list.add("Hello"); //编译时期自动报错
        
        for(int j=0;j

• 泛型，即参数化类型，顾名思义是指将类型由原来的具体类型转变为参数类型；

三、类型擦除

    public static void main(String[] args) {
        List listInt = new ArrayList();

        //List与List不是一种类型
        //List listNum = listInt;
        
        List listNum = new ArrayList();
        
        System.out.println(listInt.getClass());
        System.out.println(listNum.getClass());
        System.out.println(listInt.getClass() == listNum.getClass());
    }

//打印结果
class java.util.ArrayList
class java.util.ArrayList
true

• Java泛型，仅作用于代码编译阶段，在编译过程中，在正确检查泛型结果后，会将泛型信息擦除，即成功编译后的class文件不包含泛型信息，泛型不进入运行阶段；

• 泛型类型，逻辑上可以看做不同的类型，实际上为相同的基本类型；

四、类型通配符

    public static void main(String[] args) {
        List listInt = new ArrayList();
        List listNum = new ArrayList();
        listInt.add(80);
        listNum.add(85);
        getData(listNum);
        //不能调用getData(List list)
        getData(listInt);           
    }
    
    public static void getData(List list){
        System.out.println(list.get(0));
    }
    
//  public static void getData(List list){
//      System.out.println(list.get(0));
//  }
//  
}

• List和List本质上是一种类型，但是不能实现方法调用，我们需要一个在逻辑上可以用来表示同时是List和List的父类的一个引用类型，由此，类型通配符应运而生；

• 类型通配符一般是使用 ? 代替具体的类型实参。注意，此处是类型实参，而不是类型形参！且List在逻辑上是List、List...等所有List<具体类型实参>的父类；

• 类型通配符上限List表示Number及其子类，类型通配符下限List表示Number及其父类；

五、泛型方法

public class Generics {
        class Fruit{
            @Override
            public String toString() {
                return "fruit";
            }
        }

        class Apple extends Fruit{
            @Override
            public String toString() {
                return "apple";
            }
        }

        class Person{
            @Override
            public String toString() {
                return "Person";
            }
        }

        class GenerateTest{
            public void show_1(T t){
                System.out.println(t.toString());
            }

            //在泛型类中声明了一个泛型方法，使用泛型E，这种泛型E可以为任意类型。可以类型与T相同，也可以不同。
            //由于泛型方法在声明的时候会声明泛型，因此即使在泛型类中并未声明泛型，编译器也能够正确识别泛型方法中识别的泛型。
            public  void show_3(E t){
                System.out.println(t.toString());
            }

            //在泛型类中声明了一个泛型方法，使用泛型T，注意这个T是一种全新的类型，可以与泛型类中声明的T不是同一种类型。
            public  void show_2(T t){
                System.out.println(t.toString());
            }
        }

        public static void main(String[] args) {
            Apple apple = new Generics().new Apple();
            Person person = new Generics().new Person();

            GenerateTest generateTest = new Generics().new GenerateTest();
            //apple是Fruit的子类，所以这里可以
            generateTest.show_1(apple);
            //编译器会报错，因为泛型类型实参指定的是Fruit，而传入的实参类是Person
            //generateTest.show_1(person);

            //使用这两个方法都可以成功
            generateTest.show_2(apple);
            generateTest.show_2(person);

            //使用这两个方法也都可以成功
            generateTest.show_3(apple);
            generateTest.show_3(person);
        }   
}

• 泛型类、泛型接口使用相对简单，泛型方法难度较大，有很强的迷惑性，在访问权限和返回值间添加表示声明一个泛型方法；

• 关于其他未涉及到的知识，欢迎参考泛型详解