关于后端:Java泛型可行与不可行

个别状况，一个类的属性，或者一个办法的参数 / 返回值都须要在编写代码时申明根本类型或者自定义类型，但有时候无奈在编写代码时应用现有的类来表白参数类型或者返回值类型，这时候就需有一种形式能够表白上面的意思：这里须要一个类，它满足这些要求就能够了，具体是什么类能够在应用这个类或办法时指定。Java 中这种形式就是泛型。然而 java 泛型在应用上有很多限度，应用时要留神，同时留神泛型主义上的了解，Java 中泛型的申明应用更多

肯定程序上继承与接口就能够实现下面的性能，但泛型有很多额定的作用

泛型能够更平安
应用泛型就是通知编译器想应用什么类型，在应用泛型时编译器会对代码进行类型查看，让谬误裸露在编译期，而不是运行期，更平安

能够疾速创立简单的类型

因为在编写时没有指定具体类型，所以在应用时就能够更随便的指定类型，这个性能能够实现相似 js 中对象的性能，对象的属性规定好，具体是什么类型你轻易，然而没能像 js 那样随便增加属性

《2020 最新 Java 根底精讲视频教程和学习路线！》

public class TupleTest<T, R> {

    public final T t;
    public final R r;

    public TupleTest(T t, R r) {
        this.t = t;
        this.r = r;
    }

    public static <A, B> TupleTest<A, B> make(A a, B b) {return new TupleTest<>(a, b);
    }

    /**
     * 如果返回值申明里申明了泛型，那么在办法返回值 new 时就要有尖括号，不然会正告
     * jdk1.5 中返回值申明时的泛型去掉，也会有编译正告
     *
     * @return tupleTest
     */
    public TupleTest<String, String> make() {return new TupleTest<>("a", "b");
    }

     public R getR() {return r;}
}

能够主动实现类型的转换

在泛型呈现之前，如果一个办法不能确定办法的返回值类型，或者依据入参能够确定多种类型返回值类型，那么这个办法就只能返回 Object，有了泛型之后，在办法返回正确的值后，会主动转为具体的类型，而这在代码上没有额定的代码，而且这种转换很平安

下面例子编译之后再反编译回来 make 办法是这样的

 public com.zoro.thinkinginjava.four.TupleTest<String, String> make() {return new com.zoro.thinkinginjava.four.TupleTest((T)"a", (R)"b");
  }

再看一个调用时的代码

public class TupleMain {public static void main(String[] args) {TupleTest<Apple, Orange> tuple = new TupleTest<>(new Apple(), new Orange());

        Orange orange = tuple.getR();}
}

反编译之后

public class TupleMain {public static void main(String[] args) {TupleTest<Apple, Orange> tuple = new TupleTest(new Apple(), new Orange());
    Orange orange = (Orange)tuple.getR();}
}

能够看到主动对参数进行了转型, 所以编译器不会产生转型正告

还有一些更高级的用法，比方 泛型自限定

书写泛型代码的次要艰难是因为泛型在运行时被擦除，所以在运行期没有泛型类的具体信息，这意味着泛型参数看上去就借一个 Object 类，什么都干不了，须要留神以下办法

同样的类型，不同的泛型参数在编译期代表着不同类型，在运行期就没有差异了

public class EraseMain {public static void main(String[] args) {List<String> list1 = new ArrayList<>();
        List<Integer> list2 = new ArrayList<>();
//        list1 = list2; // 编译期是不同的
        System.out.println(list1.getClass().getName());
        System.out.println(list2.getClass().getName());
        // 运行期类型是雷同的
        System.out.println(list1.getClass() == list2.getClass());
    }

}

不能应用 new 来创立泛型类型的具体对象，最好的计划是应用 Class.newInstance()或者应用工场模式

public T getNewInstance() {// return new T();
        // Error:(12, 20) java: 意外的类型
        //  须要: 类
        //  找到:    类型参数 T
        try {return t.newInstance();
        } catch (Exception e) {throw new RuntimeException(e);
        }
    }

不能应用 instanceof 操作符了，但能够用 Class.isInstance(Object)办法

public class EraseEntity<T> {

    Class<T> tClass;

    public EraseEntity(Class<T> tClass) {this.tClass = tClass;}

