Java之泛型

泛型

• 什么是泛型
  
  • 实现了参数化类型的概念,是代码可以应用于多种类型
  • 可以用在类,接口,方法创建中,分别为泛型类,泛型方法,泛型接口
  • 当创建类型化参数时,编译器会负责转换操作

• 泛型声明:

  • 泛型类:public class Wrapper<T,V>{}
  • 泛型接口:public interface Conusumer<T>{}
  • 泛型方法:public static <T> String parser<T t>(){};

• 泛型的好处:

  • 类型安全
  • 消除强制类型转换

类型擦除

• 类型擦除

  • 类型变量没用显示限定,擦除后,原生类型用Object代替
    public static <T> T min(T[] a){}
    类型擦除后为:
    public static Object min(Oject[] a){}

  • 若类型变量有显示限定,原始类型用第一个限定类型变量替换
    public class Interval<T extends Comparable & Serializable> implements Serializable{}
    类型擦除后的原始类型为:
    public class Interval implements Serializable{}

    对于多限定:如果T extens Serializable & Comparable 会发生什么呢?
    类型擦除时,Seriablizable替换为T,而编译器在必要时要向Comparable插入强制类型转换,为了提高效果,要将没有方法的接口放在边界末尾.

  • 泛型参数在编译时有用,而在运行时会被擦除

  • 不能在需要实际参数类型时使用形式泛型类型
    
    • T t= new T();
    • T[] data= new T[10];
    • if(t instance of T)

• 泛型与原生类型的关系

  • 泛型的实现是向后兼容的
  • 泛型类型的无泛型版本称为原生类型(Raw Type)

  • 泛型版本与原生类型可以相互赋值,这种做法不推荐

    ArrayList<String> sList= new ArrayList();
    ArrayList<Object> oList= new ArrayList();
    ArrayList list= new ArrayList();
    sList= list; //原生类型向后兼容
    list=oList;
    

• 翻译泛型方法

  • 使用桥方法,避免类型擦除和多态的冲突

  • 实际类型参数如果有继承关系,也不允许相互赋值

    ArrayList<String> sList= new ArrayList();
    ArrayList<Object> oList= new ArrayList();
    oList=sList; //不能赋值,二者其实没有任何关系
    

• 堆污染

  • 当将一个带有类型参数的变量赋值给不同的类型参数的变量

  • 将泛型类型用于可变长度参数是会有警告:潜在的堆污染.

    ArrayList<String> sList= new ArrayList();
    ArrayList<Object> oList= new ArrayList();
    ArrayList list= new ArrayList();
    sList= list; //潜在的堆污染
    list=oList;
    

泛型方法

• 泛型方法的声明与调用

  • 可以在泛型类或非泛型类(接口)中声明泛型方法<V> V test(V v){}

    不能在静态方法中使用类的参数类型

    String[] array = list.<String>toArray(new String[list.size()]);`
        Collections.<String>sort(list, new Comparator<String>() {
                @Override
                public int compare(String o1, String o2) {
                    return o1.compareTo(o2);
                }
            });

    实际参数类型可以省略

• 泛型构造方法声明与调用

  • 声明构造方法:public <V> V Wrapper<V v>{}
  • new <String> Wrapper("Java");

• 方法重写与泛型

  • Java使用桥方法的方式实现泛型方法的重写.

    泛型类型擦除后,在子类重写test方法,实际的参数应该为Object,但是为什么是String类型呢?这是因为虚拟机为解决泛型擦除和多态之间的冲突引入的桥方法,如下例子:

        public class Parent<T>{
                    public void test(T t){};
                }
    
                public class Son<String>{
                    @override
                    public void test(String t){
                        super.test(t);
                    }
    
                    //内部桥方法
                    public void test(Object o){
                        this.test((String)o);
                    }
    
                }

泛型类型推断

• 泛型类的类型推断:
  
  • java7后,使用new关键字创建泛型类时,可以省略类型参数,只有<>;
  • 类型推断规则:
    
    • 从构造方法的参数中推断类型
    • 从赋值运算符的左边推断类型,如果在方法调用中没有赋值,则进入下一步
    • java8从方法的形式参数中推断,java7前略过这步
    • 上述规则都推断不出类型,则使用Object类型
• 泛型与数组
  
  • 不可使用参数类型直接创建数组
  • 不可使用泛型类创建数组
  • 可以使用无边界通配符的泛型类创建数组
  • 可以使用反射机制泛型数组

泛型类型的继承规则:

• 
  
• 实际类型参数有继承关系：
  

如Employee和Manager是父子类关系,但是 Pair<Manager>与 Pair<Employee>是子父类关系么? 答案是”没有任何关系!”

通配符

• 无边界通配符

  • 使用问好(?)作为实际参数类型参数: Wrapper<?> wrapper;
  • 只能用于填充泛型变量T,不能使用这种语法创建对象,
  • 通配符(?)与T的关系:
    
    • 没有任何关系
    • 泛型变量T不能在代码中用于创建变量,只能在类,接口,函数中声明后才能使用.

• 上边界通配符

  • 使用问号(?)与extends配合作为实际参数:
  • Wrapper<? extends Type> wrapper;

• 下边界通配符

  • 使用问号(?)与super配合作为实际参数:
  • Wrapper<? super Type> wrapper;