泛型 1. 泛型就是参数化类型
2. 作用：安全，方便
3. 适用于对多种数据类型执行相同功能的代码，主要适用于集合
4. 泛型中的类型在使用时指定，不能是基本数据类型
5. 不能在静态方法和静态属性中使用所在类的泛型
6. 通常用单个大写字母表示，尽可能见名知意（T Type， K Key， V Value， E Element ...）
7. 泛型嵌套：由外向内拆分

public class Genericity {
    public static void main(String[] args) {
        List list = new ArrayList();
        // 安全
        list.add("So easy");// 编译时会进行类型检测
        // 方便
        String str = list.get(0);// 不需要强制转型
        
        // JDK 1.4 之前
        List list2 = new ArrayList();
        list2.add(1);
        list2.add("So");
        
        // 取出数据，麻烦，不安全
        Integer num = (Integer)list2.get(0);
        if(list2.get(1) instanceof String){
            String str2 = (String)list2.get(1);
        }  
    }
}

// 泛型接口
public interface IGenericity {
    public static final int MAX_VALUE = 1024;
    public abstract void method(T t) {};
    public abstract T method02(T t) {};
}

// 泛型类
public class Genericity {
public T age;
public static T name;// 报错，不能在静态属性中使用所在类的泛型
public void method(T t) {}
public static void method02(T t) {}// 报错，不能在静态方法中使用所在类的泛型
}

// 泛型方法，在返回类型、void 前使用 
public void method() {}

继承、实现泛型类
1. 父类为泛型类 | 泛型接口，子类继承 | 实现时：
 *   a.父类存在泛型，子类必须 >=
 *   b.父类擦除（即使用时 | 实现时 | 继承时没有指定类型）或指定类型，子类按需编写
 *   c.属性类型和方法根据所在位置而定：在父类中的，随父类而定；在子类中的，随子类而定

public abstract class Father {
    T1 age;
    public abstract void test(T2 name);
}

// 父类存在泛型，子类必须 >=
// 1.擦除，没有指定具体类型。类似于 Object，但不等同于 Object，因为没有指定具体类型，在编译时不会进行类型检测；但如果指定为 Object，则在编译时会进行类型检测
public class Son extends Father/**/{
    @Override
    public void test(Object name) {}
}
// 2.全部保留
public class Son01extends Father{
    @Override
    public void test(T2 name) {}
}
// 3.部分保留
public class Son02extends Father{
    @Override
    public void test(T2 name) {}
}  
// 4.不保留
public class Son03 extends Father{
    @Override
    public void test(String name) {}
}

? 通配符
*  1.类型不确定
*  2.只用于声明变量 | 形参
*  3.不能用在创建对象、泛型类、泛型方法、泛型接口上

public class Wildcards {
    // 声明变量
    List> list = new ArrayList();
    list = new ArrayList();
    list = new ArrayList();
    
    // 声明形参
    public static void test(List> list){
    }

    // 编译错误，不能用在创建对象
    list = new ArrayList>();

    // 编译错误，不能用在创建泛型方法
    public static > void test(){}    

    // 编译错误，不能用在创建泛型类
    class Test>{}
}

extends 泛型的上限  
 * 1.一般用于限制操作
 * 2.不能使用在添加数据上，一般是读取操作

super 泛型的下限  >= 
 * 1.一般用于限制操作
 * 2.能够添加数据，不能添加父类对象 

public class Father {}
public class Son extends Father{}
public class Grandson extends Son{} 

public class Extends {
    public static void main(String[] args) {
        // 规则
        List extends Father> list = new ArrayList();
        test(list);
        List list2 = new ArrayList();
        test(list2);
        List extends Father> list3 = new ArrayList();
        test(list3);
        List extends Son> list4 = new ArrayList();
        test(list4);
        
        List> list5 = new ArrayList();
        test(list5);// 编译错误，因为 > 等同于  extends Object>
        
    }
    
    // ? extends Father
    public static void test(List extends Father> list){
        /*
        不能用于添加数据！！！
        list.add(new Object());
        list.add(new Father());
        list.add(new Son());
        list.add(new Grandson());
        */
        list.add(null);
        System.out.println(list.get(0));
        }
}


public class Super {
    public static void main(String[] args) {
        //规则
        List list = new ArrayList();
        test(list);
        List list2 = new ArrayList();
        test(list2);
        List