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());
    }
}