Java Generics 요약(1) - 기본 사용법 및 유형 삭제에 대한 자세한 설명

이 글에서는 주로 Java 제네릭의 사용과 유형 삭제와 관련된 문제를 소개합니다. 매우 좋은 참조 값을 가지고 있습니다. 아래 에디터를 살펴보겠습니다

소개

Java는 1.5에서 제네릭 메커니즘을 도입했습니다. 제네릭의 핵심은 매개변수화된 유형입니다. 변수 의 타입은 매개변수로서 사용시 특정 타입으로 지정된다. 제네릭을 클래스, 인터페이스 및 메서드에 사용할 수 있습니다. 제네릭을 사용하면 코드가 더 간단하고 안전해집니다. 그러나 Java의 제네릭은 유형 삭제를 사용하므로 의사 제네릭일 뿐입니다. 이 글은 "Java 프로그래밍 사고"를 중심으로 제네릭의 사용과 기존의 문제점을 요약한 것입니다.

이 시리즈의 다른 두 기사:

• Java Generics 요약(2): Generics and Arrays

• 요약 Java Generics(3): 와일드카드 사용

기본 사용법

일반 클래스

변수를 래핑하는 데 사용되는 홀더 클래스가 있는 경우 이 변수의 유형은 임의적일 수 있습니다. 홀더를 작성하는 방법은 무엇입니까? 제네릭 이전에는 다음과 같이 할 수 있었습니다:

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가 참조하는 변수가 있습니다. 모든 유형을 객체로 업캐스트할 수 있으므로 이 홀더는 모든 유형을 허용할 수 있습니다. 꺼낼 때 홀더는 ObjectObject를 저장한다는 것만 알기 때문에 해당 타입을 강제로 적용해야 합니다. 기본 메소드에서 홀더1은 먼저 String 객체인 string을 저장한 다음 Integer 객체를 저장합니다(매개변수 1은 자동으로 boxing됩니다). 홀더에서 변수를 꺼낼 때 캐스팅하는 것은 이미 번거로운 일입니다. 여기서도 다른 유형을 기억해야 합니다. 잘못된 변환을 수행하면 런타임 예외가 발생합니다.

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는 단지 식별자일 뿐이며 다른 문자도 사용할 수 있습니다. 홀더2 객체를 생성할 때 매개변수 T의 유형이 꺾쇠 괄호 안에 전달되고, 이 객체에서 T의 모든 발생은 문자열로 대체되는 것과 동일합니다. get이 지금 꺼내는 것은 Object가 아닌 String 객체이므로 타입 변환이 ​​필요하지 않습니다. 또한 set을 호출할 때 String 유형만 전달할 수 있으며, 그렇지 않으면 컴파일이 통과되지 않습니다. 이는 홀더2의 유형 안전성을 보장하고 실수로 잘못된 유형을 전달하는 것을 방지합니다.

위의 예를 통해 pan이 코드를 더 간단하고 안전하게 만든다는 것을 알 수 있습니다. 제네릭이 도입된 후 일반적으로 사용되는 컨테이너 클래스와 같은 일부 클래스도 제네릭을 지원하도록 다시 작성되었습니다. 이를 사용하면 다음과 같은 매개변수 유형을 전달하게 됩니다. ArrayList ;>();.

제네릭 메서드

제네릭은 클래스를 대상으로 할 수 있을 뿐만 아니라 개별적으로 메서드를 제네릭으로 만들 수도 있습니다. 객체를 생성할 때 일반 매개변수를 전달할 필요가 없지만 해당 메서드 f는 일반 메서드입니다. 반환 유형 앞에는 매개변수 식별자 가 있습니다. 여기에는 두 개의 일반 매개변수가 있으므로 여러 개의 일반 매개변수가 있을 수 있습니다.

일반 메서드를 호출할 때는 위 호출의 경우와 달리 일반 매개변수를 명시적으로 전달할 필요가 없습니다. 이는 컴파일러가 매개변수 유형 추론을 사용하여 전달된 인수 유형(여기서는 정수 및 문자열)을 기반으로 K 및 V 유형을 추론하기 때문입니다.

유형 삭제

유형 삭제란 무엇입니까Java 제네릭 사용 유형 삭제 메커니즘에는 많은 논란을 불러일으켰기 때문에 Java의 일반 기능은 제한되어 있으며 "유사 일반"이라고만 말할 수 있습니다. 유형 삭제란 무엇입니까? 간단히 말해서, 유형 매개변수는 런타임 시에만 존재하며 JVM(Java Virtual Machine)은 제네릭의 존재를 인식하지 못합니다. 먼저 예를 살펴보겠습니다.

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

위 코드에는 ArrayList와 ArrayList라는 두 가지 ArrayList가 있습니다. 우리 의견으로는 매개변수화된 유형이 다릅니다. 하나는 정수를 저장하고 다른 하나는 문자열을 저장합니다. 그러나 Class 객체를 비교하면 위의 코드 출력이 사실입니다. 이는 JVM의 관점에서 동일한 클래스임을 의미합니다. C++,

C#

및 진정한 제네릭을 지원하는 기타 언어에서는 서로 다른 클래스입니다. 일반 매개변수는 첫 번째 경계까지 지워집니다. 예를 들어 위의 Holder2 클래스에서 매개변수 유형이 단일 T인 경우 Object로 지워집니다. T가 나타납니다. 객체로 대체합니다. 따라서 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 必须是 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 类型的方法，泛型就有用了，因为这样会返回准确类型。比如下面的例子：

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 Generics 요약(1) - 기본 사용법 및 유형 삭제에 대한 자세한 설명의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!