    public boolean instanceOf(Object t) {
//        return t instanceof T; // 这样就不能够了
        return tClass.isInstance(t); // 这样是能够的
    }

}

不能 new 一个泛型数组，而且要产生泛型数组十分麻烦，能够应用 Array.newInstance(Class<?>,int)
```
 public T[] createArray(){return (T[]) Array.newInstance(t,5);
    } 
```
然而这样也会有正告，须要压抑
除非设定边界，否则不能调用任何自定义的办法

根本类型不能作为泛型参数，然而其包装类型能够，并能够主动包装

//        List<int> list2 = new ArrayList<>();
        List<Integer> list2 = new ArrayList<>();

一个类不能实现同一个泛型接口的两种变体，但去掉泛型实现能够；

public class ImplTest extends AbstractA implements InterfaceA<Integer> {
//public class ImplTest extends AbstractA implements InterfaceA<String> {
// ImplTest 类实现 InterfaceA 接口时申明的泛型参数是 String,AbstractA 实现 InterfaceA 时申明的泛型参数是 Integer, 这时就不能够了，// 如果能够会导致类型抵触, 比方 get 办法，在 AbstractA 中返回值是 Integer, 然而在 ImplTest 中就变成了 String，无论重载或重写都不能解决这个问题
}

interface InterfaceA<T> {T get(T t);

}

abstract class AbstractA implements InterfaceA<Integer> {public Integer get(Integer integer) {return 0;}
}

不能通过不同的泛型参数进行办法重载，然而能够应用 <R extends List<?>> 给泛型参数增加边界重载办法

public class OverLoadTest {public <T> void test(T t) { }

    // 因为 T 与 R 没有设置边界在运行时 T 与 R 都是相似 Object，所以不能通过办法签名辨别这两个办法
//    public <R> void test(R r) { }

    // 这样是能够的 因为 R 肯定会是一个 List 的子类，List 与 Object（T）是有区别的，就能够通过办法签名辨别了
    public <R extends List<?>> void test(R r) {}}

能够应用 extends 限定泛型类型的边界，能够是多个（& 连贯），类写在后面，限定边界之后在泛型办法或者类的外部就能够应用边界类上的办法了

public class WildCardTest<T extends List<String> & Iterable<String> & InterfaceA<?>> {public void test(T t) {t.add("");  // List 接口的办法
        t.iterator(); // Iterable 接口的办法
        t.testMethod(); // InterfaceA 办法}

}

interface InterfaceA<T>{//    void add(T t); // List 接口也有同样办法签名的办法，所以在 同时将 List 与 InterfaceA 设置为上边界时 List 与 InterfaceA 的泛型参数要兼容，否则也会出错
    void testMethod();}

通配符在泛型中的利用是为了解决上面的问题：有一个容器的泛型是基类的变量，想要将一个泛型是子类的容器赋值给这个变量，编译器是不容许的；因为运行时会将泛型擦除，一旦将一个泛型是子类的容器赋值给泛型是基类的容器变量，在运行时就能够将一个这个基类的其余子类对象放入这个窗口，造成在取出对象时的类型不平安，所以编译期不容许这样赋值;

public class WildCardTest<T extends List<String> & Iterable<String> & InterfaceA<?>> {public static void main(String[] args) {
        List<InterfaceA<String>> list ;
        List<Impl> impls = new ArrayList<>();
//        list = impls;
        // 将 impls 赋值给 list 是不能够的，起因：// 1. 编译期 List<InterfaceA<String>> 与 List<Impl> 是不同的且不能向上转型
        // 2. 一旦容许这样赋值，那么之后 的操作会呈现类型问题，比方此例，将一个 ArrayList<Impl> 赋值给 List<InterfaceA> 变量 list，// 那么之后能够向 list 中 add 一个 Impl2 对象，Impl2 与 Impl 不兼容
    }
}
interface InterfaceA<T>{}

class Impl implements InterfaceA<String> {}

class Impl2 implements InterfaceA<String> {}

容器的这一特点与数组不同，子类数组对象能够赋值给基类数组变量（相似向上转型），然而在运行期 jvm 能够晓得数组元素中的对象类型是哪个具体子类，所以如果将数组中元素赋值时，如果不是原数组中的类型，会报错（ArrayStoreException）

public class WildCardTest2 {public static void main(String[] args) {InterfaceA<?>[] arr1 = new Impl[3];
        arr1[0] = new Impl();
        // 会报错
        //arr1[2] = new Impl2();

