1. 泛型的入门

JDK1.4以前类型不明确

• 装入集合的类型都被当做Object对待，从而失去自己的实际类型。
• 从集合中取出时往往需要转型，效率低，容易产生错误。
• 方案: 在定义集合的时候同时定义集合中对象的类型。

• 作用：
• 1. 模板：提高代码的重用率
• 2. 安全： 在编译的时候检查类型安全
• 3. 省心： 所有的强制转换都是自动和隐式的

3. 泛型的概念

• 概念：泛型就是参数化类型。
• 1. 适用于对多种数据类型执行相同功能的代码。
• 2. 泛型中的类型在使用时指定。
• 3. 泛型归根到底就是"模板"。
• 4. 泛型主要适用在集合中。

4. 泛型字母

• 形式类型参数：即泛型字母
• 命名：泛型字母可以随意指定，尽量使用单个的大写字母(有时候多个泛型类型时会加上数字，比如T1，T2)
• 常见字母(见名知意)
• T Type
• K V Key Value
• E Element
• 当类被使用时，会使用具体的实际类型参数代替。

1. 泛型类

/**
 * 注意点：
 * 泛型不能使用在静态属性上
 * 指定的类型不能为基本类型
 */
public class Holder3<T> {

    private T a;

    public Holder3(T a) {
        this.a = a;
    }

    public void setA(T a) {
        this.a = a;
    }

    public T getA() {
        return a;
    }

    public static void main(String[] args) {
        Holder3<String> holder3 = new Holder3<String>("Wu");
        String name = holder3.getA();
        System.out.println(name);
    }

}

2. 泛型方法

/**
 * 非泛型类中定义泛型方法
 * 定义：在返回类型前面 <字母>
 */
public class Method {

    // 泛型方法
    public static <T> void test(T t){
        System.out.println(t);
    }

    public static <T extends List> void test(T t) {
        t.add("WM");
    }

    // T... 可变参数 类似于T[]
    public static <T extends Closeable> void test(T... t) {
        for (T temp : t) {
            if (temp != null) {
                try {
                    temp.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

}

3. 泛型接口

public class NumGenerator implements Generator<Integer> {

    int[] args = {1,2,3};

    @Override
    public Integer next() {
        Random random = new Random();
        return args[random.nextInt(3)];
    }

    public static void main(String[] args) {
        NumGenerator numGenerator = new NumGenerator();
        System.out.println(numGenerator.next());
    }

}

8. 泛型檫除

定义：泛型檫除是指在继承(实现)或使用时没有指定具体的类型
特点：一旦檫除之后，按Object处理

/**
 * 泛型父类，子类为富二代(只可多，不可少)
 * 1. 保留父类泛型，子类为泛型
 * 2. 不保留父类泛型，子类按需实现
 *
 * 属性及方法类型---> 随位置而定
 * 1).子类重写方法的类型---> 随父类而定
 * 子类新增方法的类型 ---> 随子类而定
 * 2).子类中使用父类的属性---> 随父类而定
 * 子类中使用自己的属性 ---> 随子类而定
 */
public abstract class Father<T1,T2> {
    T1 age;
    public abstract void test(T2 name);
}

// 保留 ---> 泛型子类
// 1. 全部保留
class C1<T1,T2,A,B> extends Father<T1,T2>{
    @Override
    public void test(T2 name) {
//        this.age; T1
    }
}

// 2. 部分保留
class C2<T2> extends Father<Integer,T2>{
    @Override
    public void test(T2 name) {
//        this.age; Integer
    }
}

// 不保留 ---> 按需实现
// 1. 具体类型
class C3 extends Father<Integer,String>{
    @Override
    public void test(String name) {
//         this.age;  Integer
    }
}

// 2. 没有类型 檫除 Object
class C4 extends Father{
    @Override
    public void test(Object name) {
//        this.age; Object
    }
}

/**
 * 泛型接口与泛型类同理
 */
public interface Comparator<T> {
    // 全局常量
    public static final int MAX_VALUE = 100;

    // 公共抽象方法
    public abstract void test(T t);
}

// 实现
class InterC1 implements Comparator{
    @Override
    public void test(Object o) {

    }
}
class InterC2<A> implements Comparator<Integer>{
    @Override
    public void test(Integer integer) {

    }
}
class InterC3<T,A> implements Comparator<T>{
    @Override
    public void test(T t) {

    }
}