Java - 泛型基础 - 精解

泛型
  

一，什么是泛型

Java泛型设计原则，只要在编译期没有出现警告，那么运行期间就不会出现ClassCastException异常

        1.背景:
            JAVA推出泛型以前，程序员可以构建一个元素类型为Object的集合，该集合能够存储任意的数据对象，而在使用该集合的过程中，需要程序员明确的知道存储每个元素的数据类型，否则很容易引发ClassCastException ，类型转换异常

          2.泛型的概念：
            Java泛型 generics 是JDK5中引入的一个新特性，泛型提供了编译时类型安全检测机制，该机制允许我们在编译时检测到非法的数据类型，将运行时可能发生的类型转换错误提到了编译期间
            泛型的本质就是参数化类型，也就是所操作的数据类型被指定为一个参数

            泛型：把类型明确的工作推迟到创建对象或调用方法时候才去明确的特殊的类型

        3.泛型的优点：
            1).类型安全
            2).消除了强制类型的转换

 

        4.类型：

        E - Element (在集合中使用，因为集合中存放的是元素)

        T - Type（表示Java 类，包括基本的类和我们自定义的类）

        K - Key（表示键，比如Map中的key）

        V - Value（表示值）

        N - Number（表示数值类型）

        ？ - （表示不确定的java类型）

        S、U、V - 2nd、3rd、4th types

    二，泛型类 · 与 · 泛型接口

        1.泛型类
            1)泛型类的定义语法

class 类名称 <泛型标识, 泛型标识 ,...>{
    private 泛型标识 变量名;
    ...
}

            2)常用的泛型标识： T, E, K, V

            3)使用语法
类名<具体的数据类型> 对象名 = new 类名<具体的数据类型>();

            4)Java 1.7 以后后面的 <> 中具体的数据类型可以省略不写
类名<具体的数据类型> 对象名 = new 类名<>();

            5)注意点:
                T 是在创建对象的时候指定具体的数据类型        
                T 由外部使用的时候指定
                泛型类在创建对象的时候，没有指定类型，将按照Object类型来操作
                泛型类的类型参数只能是类类型，不支持基本数据类型
                同一泛型类，根据不同的数据类型创建的对象，本质上是统一类型（同一类），即泛型类在逻辑上可以看成多个不同的类型，但实际上都是相同类型，这个是基于Java运行的本质，泛型只是存在编译期的
        

有Generic<T>这个类
		 Generic<String> strGeneric = new Generic<String>,
		 Generic<Integer> intGeneric = new Generic<Integer>
		 intGeneric.getClass() == strGeneric.getClass()，
		 结果是true

2.从泛型类派生子类
            1)子类也是泛型类，子类和父类的泛型类型必须一致

class ChildGeneric <T, ...> extends generic <T>{
}

        

//父类
public class Parent<E> {
    private E value;
    public E getValue() {
        return value;
    }
    public void setValue(E value) {
        this.value = value;
    }
}

/**
 * 泛型类派生子类，子类也是泛型类，那么子类的泛型标识要和父类一致。
 * @param <T>
 */
public class ChildFirst<T> extends Parent<T> {
    @Override
    public T getValue() {
        return super.getValue();
    }
}

 

           2)子类不是泛型类，父类要明确泛型的数据类型

class ChildGeneric extends generic <String>{
}

        

/**
 * 泛型类派生子类，如果子类不是泛型类，那么父类要明确数据类型
 */
public class ChildSecond extends Parent<Integer> {
    @Override
    public Integer getValue() {
        return super.getValue();
    }
    @Override
    public void setValue(Integer value) {
        super.setValue(value);
    }
}

        3.泛型接口
            1)泛型接口的定义语法

interface 接口名称 <泛型标识, 泛型标识, ..>{
    泛型标识 方法名();
    ......

}.

            2)泛型接口的使用
                a.实现类不是泛型类，接口要明确数据类型
                b.实现类也是泛型类，实现类的接口的泛型类型要一致

/**
 * 泛型接口
 * @param <T>
 */
