제네릭의 핵심은 Parameterized Type을 적용한 것입니다. , 연산되는 데이터 유형을 매개 변수로 지정하고 사용 시 특정 유형을 지정합니다.
이 매개변수 유형은 각각 일반 클래스, 일반 인터페이스 및 일반 메소드라고 하는 클래스, 인터페이스 및 메소드를 생성하는 데 사용할 수 있습니다.
JDK 1.5 이전에는 Object만이 모든 유형의 상위 클래스이고 유형 캐스팅입니다. 특성은 유형 일반화를 달성할 수 있습니다.
따라서 컴파일 중에 컴파일러는 이 개체의 캐스팅이 성공했는지 여부를 확인할 수 없으며 이로 인해 ClassCastException(캐스트 예외)이 발생할 수 있습니다.
제네릭의 역할을 이해하기 위해 예를 살펴보겠습니다.
제네릭을 사용하지 않는 경우(1.5 이전)
ArrayList arrayList = new ArrayList(); arrayList.add(100); arrayList.add("abc");//因为不知道取出来的值的类型,类型转换的时候容易出错 String str = (String) arrayList.get(0);
generic 사용(1.5 이후)
ArrayList<String> arrayList = new ArrayList<String>(); arrayList.add("abc");//因为限定了类型,所以不能添加整形,编译器会提示出错arrayList.add(100);
// 以 ArrayList<E>,ArrayList<Integer> 为例:ArrayList<E>:泛型类型 E:类型变量(或者类型参数) ArrayList<Integer> :参数化的类型 Integer:类型参数的实例(或实际类型参数) ArrayList :原始类型
일반 클래스
class Demo<T> { private T value; Demo(T value) { this.value = value; } public T getValue() { return value; } public void setValue(T value) { this.value = value; } }public class Test { public static void main(String[] args) { Demo<String> demo = new Demo("abc"); demo.setValue("cba"); System.out.println(demo.getValue()); // cba } }
일반 인터페이스
interface Demo<K, V> { void print(K k, V v); } class DemoImpl implements Demo<String, Integer> { @Override public void print(String k, Integer v) { System.out.println(k + "-" + v); } }public class Test { public static void main(String[] args) { Demo<String, Integer> demo = new DemoImpl(); demo.print("abc", 100); } }
일반 메서드
public class Test { public static void main(String[] args) { int num = get("abc", 100); System.out.println(num); } // 关键 --> 多了 <K, V> ,可以理解为声明此方法为泛型方法 public static <K, V> V get(K k, V v) { if (k != null) { return v; } return null; } }
형 한정은 제네릭 클래스, 제네릭 인터페이스, 제네릭 메서드에서 사용할 수 있지만, 다음 사항에 주의하시기 바랍니다.
자격이 클래스 또는 인터페이스인 경우 키워드 확장
& 기호를 사용하여 여러 자격을 부여할 수 있습니다
자격이 둘 다 있는 경우 인터페이스와 클래스가 있는 경우 클래스는 하나만 있어야 하며 먼저 배치되어야 합니다. 예를 들면 다음과 같습니다.
public static <T extends Comparable&Serializable> T get(T t1,T t2)
유형 제한의 역할을 분석해 보겠습니다.
public static <T> T get(T t1,T t2) { //编译错误 if(t1.compareTo(t2)>=0); return t1; }
public static <T extends Comparable> T get(T t1,T t2) { if(t1.compareTo(t2)>=0); return t1; }
public class Test { public static void main(String[] args) { ArrayList<String> arrayList1 =new ArrayList<String>(); ArrayList<Integer> arrayList2 = new ArrayList<Integer>(); // true System.out.println(arrayList1.getClass() == arrayList2.getClass()); } }코드를 살펴보세요. 두 개의 ArrayList 배열이 여기에 정의되어 있습니다.
public class Test { public static void main(String[] args) throws Exception{ ArrayList<String> arrayList =new ArrayList<String>(); arrayList.add("abc"); arrayList.getClass().getMethod("add", Object.class).invoke(arrayList, 100); for (int i=0;i<arrayList.size();i++) { System.out.println(arrayList.get(i)); } } }코드를 살펴보세요. 여기서는 Integer로 인스턴스화된 ArrayList 일반 유형 개체가 정의되어 있습니다.
바이트코드 에 있는 유형 변수의 실제 유형입니다.
// 此时 T 是一个无限定类型,所以原始类型就是 Objectclass Pair<T> { } // 类型变量有限定,原始类型就用第一个边界的类型变量来替换,即Comparableclass Pair<T extends Comparable& Serializable> { } // 此时原始类型为 Serializable,编译器在必要的时要向 Comparable 插入强制类型转换 // 为了提高效率,应该将标签(tagging)接口(即没有方法的接口)放在边界限定列表的末尾class Pair<T extends Serializable&Comparable>
public class Test { // 定义泛型方法 public static <T> T add(T x, T y) { return y; } public static void main(String[] args) { // 1.不指定泛型 // 两个参数都是 Integer,所以 T 为 Integer 类型 int i = Test.add(1, 2); // 两个参数分别是 Integer,Float,取同一父类的最小级,T 为 Number 类型 Number f = Test.add(1, 1.2); // T 为 Object Object o = Test.add(1, "asd"); // 2.指定泛型 // 指定了Integer,所以只能为 Integer 类型或者其子类 int a = Test.<Integer> add(1, 2); //编译错误,指定了 Integer,不能为Float int b=Test.<Integer>add(1, 2.2); // 指定为Number,所以可以为 Integer,Float Number c = Test.<Number> add(1, 2.2); } }
아래 예에서 list는 참조 객체이므로 유형 검사는 이에 반대됩니다.
// 没有进行类型检查,等价于 ArrayList list = new ArrayLis()ArrayList list = new ArrayList<String>(); list.add(100); list.add("hello");// 进行编译检查,等价于 ArrayList<String> list = new ArrayList<String>();ArrayList<String> list = new ArrayList(); list.add("hello"); list.add(100); // 编译错误
来看下面的例子,这里定义了一个泛型类 Parent,一个实现它的子类 Son,并在子类中重写了父类的方法。
class Parent<T> { private T value; public T getValue() { return value; } public void setValue(T value) { this.value = value; } } class Son extends Parent<String>{ @Override public void setValue(String value) { super.setValue(value); } @Override public String getValue(){ return super.getValue();} }
在上面提到过泛型的类型参数在编译时会被类型擦除,因此编译后的 Parent 类如下:
class Parent { private Object value; public Object getValue() { return value; } public void setValue(Object value) { this.value = value; } }
此时对比 Parent 与 Son 的 getValue/setValue 方法,发现方法的参数类型已经改变,从 Object -> String,这也意味着不是重写(overrride) 而是重载(overload)。
然而调用 Son 的 setValue 方法, 发现添加 Object 对象时编译错误。说明也不是重载。
public class Test { public static void main(String[] args) { Son son = new Son(); son.setValue("hello"); // 关键 -->编译错误 son.setValue(new Object()); } }
那么问题来了,通过上面的分析?Son 中定义的方法到底是重写还是重载?答案是:重写。这里 JVM 采用了桥方法(Brige)来解决类型擦除和多态引起的冲突。
我们对 Son 进行反编译(”Javap -c 类名.class”),得到如下内容:
Compiled from "Test.java"class Son extends Parent<java.lang.String> { Son(); Code: 0: aload_0 1: invokespecial #8 // Method Parent."<init>":()V 4: return public void setValue(java.lang.String); Code: 0: aload_0 1: aload_1 2: invokespecial #16 // Method Parent.setValue:(Ljava/lang/Object;)V 5: return public java.lang.String getValue(); Code: 0: aload_0 1: invokespecial #23 // Method Parent.getValue:()Ljava/lang/Object; 4: checkcast #26 // class java/lang/String 7: areturn public java.lang.Object getValue(); Code: 0: aload_0 1: invokevirtual #28 // Method getValue:()Ljava/lang/String; 4: areturn public void setValue(java.lang.Object); Code: 0: aload_0 1: aload_1 2: checkcast #26 // class java/lang/String 5: invokevirtual #30 // Method setValue:(Ljava/lang/String;)V 8: return }
发现这里共有 4 个 setValue/getValue 方法,除了 Son 表面上重写的 String 类型,编译器又自己生成了 Object 类型的方法,也称为桥方法。结果就是,编译器通过桥方法真正实现了重写,只是在访问时又去调用表面的定义的方法。
不能用基本类型实例化类型参数,可以用对应的包装类来实例化类型参数
// 编译错误ArrayList<int> list = new ArrayList<int>();// 正确写法ArrayList<Integer> list = new ArrayList<Integer>();
参数化类型的数组不合法
Demo<T >{ }public class Test { public static void main(String[] args) { // 编译错误 --> 类型擦除导致数组变成 Object [],因此没有意义 Demo<String>[ ] demo =new Demo[10]; } }
不能实例化类型变量
// 编译错误,需要类型参数需要确定类型Demo<T> demo = new Demo<T>
泛型类的静态上下文中不能使用类型变量
public class Demo<T> { public static T name; public static T getName() { ... } }
不能抛出也不能捕获泛型类的对象
//异常都是在运行时捕获和抛出的,而在编译的时候,泛型信息全都会被擦除掉。会导致这里捕获的类型一致try{ }catch(Problem<Integer> e1){ //do Something... }catch(Problem<Number> e2){ // do Something ...}
以上就是11.Java 基础 - 泛型的内容,更多相关内容请关注PHP中文网(www.php.cn)!