java泛型学习

没有java泛型会存在的问题

1. 假设我们有一个方法，希望通过传递不同类型的参数，输出不同类型的对象值。正常情况下我们可能会写不同的方法来实现，但是这样会导致类不断增加，并且类方法很相似，不能够复用。进而导致类爆炸
2. 假设有一个方法，我们希望传参具有一定约束，而不是像Object对象一样随便传参

java泛型的常见使用

包装类型参数

1. 定义一个方法，打印各种包装类型

public class Generics1<T> {
    private T name;

    public Generics1(T name) {
        this.name = name;
    }

    public void allPrint(){
        System.out.println(name);
    }
}

• main

public class Main {

    public static void main(String[] args) {
        Generics1<Integer> integerGenerics1 = new Generics1<>(1);
        integerGenerics1.allPrint();

        Generics1<String> stringGenerics2 = new Generics1<>("222222");
        stringGenerics2.allPrint();

        Generics1<Long> longGenerics3 = new Generics1<>(222L);
        longGenerics3.allPrint();
    }
}

注意：泛型里面必须是对象，或者包装类型。基础类型是不被允许的

多个包装类型参数

2. 两个泛型参数

public class Generics2<T,K> {

    private T name;
    private K context;

    public Generics2(T name,K context) {
        this.name = name;
        this.context=context;
    }

    public void allPrint(){
        System.out.println(name);
        System.out.println(context);
    }
}

• Main

public class Main2 {

    public static void main(String[] args) {
        Generics2<String, Integer> stringIntegerGenerics2 = new Generics2<>("1111", 222);
        stringIntegerGenerics2.allPrint();

    }
}

上界继承

1. 限定使用者传递的参数必须继承某个父类之下

public class Generics3<T extends Vehicle> {

    private T name;

    public Generics3(T name) {
        this.name = name;
    }

    public void allPrint(){
        System.out.println(name.getName());
    }
}

• 父类

public class Vehicle {


    private String name;

    public String getName() {
        return name;
    }

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

    public void run(String name){
        System.out.println(name+"can run");
    }
}

• 子类

public class Car extends Vehicle{

    private Integer wheel;



    public Integer getWheel() {
        return wheel;
    }

    public void setWheel(Integer wheel) {
        this.wheel = wheel;
    }


    public void getWheel(String name,Integer wheel) {
        System.out.println(name+"有"+wheel+"个轮子");
    }
}

2. 可以不是父 类，可以是接口。接口有更好的扩展性

public class Generics4<T extends Vehi> {

    private T vehics;

    public Generics4(T vehics) {
        this.vehics = vehics;
    }

    public void allPrint(){
        vehics.run();
    }
}

• 接口

public interface Vehi {
    void run();
}

使用上界继承的好处

1. 使用上界继承的最大好处是：必然我们会用到接口或者父类，那么我们可以抽取一些公共方法，放到父类或接口里面。不同的实现拥有不同的处理方式。具备更强的扩展性
2. java里面虽然有Object来实现传递各种类型参数（如下），但是不推荐这么做。会产生一种。例如：当我们从List取值的时候，java是无法推断里面值的类型，编译器就会报错

上面这个代码在运行时，获取第二个值时，就会报错。
使用Object，在编译阶段是没有问题的，但是在运行时就会出现问题。
而使用泛型，在编译阶段，就能检查出来问题

泛型函数：Generic method

泛型函数方法的定义

1. 在返回类型前添加泛型类型： 。参数设置为泛型

private static <T> void printAll(T myOb){
}

2. 举例子

public class Main5 {

    public static void main(String[] args) {
        printAll(new BigCar(3,"myba"));
    }


    private static <T> void printAll(T myOb){
        System.out.println(myOb);
    }
}

3. 同理也可以使用上界继承限定

    private static <T> void printAll(T myOb){
        System.out.println(myOb);
    }

private static <T extends Vehicle & Vehi> void printAll(T myOb){
    System.out.println(myOb);
}

4. 配置多个参数

private static <T,K> void printAll2(T myOb,K myob2){
    System.out.println(myOb);
    System.out.println(myob2);
}

泛型通配符

1. String，Integer，Long我们在传递参数时，可以用Object来定义参数。但是：List，却不是List的子类。这种情况怎么处理？
2. 通配符的使用

private static void printAll(List<?> myOb){
    System.out.println(myOb);
}

上界通配符

1. 意思是，传入的参数必须是Vehi的子类或者实现，或者本身

private static void printAll(List<? extends Vehi> myOb){
    System.out.println(myOb);
}

下界通配符

1. 意思是传入的参数必须是Car的父类或者Car本身

private static void printAll(List<? super Car> myOb){
    System.out.println(myOb);
}