java--泛型的使用详解--泛型结构使用的几种情况

代码中主要包含：

1、定义泛型类以及实例化

2、定义泛型方法以及调用

3、泛型继承相关的说明

4、泛型通配符的使用

package test;

import javax.xml.soap.SAAJMetaFactory;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

public class Test {
    public static void main(String[] args) {
        // 实例化泛型类，未指定泛型类型
        Temp wlh = new Temp("wlh","001",44);
        wlh.setAge("王力宏");// 未指定泛型类型，默认Object
        System.out.println(wlh);

        // 实例化泛型类，指定泛型
        Temp<String, Integer> zjl = new Temp<>("zjl", "002", 40);
        zjl.setAge(40); // 指定泛型类为Integer后，必须为Integer
        System.out.println(zjl);

        // 实例化泛型类的子类，继承时指定父类泛型类型
        JuniorTemp wbq = new JuniorTemp("wbq", "003", 45);
        wbq.setAge(50);// 继承时指定父类泛型类为Integer后，必须为Integer
        System.out.println(wbq);

        // 实例化泛型类的子类，继承时不指定父类泛型类型，此时该类依然是泛型类
        JuniorTemp01<String,Integer> shl = new JuniorTemp01<>("shl","004",50);
        shl.setAge(56);
        System.out.println(shl);

        // 泛型不同，不能相互赋值，即使指定的类型是父子类也不可以，因为Temp<Object>不是Temp<String>的父类
        Temp<String, Integer> stringIntegerTemp = new Temp<>("zxy","006",11);
        Temp<Integer, Integer> integerIntegerTemp = new Temp<>("yyqx", 7, 22);
        Temp<Integer, Integer> integerIntegerTemp1 = new Temp<>("wk", 8, 22);
        // 不可以
        // stringIntegerTemp = integerIntegerTemp;
        // 可以
        integerIntegerTemp = integerIntegerTemp1;
        System.out.println(integerIntegerTemp);

        // 通配符的使用,看下show1结构
        List<String> listString = new ArrayList<>();
        List<Integer> listInteger = new ArrayList<>();
        List<?> listList = listInteger; // 使用通配符的变量不能添加数据
        wlh.show1(listList);
        listList = listString;
        wlh.show1(listList);

        List<? extends Temp> list001 = null; // Temp 或Temp的子类,不可以add非null
        List<? super Temp> list002 = null;// Temp 或Temp的父类,可以add Temp或其子类
        list001 =  new ArrayList<JuniorTemp>();
        list002 =  new ArrayList<Object>();
        list002.add(new JuniorTemp("AA","AA",11));

        // 调用泛型方法,放什么类型的方法就自动指定什么类型
        System.out.println(wlh.show(100000000));

    }
}
// 自定义泛型类
// 类名后加<>,<>内加泛型形参名，相当于声明了一个临时的类
class Temp<X,Y> {
    private String name;
    private X id;
    private Y age;

    // 泛型类的数组定义
    // X[] xes = new X[10];  // 错误
    X[] xes = (X[])new Object[10];  // 正确

    public Temp(String name, X id, Y age) {
        this.name = name;
        this.id = id;
        this.age = age;
    }
    public void setAge(Y age) {
        this.age = age;
    }
    // 静态方法不能使用泛型
/*    public static void temp(X x){

    }*/

    // 异常类不能使用泛型
/*    public void show(){
        try{}
        catch (X x){

        }
    }*/

    // 泛型方法，泛型方法的泛型参数与类的泛型没有关系，泛型方法所在类不一定是泛型类,泛型方法可以为static
    // 从左到右三个E分别为：1.指明E为泛型(必须）；2.返回值为E类型（可选）；3.参数类型为E(可选）
    public <E> E show(E e){
        System.out.println(e.hashCode());
        return e;
    }

    // 通配符的使用,只能用在<>中
    public void show1(List<?> t){
        Iterator<?> iterator = t.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
    @Override
    public String toString() {
        return "Temp{" +
                "name='" + name + '\'' +
                ", id=" + id +
                ", age=" + age +
                '}';
    }
}

// 继承泛型类，指定父类泛型类型,该类不再是泛型类
class JuniorTemp extends Temp<String,Integer>{

    public JuniorTemp(String name, String id, Integer age) {
        super(name, id, age);
    }
}

// 继承泛型类，不指定父类泛型类型,该类依然是泛型类
class JuniorTemp01<X,Y> extends Temp<X,Y>{

    public JuniorTemp01(String name, X id, Y age) {
        super(name, id, age);
    }
}

// 继承泛型类，不指定父类泛型类型,该类依然是泛型类，部分保留
class JuniorTemp02<Y> extends Temp<String,Y>{

    public JuniorTemp02(String name, String id, Y age) {
        super(name, id, age);
    }
}

// 继承泛型类，不指定父类泛型类型,该类依然是泛型类，部分保留，并有自己的泛型
class JuniorTemp03<A,B,Y> extends Temp<String,Y>{
    private A a;
    private B b;
    public JuniorTemp03(String name, String id, Y age,A a,B b) {
        super(name, id, age);
        this.a = a;
        this.b = b;
    }
}