java 泛型

只能使用引用类型, 不能使用基本类型(int 与 Integer)

泛型类

/**
 * 泛型类
 *
 * @param <T>
 */
class User<T>{
    private T name;

    public T getName() {
        return name;
    }

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

public class 泛型类 {
    public static void main(String[] args) {
        User<String> user = new User<>();
        user.setName("Marry");
        System.out.println(user.getName());
    }
}

泛型接口

/**
 * 泛型接口, 可以多个泛型
 * @param <T>
 */
interface IUser<T, T2>{
    T getById();

    List<T2> listCompany();

    T2 getCompanyByUser(T t);
}

/**
 * 实现泛型接口
 */
class UserServiceImpl implements IUser<Integer, String> {
    @Override
    public Integer getById() {
        return 1;
    }

    @Override
    public List<String> listCompany() {
        return null;
    }

    @Override
    public String getCompanyByUser(Integer integer) {
        return null;
    }

}
public class 泛型接口 {
    public static void main(String[] args) {
        System.out.println(new UserServiceImpl().getById());
    }
}

泛型方法

class ProductService{

    /**
     * 泛型方法，<T> 不管有没有返回值都需要，是用来定义为泛型方法的，后面才能使用 T 类型的数据，比如参数
     */
    public <T> void getInfo(T t){

        Class<?> aClass = t.getClass();
        // service ...

        System.out.println("泛型方法, 参数为：" + t);
    }

    /**
     * 有返回值的泛型方法
     * @param e 参数，类型为 E
     * @param <E> 当前方法可以使用 E 类型
     */
    public <E> E getInfo2(E e){
        return e;
    }
}
public class 泛型方法 {
    public static void main(String[] args) {
        ProductService service = new ProductService();
        service.getInfo(1);

        service.getInfo2("123");
    }
}

 泛型上下限

/**
 * 基类
 */
class Animal{
    public void eat(){
        System.out.println("Animal -- > 吃");
    }
}

/**
 * 继承 Animal
 */
class People extends Animal{
    public void talk(){
        System.out.println("People -- > 说话");
    }
}

/**
 * 没有继承 Animal
 */
class Flower{
    public void Bloom(){
        System.out.println("Flower -- > 开花");
    }
}

/**
 * 泛型类，传入的类型必须是 Animal 的子类
 * @param <T>
 */
class Man<T extends Animal>{

    T getInfo(T t){
        return t;
    }

    public void work(){
        System.out.println("工作, Man");
    }
}
public class 上下限 {
    public static void main(String[] args) {
        // 通过
        Man<People> man = new Man<People>();
        // 不通过
        // Man<Flower> man2 = new Man<Flower>();
    }
}

通配符

/**
 * 通配符不能定义泛型类/接口，只能用在方法参数/申明类型上
 */
interface ICompany<T>{
    List<T> getById();
}
class CompanyServiceImpl implements ICompany<Integer>{

    private List<?> data;

    @Override
    public List<Integer> getById() {
        return null;
    }


}
public class 通配符 {
    public static void main(String[] args) {

    }
}