泛型的应用

泛型

Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编

译时类型安全检测机制，泛型的好处就是在编译的时候能够检查类型安

全。

泛型类型用于类的定义中，被称为泛型类。通过泛型可以完成对一组类的操作对外开

放相同的接口。

用泛型

package com.ffyc.java.day1;
​
import java.util.ArrayList;
import java.util.Date;
​
public class Demo1 {
    public static void main(String[] args) {
        /*
            ArrayList<E> E-->参数-->类型
            泛型-->参数化类型，类型参数化
​
            java中所有的集合类，都支持泛型，支持向类中，传入一个类型
            建议集合中只存储一种类型,就不需要进行向下转型
         */
        ArrayList list = new ArrayList();
        list.add("aaa");
        list.add("aaa");
    }
}

从泛型类派生子类

​
//如果一个子类继承/实现父级类/接口是有泛型的，那么子类也可以定义为一个泛型类
//public class Person1<T> implements Comparable<T>{
​
如果一个子类继承/实现父级类/接口是有泛型的，那么子类也可以不定义为一个泛型类，那么父类/接口类型必须要明确才行
public class Person1 implements Comparable<Person1>{
    private String name;
​
    @Override
    public int compareTo(Person1 o) {
        return 0;
    }
​
    public static void main(String[] args) {
//        Person1<String> p = new Person1();
//        p.compareTo("aaaa");
        Person1 p = new Person1();
    }
}

/*
    Car(定义的字母)
        T type
        E element
        K key
        V value
 */
public class Car<T,E> {
    //类型在定义时固定
    //String name
    private T name;
​
    public Car(T name) {
        super();
        this.name = name;
    }
​
    public T getName() {
        return name;
    }
​
    public void setName(T name) {
        this.name = name;
    }
​
    public static void main(String[] args) {
        //类型参数化,把类型当做参数一样，动态的传递
        Car<String,String> car =new Car<String,String>("111");
        car.setName("aaaaa");
        Car<Integer,String> car1 =new Car<Integer,String>(111);
        car1.setName(111);
        //泛型的类型只能是类类型，可以定义多个泛型，如果没有定义类型，那么默认为Object
    }
}

泛型通配符

类型通配符一般是使用"？"代替具体的类型实参。

public class Demo<T> {
    /*
        方法的参数的泛型实际可以为什么，
            tset(Demo<?> d) ？类型通配符，指的是实际传入参数的类型,?表示可以是任何类型
     */
    public void test(Demo<?> d){
​
    }
    //? extends T 泛型的上限
    //实际传入的泛型上限是T，以及T的子类
    public void test1 (Demo<? extends T> d){
​
    }
    //? extends T 泛型的下限
    //实际传入的泛型下限是T，以及T的父类
    public void test2 (Demo<? super T> d){
​
    }
​
    public static void main(String[] args) {
//        Demo d0 = new Demo<>();
//        Demo<Integer> d1 = new Demo<>();
//        Demo<String> d2 = new Demo<>();
//        d0.test(d1);
//        d0.test(d2);
        Demo<Number> d0 = new Demo<>();
        Demo<Integer> d1 = new Demo<>();
        Demo<String> d2 = new Demo<>();
        d0.test1(d1);
//        d0.test1(d2);
//        d0.test2(d1);
    }
}

类型擦除

泛型类被类型擦除后，相应的类型就被替换成 Object 类型或者上限类型.

package com.ffyc.java.day1;
​
import java.lang.reflect.Field;
import java.util.ArrayList;
​
public class Demo2<T> {
    public T name;
​
    public static void main(String[] args) throws NoSuchFieldException {
        //transient Object [] elementData;
        ArrayList<String> list = new ArrayList<>();
        //泛型只是在编译期间来对类型进行限制，底层还是Object类型
        //这就是泛型类型的檫除
        Demo2<String> d2 = new Demo2<>();
        d2.name="aaa";
//        d2.name=111;
        Class c = d2.getClass();
        Field f = c.getField("name");
        System.out.println(f.getName()+":::"+f.getType());
    }
}