Java泛型机制详解

引入泛型的原因

泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。

引入泛型的意义

适用于多种数据类型执行相同的代码（代码复用）

public class FloatTest01 {


    static abstract class Animal {
        public abstract void eat();
    }

    static class Cat extends Animal {

        @Override
        public void eat() {
            System.out.println("猫吃鱼");
        }
    }

    static class Dog extends Animal {
        @Override
        public void eat() {
            System.out.println("小狗吃骨头");
        }
    }

    public static void animalEat(Cat cat) {
        cat.eat();
    }

    public static void animalEat(Dog dog) {
        dog.eat();
    }

    public static <T extends Animal> void animalEatUp(T t){
        t.eat();
    }

    public static void main(String[] args) {
        Cat cat = new Cat();
        animalEat(cat);
        Dog dog = new Dog();
        animalEat(dog);
        System.out.println("------------------------");
        animalEatUp(cat);
        animalEatUp(dog);
    }

}

通过看这个例子就可以看出来,实现了代码的复用.(多多少少也有一点多态的影子)

泛型的使用

泛型类

public class Float<T> {  //泛型标识,符号不做限制.T是类型的简称.

    //value的类型由T指定.
    private T value;     

    //返回值的类型也由T指定.
    public T getValue() {
        return value;
    }

    //设置值的类型也由T指定.
    public void setValue(T value) {
        this.value = value;
    }

    public static void main(String[] args) {
        Float<String> strFloat = new Float<>();
        strFloat.setValue("我是string");
        System.out.println(strFloat.getValue());
        System.out.println("=======================");
        Float<Integer> intFloat = new Float<>();
        intFloat.setValue(1);
        System.out.println(intFloat.getValue());
    }
}

多元泛型

public class ManyFloat<K,V> {  //指定了两个泛型类型 
    
    private K key;
    
    private V value;

    public K getKey() {
        return key;
    }

    public void setKey(K key) {
        this.key = key;
    }

    public V getValue() {
        return value;
    }

    public void setValue(V value) {
        this.value = value;
    }

    public static void main(String[] args) {
        ManyFloat<String, String> strManyFloat = new ManyFloat<>();
        strManyFloat.setKey("字符串key");
        strManyFloat.setValue("字符串value");
        System.out.println(strManyFloat.getKey() 
        + strManyFloat.getValue());
        System.out.println("===================");
        ManyFloat<Integer, Integer> intManyFloat = new ManyFloat<>();
        intManyFloat.setKey(1);
        intManyFloat.setValue(2);
        System.out.println(intManyFloat.getKey()+ "--" 
        + intManyFloat.getValue());
    }
}

泛型接口

public interface FloatInterface<T> {  //接口上定义泛型.
    //定义抽象方法,返回值为泛型类型.
    public T getValue();
}

class FloatInterfaceImpl<T> implements FloatInterface<T> {

    private T value;

    //构造方法设置属性内容
    public FloatInterfaceImpl(T value) {
        this.value = value;
    }

    @Override
    public T getValue() {
        return value;
    }

    public static void main(String[] args) {
        FloatInterfaceImpl<String> strImpl = 
         new FloatInterfaceImpl<>("我是string参数");
        System.out.println("值为" + strImpl.getValue());
        System.out.println("====================");
        FloatInterfaceImpl<Integer> intImpl = new FloatInterfaceImpl<>(11);
        System.out.println("值为" + intImpl.getValue());
    }
}

泛型方法

public class FloatMethod {

    //第一个<T>声明此方法有一个泛型T.也可以理解为此方法为泛型方法.
    //第二个T是返回值类型.
    //第三个<T>代表T的具体类型.
    public <T> T getObject(Class<T> c) throws Exception {
        T t = c.newInstance();
        return t;
    }

    public static void main(String[] args) throws Exception {
        FloatMethod floatMethod = new FloatMethod();
        ManyFloat object = (ManyFloat) floatMethod.getObject
         (Class.forName("com.itbo.Genericity.ManyFloat"));
        object.setValue("泛型方法");
        System.out.println(object.getValue());
    }
}

为什么要用泛型方法

因为泛型类要在实例化的时候就指明类型，如果想换一种类型，不得不重新new一次，可能不够灵活；而泛型方法可以在调用的时候指明类型，更加灵活.

泛型上下限

public class FloatUpAndLow {
    
    class A {}
    
    class B extends A{}
    
    public static void testFloatUpAndLowA(A a){
        
    }

    public static void testFloatUpAndLowB(B b){
        testFloatUpAndLowA(b);
    }

    public static void testFloatUpAndLowC(List<A> listA) {
             
    }
    //这里会有异常
    public static void testFloatUpAndLowD(List<B> listB) {
        testFloatUpAndLowC(listB); 
    }
}

解决方式

为了解决泛型中隐含的转换问题，Java泛型加入了类型参数的上下边界机制。<? extends A>表示该类型参数可以是A(上边界)或者A的子类类型。

 public static void testFloatUpAndLowC(List<? extends A> listA) {
    }
    public static void testFloatUpAndLowD(List<B> listB) {
        testFloatUpAndLowC(listB); 
    }

 泛型上下限的引入

在使用泛型的时候，我们可以为传入的泛型类型实参进行上下边界的限制，如：类型实参只准传入某种类型的父类或某种类型的子类。

上限

public class FloatUpAndLow {

    @Data
    class Up {
        private String value;

        public Up(String value) {
            this.value = value;
        }
    }

    class UpSon extends Up {

        public UpSon(String value) {
            super(value);
        }
    }

    @Data
    static class UpTest<T extends Up> {  // 此处泛型只能是Up类型和Up的子类.
        private T value; // 定义泛型变量

        public void setValue(T var) {
            this.value = var;
        }

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

        @Override
        public String toString() {    // 直接打印
            return this.value.toString();
        }
    }

    public static void main(String[] args) {
        UpTest<Up> upUpTest = new UpTest<>();
        UpTest<UpSon> upSonUpTest = new UpTest<>();
    }
}

下限

public class FloatUpAndLow2 {

    public static void main(String[] args) {
        Low<String> stringLow = new Low<>();
        Low<Object> objectLow = new Low<>();
        stringLow.setVar("我是字符串.");
        objectLow.setVar(new Object());
        test(stringLow);
        test(objectLow);
    }

    public static void test(Low<? super String> arg) {
        System.out.println(arg + ",");
    }

}

class Low<T> {
    private T value;        // 定义泛型变量

    public void setVar(T var) {
        this.value = var;
    }

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

    @Override
    public String toString() {    // 直接打印
        return this.value.toString();
    }
}

总结

1:<?> 无限制通配符.

2:<? extends E> extends 关键字声明了类型的上界，表示参数化的类型可能是所指定的类型，或者是此类型的子类.

3:<? super E> super 关键字声明了类型的下界，表示参数化的类型可能是指定的类型，或者是此类型的父类.

有了方向,还会怕走错路嘛.

如果大家喜欢我的分享的话,可以关注我的微信公众号

心有九月星辰