Java Genericity

四、  Java Genericity

1.  Genericity 泛型

泛型 <T>
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<String> list = new ArrayList<String>();
        // 安全
        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<T> {
    public static final int MAX_VALUE = 1024;
    public abstract void method(T t) {};
    public abstract T method02(T t) {};
}

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

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

2.  继承、实现泛型类

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

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

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

3.  ？ 通配符

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

public class Wildcards {
    // 声明变量
    List<?> list = new ArrayList<>();
    list = new ArrayList<String>();
    list = new ArrayList<Integer>();

    // 声明形参
    public static void test(List<?> list){
    }

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

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

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

4.  extends 泛型上限 & super 泛型下限

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<Father>();
        test(list);
        List<Father> list2 = new ArrayList<Father>();
        test(list2);
        List<? extends Father> list3 = new ArrayList<Son>();
        test(list3);
        List<? extends Son> list4 = new ArrayList<GrandSon>();
        test(list4);

        List<?> list5 = new ArrayList<Son>();
        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<Son> list = new ArrayList<Son>();
        test(list);
        List<Father> list2 = new ArrayList<Father>();
        test(list2);
        List<Object> list3 = new ArrayList<Object>();
        test(list3);
        List<? super Son> list4 = new ArrayList<Son>();
        test(list4);
        List<? super Father> list5 = new ArrayList<Father>();
        test(list5);

        List<? super Grandson> list6 = new ArrayList<Son>();
        test(list6);// 编译错误，因为 <? super Grandson> 中存在不满足 <? super Son> 的情况
        List<?> list7 = new ArrayList<Object>();
        test(list7);// 编译错误，<?> 等同于 <? extends Object>  存在不满足 <? super Son> 的情况
    }

    // ? super Son
    public static void test(List<? super Son> list){
        // 不能添加父类对象  list.add(new Father()); list.add(new Object());
        list.add(new Son());
        list.add(new Grandson());
    }
}