自定义泛型结构

• 泛型类
• 泛型接口
• 泛型方法

泛型类

//普通类
public class GenericTest {}
//泛型类
public class GenericTest<A> {}

泛型类案例 

普通情况

//泛型类
public class GenericTest {
    int age;
    String name;
    E sex;
    public void method1(E n){
        System.out.println(n);
    }
    public void method2(E[] m){
        System.out.println(Arrays.toString(m));
    }
}
class Test{
    public static void main(String[] args) {
        //实例化时不指定泛型默认为Object
        GenericTest gt1 = new GenericTest();
        gt1.method1("hello");
        gt1.method1(17);
        gt1.method2(new String[]{"a","b","c"});
        gt1.method2(new Integer[]{1,2,3});
        //实例化的时候指定泛型
        GenericTest<String> gt2 = new GenericTest<>();
        gt2.method1("必须是string了，我失去了自由");
        gt2.sex="男";//因为上面已经指定了泛型为string，因此sex为string类型
    }
}

继承情况

父类指定泛型，子类可以直接使用父类方法属性等

//泛型类
public class GenericTest<E> {
    int age;
    String name;
    E sex;
    public void method1(E n){
        System.out.println(n);
    }
    public void method2(E[] m){
        System.out.println(Arrays.toString(m));
    }
}
class SubGenericTest extends GenericTest<Integer>{}
class Test{
    public static void main(String[] args) {
        //父类指定泛型，子类可以直接使用
        SubGenericTest sgt1 = new SubGenericTest();
        sgt1.method1(12);//这里父类指定泛型了，因此必须传Integer类型
    }
}

父类不指定泛型，那么子类直接变成一个泛型类，这个泛型类型可以在子类创建对象时确定

public class GenericTest {
    int age;
    String name;
    E sex;
    public void method1(E n){
        System.out.println(n);
    }
    public void method2(E[] m){
        System.out.println(Arrays.toString(m));
    }
}
class SubGenericTest extends GenericTest{}
class Test{
    public static void main(String[] args) {
        SubGenericTest<String> sgt1 = new SubGenericTest();
        sgt1.method1("hello");
    }
}

泛型类可以定义多个参数类型

public class GenericTest1<A,B,C> {
    A age;
    B name;
    C sex;
    public void method(A m,B n,C x){
        System.out.println(m);
        System.out.println(n);
        System.out.println(x);
    }
    //泛型类的构造器不写泛型类型
    public GenericTest1(){}
}

泛型类总结

• <>里面就是一个参数类型，这个类型现在是不确定的，相当于一个占位符，但是现在确定它是一个引用数据类型
• 实例化的时候才会确定泛型类型
• 遇到继承情况，父类为泛型类，若父类指定了泛型，那么子类可以直接使用
• 父类不指定泛型，那么子类直接变成一个泛型类，这个泛型类型可以在子类创建对象时确定
• 若在实例化的时候，不明确指定泛型，那么默认此泛型为Object类型
• 泛型类可以定义多个参数类型
• 泛型类型的构造器不加<>，就按常规写法即可
• 不同泛型的引用类型不可以相互赋值
• 泛型如果不指定，那么就会被擦除，对应类型为Object类型
• 泛型类里的静态方法不能使用类的泛型（因为static方法优先于对象存在，而泛型是创建对象时指定的，怎么用）
• 创建泛型数组：A[] i=(A[])new Object[10]

泛型方法

public class GenericTest2 {
    //不是泛型方法
    public void method1(E e){}
    //是泛型方法
    public  void method2(T t){}
    public  void method3(T t,U u){}
}

泛型方法的要求：这个方法的泛型的参数类型要和当前类的泛型无关。

注意：泛型方法定义的时候需要在返回值类型前面加上,若不加的话会把T当作一种数据类型，然而代码中并没有T类型，便会报错。

泛型方法案例

public class GenericTest2 {
    //不是泛型方法
    public void method1(E e){}
    //是泛型方法
    public  void method2(T t){}
    public static  void method3(T t,U u){}
}
class Test5{
    public static void main(String[] args) {
        GenericTest2<Object> gt2 = new GenericTest2<>();
        gt2.method2("hello");//调用方法时确定泛型方法为字符串类型
        gt2.method2(12);//调用方法时确定泛型方法为Integer类型
        gt2.method3("hello", true);//调用方法时分别确定了2个泛型
    }
}

泛型方法总结

• 不是带有泛型的方法就是泛型方法
• 泛型方法的泛型类型是在方法调用时确定的
• 泛型方法的泛型类型可以是多个
• 泛型方法可以是静态方法

通配符

泛型通配符写法：

经典案例

public class Test7 {
    public static void main(String[] args) {
        ArrayList<Object> objects = new ArrayList<>();
        ArrayList<String> strings = new ArrayList<>();
        ArrayList<Integer> integers = new ArrayList<>();
        List> list=null;
        list=objects;
        list=strings;
        list=integers;
    }
}

通配符类型变量操作

    public void method3(List list){
        //遍历
        for (Object a:list){
            System.out.println(a);
        }
        //数据的写入操作
        //list.add("abc");报错，因为什么类型都可能接收到，接收到的类型若不是String类型的泛型就没意义了
        list.add(null);//可行，但没意义
        //数据的读取操作
        Object o = list.get(0);
        System.out.println(o);
    }

通配符总结

• A和B是子类父类的关系，G和G不存在子类父类的关系，其是并列关系，但加入通配符?后，G就变成了G和G的父类
• 如果内部遍历该通配符类型的变量，那么用Object即可
• 在List类型变量作为参数的方法中，不能用list随意添加数据
• 在List类型变量作为参数的方法中，数据的读取操作用Object类型接收

public class Person extends Object{}
class Student extends Person{}
class Test8{
    public static void main(String[] args) {
        //下面3个集合不具备子类父类的关系
        ArrayList<Object> objects = new ArrayList<>();
        ArrayList<Person> persons = new ArrayList<>();
        ArrayList<Student> students = new ArrayList<>();
 
        //泛型的上限
        //List是List的父类,也是List的父类
        Listextends Person> list1=null;
        //list1=objects;报错
        list1=persons;
        list1=students;
 
        //泛型的下限
        //List是List的父类,也是List的父类
        Listsuper Person> list2=null;
        list2=objects;
        list2=persons;
        //list2=students;报错
    }
}