public interface Generator<T> {
    T getKey();
}
/**
 * 泛型接口的实现类，是一个泛型类，
 * 那么要保证实现接口的泛型类泛型标识包含泛型接口的泛型标识
 * @param <T>
 * @param <E>
 */
public class Pair<T,E> implements Generator<T> {
    private T key;
    private E value;
    public Pair(T key, E value) {
        this.key = key;
        this.value = value;
    }
    @Override
    public T getKey() {
        return key;
    }
    public E getValue() {
        return value;
    }
}

    
    三，泛型方法
        1.语法
修饰符 <T, E, ...> 返回值类型 方法名 (形参列表){
    方法体....
}

            1)public 于与返回值中间的 <T> 非常重要，可以理解为声明此方为泛型方法
            2)只有声明了<T>的方法才是泛型方法，泛型类中使用了泛型的成原方法并不是泛型方法
            3)<T>表明该方法将使用泛型类型T，此时才可以在方法中使用泛型类型T
            4)与泛型类的定义一样，此处T可以随便写为任意标识，常见如T, E , K, V等
      

     2.泛型方法·与·可变参数

public <E> void print (E... e){
    for(E e1 : e ){
       System.out.println(e);
     }
}

        
        3.泛型方法总结
            1)泛型方法能使方法独立于类而产生变化
            2)如果static方法要使用泛型能力，就必须使其成为泛型方法

   public static <T,E,K> void printType(T t, E e, K k) {
        System.out.println(t + "\t" + t.getClass().getSimpleName());
        System.out.println(e + "\t" + e.getClass().getSimpleName());
        System.out.println(k + "\t" + k.getClass().getSimpleName());
    }

    
    四，类型通配符
        1.什么是类型通配符？
            1)类型通配符一般使用 " ？ "代替具体的类型参数
            2)所以，类型通配符是类型实参，而不是类型形参，可以代表任意类型

        2.类型通配符的上限
类/接口 < ? extends 实参类型 >

            要求该泛型的类型，只能是实参类型，或实参类型的子类类型
            数值类型的继承关系图？？补充
        3.类型通配符的下限
类/接口 < ? super 实参类型 >

            要求该泛型的类型，只能是实参类型，或实参类型的父类类型
            用Object类型来接收返回的数据，不保证下限的约束条件

    五，类型的擦除
        1.概念，泛型是Java 1.5 版本以后才引进的概念，在这之前是没有泛型的，但是泛型代码能够很好地和之前的代码兼容，那是因为，泛型信息只存在于代码编译阶段，在进入JVM之前，与泛型相关的信息会被擦除掉，我们称为 --- 类型擦除
      

        2.无限制类型擦除

 

        3.有限制类型擦除  -- 上限类型

        4.擦除方法中类型定义的参数

        5.桥接方法  -- 和接口有关，保持接口和类的实现关系
          

六，泛型与数组

    1.泛型数组的创建
        1)可以声明带泛型的数组引用，但是不能直接创建带泛型的数组对象

rrayList[] list = new ArrayList[5];
ArrayList<String>[] listArr = list;
或者
ArrayList<String>[] listArr = new ArrayList[5];

        第一个会将原生数组暴露，有可能会造成类型转换异常

由于将原生数组暴露出来，在添加元素的时候，由于编译期无法检测出来所以运行期会造成类型转化异常，一般使用第二种直接创建泛型数组

        2)可以通过java.lang.reflact.Array的newIntance(Class <T>,int）创建T[]数组

public class Fruit<T> {
    private T[] array;

    public Fruit(Class<T> clz, int length){
        //通过Array.newInstance创建泛型数组
        array = (T[])Array.newInstance(clz, length);
    }
}

七，泛型和反射

    1.Class<T>
    2.Constructor<T>

public class Person {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
/**
 * 泛型与反射
 */
public class Test{
	public static void main(String[] args) throws Exception {
	     Class<Person> personClass = Person.class;
	     Constructor<Person> constructor = personClass.getConstructor();
	     Person person = constructor.newInstance();
	 }
}