Java 泛型总结(一):基本用法与类型擦除
2017-07-21 17:34
567 查看
转自:https://segmentfault.com/a/1190000005179142
简介
Java 在 1.5 引入了泛型机制,泛型本质是参数化类型,也就是说变量的类型是一个参数,在使用时再指定为具体类型。泛型可以用于类、接口、方法,通过使用泛型可以使代码更简单、安全。然而 Java 中的泛型使用了类型擦除,所以只是伪泛型。这篇文章对泛型的使用以及存在的问题做个总结,主要参考自 《Java 编程思想》。这个系列的另外两篇文章:
Java泛型总结(三):通配符的使用
基本用法
泛型类
如果有一个类 Holder用于包装一个变量,这个变量的类型可能是任意的,怎么编写
Holder呢?在没有泛型之前可以这样:
public class Holder1 { private Object a; public Holder1(Object a) { this.a = a; } public void set(Object a) { this.a = a; } public Object get(){ return a; } public static void main(String[] args) { Holder1 holder1 = new Holder1("not Generic"); String s = (String) holder1.get(); holder1.set(1); Integer x = (Integer) holder1.get(); }
}
在
Holder1中,有一个用
Object引用的变量。因为任何类型都可以向上转型为
Object,所以这个
Holder可以接受任何类型。在取出的时候
Holder只知道它保存的是一个
Object对象,所以要强制转换为对应的类型。在
main方法中,
holder1先是保存了一个字符串,也就是
String对象,接着又变为保存一个
Integer对象(参数
1会自动装箱)。从
Holder中取出变量时强制转换已经比较麻烦,这里还要记住不同的类型,要是转错了就会出现运行时异常。
下面看看
Holder的泛型版本:
public class Holder2<T> { private T a; public Holder2(T a) { this.a = a; } public T get() { return a; } public void set(T a) { this.a = a; } public static void main(String[] args) { Holder2<String> holder2 = new Holder2<>("Generic"); String s = holder2.get(); holder2.set("test"); holder2.set(1);//无法编译 参数 1 不是 String 类型 }
}
在
Holder2中, 变量
a是一个参数化类型
T,
T只是一个标识,用其它字母也是可以的。创建
Holder2对象的时候,在尖括号中传入了参数
T的类型,那么在这个对象中,所有出现
T的地方相当于都用
String替换了。现在的
get的取出来的不是
Object,而是
String对象,因此不需要类型转换。另外,当调用
set时,只能传入
String类型,否则编译无法通过。这就保证了
holder2中的类型安全,避免由于不小心传入错误的类型。
通过上面的例子可以看出泛使得代码更简便、安全。引入泛型之后,Java 库的一些类,比如常用的容器类也被改写为支持泛型,我们使用的时候都会传入参数类型,如:
ArrayList<Integer> list = ArrayList<>();。
泛型方法
泛型不仅可以针对类,还可以单独使某个方法是泛型的,举个例子:public class GenericMethod { public <K,V> void f(K k,V v) { System.out.println(k.getClass().getSimpleName()); System.out.println(v.getClass().getSimpleName()); } public static void main(String[] args) { GenericMethod gm = new GenericMethod(); gm.f(new Integer(0),new String("generic")); } } 代码输出: Integer String
GenericMethod类本身不是泛型的,创建它的对象的时候不需要传入泛型参数,但是它的方法
f是泛型方法。在返回类型之前是它的参数标识
<K,V>,注意这里有两个泛型参数,所以泛型参数可以有多个。
调用泛型方法时可以不显式传入泛型参数,上面的调用就没有。这是因为编译器会使用参数类型推断,根据传入的实参的类型 (这里是
integer和
String)
推断出
K和
V的类型。
类型擦除
什么是类型擦除
Java 的泛型使用了类型擦除机制,这个引来了很大的争议,以至于 Java 的泛型功能受到限制,只能说是”伪泛型“。什么叫类型擦除呢?简单的说就是,类型参数只存在于编译期,在运行时,Java 的虚拟机 ( JVM ) 并不知道泛型的存在。先看个例子:public class ErasedTypeEquivalence { public static void main(String[] args) { Class c1 = new ArrayList<String>().getClass(); Class c2 = new ArrayList<Integer>().getClass(); System.out.println(c1 == c2); } }
上面的代码有两个不同的
ArrayList:
ArrayList<Integer>和
ArrayList<String>。在我们看来它们的参数化类型不同,一个保存整性,一个保存字符串。但是通过比较它们的
Class对象,上面的代码输出是
true。这说明在
JVM 看来它们是同一个类。而在 C++、C# 这些支持真泛型的语言中,它们就是不同的类。
泛型参数会擦除到它的第一个边界,比如说上面的
Holder2类,参数类型是一个单独的
T,那么就擦除到
Object,相当于所有出现
T的地方都用
Object替换。所以在
JVM 看来,保存的变量
a还是
Object类型。之所以取出来自动就是我们传入的参数类型,这是因为编译器在编译生成的字节码文件中插入了类型转换的代码,不需要我们手动转型了。如果参数类型有边界那么就擦除到它的第一个边界,这个下一节再说。
擦除带来的问题
擦除会出现一些问题,下面是一个例子:class HasF { public void f() { System.out.println("HasF.f()"); } } public class Manipulator<T> { private T obj; public Manipulator(T obj) { this.obj = obj; } public void manipulate() { obj.f(); //无法编译 找不到符号 f() } public static void main(String[] args) { HasF hasF = new HasF(); Manipulator<HasF> manipulator = new Manipulator<>(hasF); manipulator.manipulate(); }
}
上面的
Manipulator是一个泛型类,内部用一个泛型化的变量
obj,在
manipulate方法中,调用了
obj的方法
f(),但是这行代码无法编译。因为类型擦除,编译器不确定
obj是否有
f()方法。解决这个问题的方法是给
T一个边界:
class Manipulator2<T extends HasF> { private T obj; public Manipulator2(T x) { obj = x; } public void manipulate() { obj.f(); } }
现在
T的类型是
<T extends HasF>,这表示
T必须是
HasF或者
HasF的导出类型。这样,调用
f()方法才安全。
HasF就是
T的边界,因此通过类型擦除后,所有出现
T的
地方都用
HasF替换。这样编译器就知道
obj是有方法
f()的。
但是这样就抵消了泛型带来的好处,上面的类完全可以改成这样:
class Manipulator3 { private HasF obj; public Manipulator3(HasF x) { obj = x; } public void manipulate() { obj.f(); } }
所以泛型只有在比较复杂的类中才体现出作用。但是像
<T extends HasF>这种形式的东西不是完全没有意义的。如果类中有一个返回
T类型的方法,泛型就有用了,因为这样会返回准确类型。比如下面的例子:
class ReturnGenericType<T extends HasF> { private T obj; public ReturnGenericType(T x) { obj = x; } public T get() { return obj; } }
这里的
get()方法返回的是泛型参数的准确类型,而不是
HasF。
类型擦除的补偿
类型擦除导致泛型丧失了一些功能,任何在运行期需要知道确切类型的代码都无法工作。比如下面的例子:public class Erased<T> { private final int SIZE = 100; public static void f(Object arg) { if(arg instanceof T) {} // Error T var = new T(); // Error T[] array = new T[SIZE]; // Error T[] array = (T)new Object[SIZE]; // Unchecked warning } }
通过
new T()创建对象是不行的,一是由于类型擦除,二是由于编译器不知道
T是否有默认的构造器。一种解决的办法是传递一个工厂对象并且通过它创建新的实例。
interface FactoryI<T> { T create(); } class Foo2<T> { private T x; public <F extends FactoryI<T>> Foo2(F factory) { x = factory.create(); } // ... } class IntegerFactory implements FactoryI<Integer> { public Integer create() { return new Integer(0); } } class Widget { public static class Factory implements FactoryI<Widget> { public Widget create() { return new Widget(); } } } public class FactoryConstraint { public static void main(String[] args) { new Foo2<Integer>(new IntegerFactory()); new Foo2<Widget>(new Widget.Factory()); } }
另一种解决的方法是利用模板设计模式:
abstract class GenericWithCreate<T> { final T element; GenericWithCreate() { element = create(); } abstract T create(); } class X {} class Creator extends GenericWithCreate<X> { X create() { return new X(); } void f() { System.out.println(element.getClass().getSimpleName()); } } public class CreatorGeneric { public static void main(String[] args) { Creator c = new Creator(); c.f(); } }
具体类型的创建放到了子类继承父类时,在
create方法中创建实际的类型并返回。
总结
本文介绍了 Java 泛型的使用,以及类型擦除相关的问题。一般情况下泛型的使用比较简单,但是某些情况下,尤其是自己编写使用泛型的类或者方法时要注意类型擦除的问题。接下来会介绍数组与泛型的关系以及通配符的使用。
相关文章推荐
- Java 泛型总结(一):基本用法与类型擦除
- Java 泛型 四 基本用法与类型擦除
- Java基本类型用法总结
- Java中的枚举类型-1:基本用法
- JAVA语法总结 - 基本数据类型
- Java基本类型转换总结
- java——(常量、变量、基本类型、进制、运算符)总结
- Java中八种基本数据类型占用字节空间总结
- 黑马程序员--Java基础加强--02.代码简化 书写规律I_原始数据类型【重载】【多态】【泛型】【泛型限定】【个人总结】
- Java核心编程第三章java的基本数据类型及运算符的总结
- Java 中八种基本数据类型占用字节空间总结
- 【Java心得总结一】Java基本类型和包装类型解析
- 2006-07-28 Java的常用包,"=="和"equals"的用法,基本数据类型与引用类型,对象的克隆
- 黑马程序员--Java基础加强--03.代码简化 书写规律II_参数化数据类型【重载】【多态】【泛型】【泛型限定】【个人总结】
- Java基本类型转换总结
- Java语法总结 - 基本数据类型
- Java中的枚举类型-1:基本用法
- JAVA语法总结 - 基本数据类型
- Java返回类型泛型的用法小结
- Java基本数据类型总结