java泛型回顾学习

参考blog：https://blog.csdn.net/s10461/article/details/53941091

泛型中 ？的含义

Generic.java

public class Generic {

    private T key;

    public Generic(T key) {
        this.key = key;
    }

    public T getKey() {
        return key;
    }
}

main(测试方法)

//Stu继承了Person
public class main {
    @Test
    public void generic_class() {
        showKeyValue(new Generic<>(new Person("huang")));
        Generic stu = new Generic<>(new Stu("huang", "24"));
        showKeyValue(stu);//这里会报错
        showKeyValue(new Generic<>(new Stu("huang", "24")));
        //这里不会报错 ，因为这里相当于new Generic(new Stu("huang", "24"))
    }

    public void showKeyValue(Generic gPerson) {
        System.out.println("key:"+gPerson.getKey());
    }
}

上面的例子说明了Generic类型的参数，并不能接收Generic。

    public void showKeyValue(Generic gPerson) {
        System.out.println("key:"+gPerson.getKey());
    }

这种方式可以解决这个问题，这种写法表示可以接收任何类型的参数，缺点就是只能使用Object类中的方法。

所以经常使用的是等有边界的方式接收

    public void showKeyValue(Generic gPerson) {
        System.out.println("key:"+gPerson.getKey());
    }

---

泛型方法

由一个仿照java.util.Optional的MyOptional来说明。

public class MyOptional {

    private T value;
    private static final MyOptional EMPTY = new MyOptional();

    private MyOptional() {
        this.value = null;
    }

    public MyOptional(T value) {
        this.value = Objects.requireNonNull(value);
    }
//这是一个泛型方法，用 标注，表示这里的T可以和类上标注的T可以是不同类型
    public static  MyOptional ofNullable(T value) {
        return value == null ? null : new MyOptional<>(value);
    }

    public T get() {
        return this.value;
    }
}

测试方法

    @Test
    public void myOptional_test() {
        MyOptional optional = new MyOptional<>(new Person("huang"));

        MyOptional innerOption = optional.ofNullable("chang");//这里optional泛型Person，ofNullable()方法传入的是String类型。
    }

注意 ：在泛型方法中添加上下边界限制的时候，必须在权限声明与返回值之间的上添加上下

public  T showKeyName(Generic container){
    System.out.println("container key :" + container.getKey());
    T test = container.getKey();
    return test;
}