        // 兼容的类型能够
        InterfaceA<?>[] arr2 = new InterfaceA[4];
        arr2[0] = new Impl();
        arr2[0] = new Impl2();}

}

为了保障类型平安，又能够将子类泛型容器赋值给基类泛型变量，能够应用通配符（繁多边界，extends 前面只能有一个类型）

当一个类在申明时应用了 <? extends Fruit> 这种泛型，而这个类的写法如同上面这样

class TestClass<T>{public void test(T t){// somecode}
    public void test2(Object o){// somecode}
}

在应用时

TestClass<? extends Fruit> f = new TestClass<Apple>;

这样写会呈现的问题是不能调用 test(T) 办法了，因为 test 须要的是一个具体的 Fruit 的子类，例子中应该是 Applie, 但 ? extends Fruit 代表的不仅仅是 Apple 这一种子类，也可能是 orange。如果调用时真的用 orange 类型实例做为能数，类型就不平安，所以 test(T) 办法不能用了；然而 test2(Object) 还能够用

逆变指的是 < ? super Apple> 这种写法，这种写法的个性与 <? extends Apple> 的写法的个性是相同的。下面的例子，泛型入参办法不能用了，而逆变的个性是入参能够是任何 Apple 的子类，留神是子类，不是基类，因为 Apple 的基类有多种，如果编译器容许传入基类，就会存在危险，然而传入子类就不会有危险，因为子类能够转型为 Apple 类，Apple 类能够算是 Apple 的基类；

public class WildcardTest4 {public static void main(String[] args) {List<? super Apple> appleList = new ArrayList<Fruit>();
        List<? super Apple> appleList2 = new ArrayList<Apple>();
        List<? super Apple> appleList3 = new ArrayList<>();
        // 前三种状况都能够，然而这种不能够
//    List<? super Apple> appleList4 = new ArrayList<BigApple>();

        // 不能够
        //appleList3.add(new Orange());
        appleList3.add(new Apple());
        appleList3.add(new BigApple());
        // 尽管字面上是 任何 Apple 的父类，然而 Apple 父类很多，不能确定类型，所以实际上任何 Apple 的父类都不行
        //appleList3.add(new Fruit());
        
        // 只能 Object 接
        Object a = appleList3.get(1);
    }


}

class Fruit {}

class Orange extends Fruit {}

class Apple extends Fruit {}

class BigApple extends Apple implements Runnable {
    @Override
    public void run() {}
}

class SmallApple extends Apple {}

逆变的艰难之处在于办法的返回值，它的返回值只能用 Object 类型的变量承受

两个性能

这里想用泛型代码来编写，这里并不是要用原生的类型，然而当前情况下，泛型参数能够持有任何类型
当有个中央须要多个泛型参数，但你只能确定一部分时能够应用无界通配符？ 例：Map<String, ?>
当一个中央要求泛型，如果你没有给出泛型，会有正告，但应用无界通配符会打消正告

无界通配符与原生类型是不一样的，以 List 和List<?> 为例，List 代表持有任何 Object 类型的 List,List<?> 代表具备某种特定类型的的非原生 List, 但目前不确定是什么类型；

上面例子显示这种区别

public class WildcardTest5 {public static void main(String[] args) {List list = new ArrayList();
        list.add(new Apple());// 有正告，然而不会编译报错
        Object o = list.get(0);

        List<?> list1 = new ArrayList<>();
//        list1.add(new Apple());// 不可这样写，编译报错
    }
}

在应用泛型时，时刻都要想着，我这样定义泛型，编译器为了保障泛型平安，这里我只能承受什么样的类型；办法的返回值会是什么样的；同时要想着这里是否会产生转型

原文链接：https://my.oschina.net/Mzoro/…

关于后端:Java泛型可行与不可行

泛型根底

了解

作用

艰难之处

泛型边界

通配符

通配符的艰难之处

逆变

无界通配符

总结