Java泛型可行与不可行

时间  2020-03-23
标签 java 可行 不可行 栏目 Java 繁體版
原文   原文链接

泛型基础

理解

​ 通常状况，一个类的属性，或者一个方法的参数/返回值都须要在编写代码时声明基本类型或者自定义类型，但有时候没法在编写代码时使用现有的类来表达参数类型或者返回值类型，这时候就需有一种方式能够表达下面的意思：这里须要一个类，它知足这些要求就能够了，具体是什么类能够在使用这个类或方法时指定。Java中这种方式就是泛型。可是java泛型在使用上有不少限制，使用时要注意，同时注意泛型主义上的理解，Java中泛型的声明使用更多java

做用

​ 必定程序上继承与接口就能够完成上面的功能，但泛型有不少额外的做用数组

  1. 泛型能够更安全安全

    使用泛型就是告诉编译器想使用什么类型，在使用泛型时编译器会对代码进行类型检查，让错误暴露在编译期，而不是运行期，更安全app

  2. 能够快速建立复杂的类型jvm

    由于在编写时没有指定具体类型，因此在使用时就能够更随意的指定类型，这个功能能够完成相似js中对象的功能，对象的属性规定好，具体是什么类型你随便，可是没能像js那样随意添加属性ide

    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;
    }
}

  3. 能够自动完成类型的转换ui

在泛型出现以前，若是一个方法不能肯定方法的返回值类型，或者根据入参能够肯定多种类型返回值类型，那么这个方法就只能返回Object ，有了泛型以后，在方法返回正确的值后，会自动转为具体的类型，而这在代码上没有额外的代码，并且这种转换很安全this

上面例子编译以后再反编译回来 make 方法是这样的code

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();
  }
}

能够看到自动对参数进行了转型,因此编译器不会产生转型警告

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

困难之处

书写泛型代码的主要困难是由于泛型在运行时被擦除，因此在运行期没有泛型类的具体信息，这意味着泛型参数看上去就借一个Object类，什么都干不了，须要注意如下方法

  1. 一样的类型，不一样的泛型参数在编译期表明着不一样类型，在运行期就没有差异了

    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());
    }

}

  2. 不能使用 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);
        }
    }

  3. 不能使用 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); // 这样是能够的
    }

}

  4. 不能new 一个泛型数组，并且要产生泛型数组很是麻烦，可使用Array.newInstance(Class<?>,int)

    public T[] createArray(){
        return (T[]) Array.newInstance(t,5);
    }

    可是这样也会有警告，须要压制

  5. 除非设定边界，不然不能调用任何自定义的方法

  6. 基本类型不能做为泛型参数，可是其包装类型能够，并能够自动包装

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

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

    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;
    }
}

  8. 不能经过不一样的泛型参数进行方法重载，可是可使用 <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());// 不可这样写，编译报错
    }
}

总结

在使用泛型时，时刻都要想着，我这样定义泛型，编译器为了保证泛型安全，这里我只能接受什么样的类型； 方法的返回值会是什么样的；同时要想着这里是否会发生转型

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程