java8泛型

[TOC]​

泛型，也就是将类型参数化，而后在使用类或者方法的时候能够传入类型，在不须要建立新类型实现的前提下能够经过泛型控制形参的类型。泛型能够用在类，方法和接口中。

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等效，<u>?是类型实参而不是类型形参，它用于泛指各类类型实参</u>，当具体类型不肯定的时候就可使用？，示例以下：

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 的多态属性，上下转型的可行性，<u>子类实例能够转换成父类实例，可是父类实例却不必定能转换成子类实例，只有自己就是该子类实例向上转型的父类实例才能够向下转型为子类实例。</u>

<? extends T> 表示类型范围为T以及其子类，<? super T>表示类型范围为T及其父类。 界限通配符在应用于集合的时候会影响集合的读写行为： 上界<? extends T> 限制了类型上限，只能向上转型，能够读，可是无法写，由于子类型不肯定，无法向下转型； 下界<? super T>限制类型的下限，只能向下转型，能够写，可是无法读，由于父类型不肯定，无法向上转型。 示例： ```java 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或者类型变量，这里额外约束的做用是限制类型必须实现相关的接口，示例以下： ```java 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()); } } ``` 此外，附加约束还可用于类型强制转换： ```java 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://codeday.me/bug/20190313/767875.html) [https://juejin.im/post/5b614848e51d45355d51f792](https://juejin.im/post/5b614848e51d45355d51f792) [https://www.cnblogs.com/whatlonelytear/p/11055126.html](https://www.cnblogs.com/whatlonelytear/p/11055126.html) [https://blog.csdn.net/s10461/article/details/53941091](https://blog.csdn.net/s10461/article/details/53941091) [https://blog.csdn.net/claram/article/details/51943742](https://blog.csdn.net/claram/article/details/51943742)

原文出处：https://www.cnblogs.com/cord/p/11616353.html