【Java 泛型】

泛型类和泛型接口

package com.yuzhenc.collection;

/**
 * @author: yuzhenc
 * @date: 2022-03-07 21:39:38
 * @desc: com.yuzhenc.collection
 * @version: 1.0
 */
public class Test06 {
    public static void main(String[] args) {
        Person<String,Integer,Integer> p1 = new Person<>("sqlboy",25,1);
        Person<String,Integer,String> p2 = new Person<>("sqlgirl",25,"男");
        //p1 = p2;//4.不同泛型引用的引用类型不可以相互赋值

        Person p3 = new Person<String,Integer,Integer>("sqlboy",25,1);
        Person p4 = new Person<String,Integer,String>("sqlgirl",25,"男");
        p3 = p4;
        //不指定泛型时可以传任何类型
        Person p5 = new Person(1,2,true);
    }
}
//泛型类
//3.泛型类可以定义多个泛型参数
class Person <A,B,C> {
    A name;
    B age;
    C sex;

    public Person() {}

    public Person(A name, B age, C sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    public A getName() {
        return name;
    }

    public void setName(A name) {
        this.name = name;
    }

    public B getAge() {
        return age;
    }

    public void setAge(B age) {
        this.age = age;
    }

    public C getSex() {
        return sex;
    }

    public void setSex(C sex) {
        this.sex = sex;
    }
}

/*
//int报错
//泛型参数一定是引用类型的参数
class Student extends Person <String,int,String> {

}*/
//1.继承时父类指定泛型
class Student extends Person <String,Integer,String> {

}
//2.继承时，父类不指定泛型，子类仍是泛型类
class Teacher<A,B,C> extends Person<A,B,C> {
    public Teacher() {}

    public Teacher(A name, B age, C sex) {
        super(name, age, sex);
    }

    /*
    //5.泛型类中的静态方法不能使用类的泛型
    public static void b(B b) {

    }*/
    //6.不能直接使用A[]创建数组
    public void c() {
        //C[] c = new C[10];//不可以
        C[] c = (C[])new Object[10];
    }
}

泛型方法

package com.yuzhenc.collection;

/**
 * @author: yuzhenc
 * @date: 2022-03-07 22:22:03
 * @desc: com.yuzhenc.collection
 * @version: 1.0
 */
public class Test07 {
    public static void main(String[] args) {
        System.out.println(a(true));
        System.out.println(a(1));
        System.out.println(a("sqlboy"));
        System.out.println(a(1.1));
    }
    //泛型方法
    /*
        1.什么是泛型方法：
            不是带泛型的方法就是泛型方法
            泛型方法有要求：这个方法的泛型的参数类型要和当前的类的泛型无关
            泛型方法对应的那个泛型参数类型 和  当前所在的这个类 是否是泛型类，泛型是啥  无关
        2.泛型方法定义的时候，前面要加上<T>
            原因：如果不加的话，会把T当做一种数据类型，然而代码中没有T类型那么就会报错
        3.T的类型是在调用方法的时候确定的
        4.泛型方法可以是静态方法
    */
    public static <T> T a(T t) {
        return t;
    }
}

通配符

package com.yuzhenc.collection;

import java.util.ArrayList;
import java.util.List;

/**
 * @author: yuzhenc
 * @date: 2022-03-07 22:31:42
 * @desc: com.yuzhenc.collection
 * @version: 1.0
 */
public class Test08 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("sqlboy");
        list.add("Hello");
        b(list);
    }

    public static void a(List<String> a) {
        for (String s : a) {
            System.out.println(s);
        }
    }
    /*
    //这里不是重载，是方法重定义，报错
    public static void a(List<Integer> a) {

    }
    */
    public static void b(List<?> b) {
        //1.遍历
        for (Object s : b) {
            System.out.println(s);
        }
        //2.数据的写入
        //b.add("sqlboy");//不能随便写入数据，报错
        b.add(null);
        //3.数据的读取
        Object o1 = b.get(0);
        Object o2 = b.get(1);
        Object o3 = b.get(2);
        System.out.println(o1);
        System.out.println(o2);
        System.out.println(o3);
    }
}

泛型受限

package com.yuzhenc.collection;

import java.util.ArrayList;
import java.util.List;

/**
 * @author: yuzhenc
 * @date: 2022-03-07 22:56:13
 * @desc: com.yuzhenc.collection
 * @version: 1.0
 */
public class Test09 {
    //这是main方法，程序的入口
    public static void main(String[] args) {
        //a,b,c三个集合是并列的关系：
        List<Object> a = new ArrayList<>();
        List<Person> b = new ArrayList<>();
        List<Student> c = new ArrayList<>();
        /*开始使用泛型受限：泛型的上限
        List<? extends Person>:
        就相当于：
        List<? extends Person>是List<Person>的父类，是List<Person的子类>的父类
         */
        List<? extends Person> list1 = null;
        //list1 = a;
        list1 = b;
        list1 = c;
        /*开始使用泛型受限：泛型的下限
        List<? super Person>
        就相当于：
        List<? super Person>是List<Person>的父类，是List<Person的父类>的父类
         */
        List<? super Person> list2 = null;
        list2 = a;
        list2 = b;
        //list3 = c;
    }
}