java8泛型

目录

• 1，泛型中的相关操作符
• 2，泛型基本使用示例
• 3，通配符
  • 3.1, T和?的区别
  • 3.2，上下界通配符
• 4, 附加约束(&)

泛型，也就是将类型参数化，然后在使用类或者方法的时候可以传入类型，在不需要创建新类型实现的前提下可以通过泛型控制形参的类型。泛型可以用在类，方法和接口中。

1，泛型中的相关操作符

		在使用泛型的代码中经常可以看到一些泛型相关的符号，它们的作用如下表所示：

类型	功能
T,E,K,V	泛型标识，可以写人任意标识，不同字母更多是一种约定，等同于< T extends Object>
?	无限制通配符，表示不确定类型，等同于< ? extends Object>
extend	上界通配符
super	下界通配符
&	附加约束(AdditionalBound, tjls8-4.4)

2，泛型基本使用示例

public class GenericDemo<C> { //泛型类

    public static void main(String[] args) {
        //泛型类用Integer初始化，所以C相关的方法属性必须是Integer
        GenericDemo<Integer> gd = new GenericDemo<Integer>();
        gd.classPrint(1);
        gd.setX(2);
        //----------------------
        //泛型方法，与调用的类型保持一致，参数类型得为String
        GenericDemo.<String>methodPrint("abc");
        //---------------------
        //泛型接口，与初始化时候传入的类型保持一致,参数类型得是Double
        IFC<Double> ifc = new IFC<Double>() {};
        ifc.interfacePrint(2.9);
    }

    private C c;

    public void setX(C c) {
        this.c = c;
    }
        public void classPrint(C c) {
        System.out.println(c.getClass());
    }

    //泛型方法，前面的<T>是为了标识这是一个泛型方法
    public static <T> void methodPrint(T t) {
        System.out.println(t.getClass());
    }

    interface IFC<I> { //泛型接口
        default void interfacePrint(I i) { System.out.println(i.getClass());}
    }
}

3，通配符

3.1, T和?的区别

基本泛型T是用于定义，将数据类型参数化，不能用于实例化。而 ? 则是在实例化对象时不确定泛型具体参数类型的时候泛指Object的所有子类型。

类型	特点
T	< T extends Object>，用于定义
?	< ? extends Object>，用于实例化

?不能和Object等效，?是类型实参而不是类型形参，它用于泛指各种类型实参，当具体类型不确定的时候就可以使用？，示例如下：

public class test6 {
    public static void main(String[] args) {
        List<String> list1 = new ArrayList<>();
        List<Integer> list2 = new ArrayList<>();
        test(list1);
        test(list2);
    }

    public static void test(List<?> list) {
        System.out.println(list);
    }
}

3.2，上下界通配符

上下界通配符其实涉及到java 的多态属性，上下转型的可行性，子类实例可以转换成父类实例，但是父类实例却不一定能转换成子类实例，只有本身就是该子类实例向上转型的父类实例才可以向下转型为子类实例。

<? extends T> 表示类型范围为T以及其子类，<? super T>表示类型范围为T及其父类。

界限通配符在应用于集合的时候会影响集合的读写行为：

上界<? extends T> 限制了类型上限，只能向上转型，可以读，但是没法写，因为子类型不确定，没法向下转型；

下界<? super T>限制类型的下限，只能向下转型，可以写，但是没法读，因为父类型不确定，没法向上转型。

示例：

public class test {

    public static void main(String[] args) {
        //<? extends B> 范围: A类或者A的子类
        //由于下限不确定，所以无法向下转型至具体类型
        List<? extends B> list1 = new ArrayList<B>(){{add(new B());}};
//        list1.add(new B()); //无法添加该类型, 向下转型无法确定目标类型
//        list1.add(new C());
        A a = list1.get(0); //正常向上转型

        //<? super B> 范围: B类或者B的父类
        //由于上限不确定，所以B类和B类的子类均可以加入，但是B类的父类不行
        List<? super B> list2 = new ArrayList<>();
//        list2.add(new A()); //无法向下转型
        list2.add(new B()); //正常向上转型
        list2.add(new C());
//        C c = list2.get(0);//无法向下转型，不加强制转换会报错
        C c = (C)list2.get(0);
    }
    //   A -> B -> C
    static class A {};
    static class B extends A {};
    static class C extends B {};
}

4, 附加约束(&)

AdditionalBound 的语法如下：

TypeBound:
extends ClassOrInterfaceType {AdditionalBound}
AdditionalBound:
& InterfaceType

也就是说extends后面可以在加个额外约束，具体为接口类型，可以I1 & I2 & I3这样连排，注意必须是接口类型，不能是class或者类型变量，这里额外约束的作用是限制类型必须实现相关的接口，示例如下：

public class test {

    public static void main(String[] args) {
        test1(1); test1("1");
        test2(2); test2("2");
//        test3(3);  //test3方法String类型才满足额外约束
        test3("3");
    }

    public static <T extends Object> void test1(T t) {
        System.out.println(t.getClass());
    }
	//得同时实现Serializable和Comparable接口
    public static <T extends Object & Serializable & Comparable> void test2(T t) {
        System.out.println(t.getClass());
    }
	//得同时实现Serializable,CharSequence和Comparable接口
    public static <T extends Object & Serializable & CharSequence & Comparable> void test3(T t) {
        System.out.println(t.getClass());
    }
}

此外，附加约束还可用于类型强制转换：

public class test12 {
    public static void main(String[] args) {
        System.out.println(test());
    }
    public static Object test() {
//        return (Object & Number)"abced"; //编译不通过
//        return (Object)"abced"; //编译通过
        return (Object & CharSequence & Comparable)"abcde"; //编译通过
    }
}

在一些类型转换的场景可以通过附加约束控制类型转换的范围。

参考链接：

https://codeday.me/bug/20190313/767875.html

https://juejin.im/post/5b614848e51d45355d51f792

https://www.cnblogs.com/whatlonelytear/p/11055126.html

https://blog.csdn.net/s10461/article/details/53941091

https://blog.csdn.net/claram/article/details/51943742