Java 일반 프로그래밍의 가장 완전한 요약

1 소개

JDK 1.5 버전 이후 Java 제네릭 프로그래밍이 도입되었습니다. 제네릭을 사용하면 프로그래머는 종종 컬렉션 내에서 유형 추상화를 사용할 수 있습니다. 다음은 제네릭을 사용하지 않는 예입니다.

List myIntList=new LinkedList(); //1  
myIntList.add(newInteger(0)); //2  
Integer x=(Integer)myIntList.iterator().next(); //3

코드의 세 번째 줄에 주의하세요. 하지만 이는 매우 불편한 점입니다. 프로그래머는 List에 저장된 객체의 유형을 알아야 하기 때문입니다. 정수이지만 목록의 요소를 반환할 때 유형은 여전히 ​​캐스트되어야 합니다. 이유는 무엇입니까? 그 이유는 컴파일러가 반복자의 next() 메소드가 Object 유형의 객체를 반환하도록 보장할 수 있기 때문입니다. Integer 변수의 유형 안전성을 보장하려면 강제로 변환해야 합니다.

이 변환은 혼란스러울 뿐만 아니라 유형 변환 예외가 발생할 수도 있습니다. 런타임 예외는 종종 감지하기 어렵습니다. 목록의 요소가 특정 데이터 유형인지 확인하여 유형 변환을 취소하여 오류 가능성을 줄이세요. 이는 일반 디자인의 원래 의도이기도 합니다. 다음은 제네릭 사용 예입니다.

Listc0f559cc8d56b43654fcbe4aa9df7b4a myIntList=newLinkedListc0f559cc8d56b43654fcbe4aa9df7b4a(); //1’  
myIntList.add(newInteger(0)); //2’  
Integerx=myIntList.iterator().next(); //3’

코드의 첫 번째 줄에서 List에 저장된 객체 유형이 Integer임을 지정합니다. 그러면 목록의 개체입니다.

2 간단한 제네릭 정의

다음은 제네릭 기술을 사용하는 java.util 패키지의 인터페이스 List와 Iterator에서 인용한 정의이다.

public interface List1a4db2c2c2313771e5742b6debf617a1 {  
5144dad4cd9c9023410d94caa0f34ebc    54bdf357c58b8a65c66d7c19c8e4d114void add(E x);  
5144dad4cd9c9023410d94caa0f34ebc    54bdf357c58b8a65c66d7c19c8e4d114Iterator1a4db2c2c2313771e5742b6debf617a1 iterator();  
}  
public interface Iterator1a4db2c2c2313771e5742b6debf617a1 {  
5144dad4cd9c9023410d94caa0f34ebc    54bdf357c58b8a65c66d7c19c8e4d114E next();  
5144dad4cd9c9023410d94caa0f34ebc    54bdf357c58b8a65c66d7c19c8e4d114boolean hasNext();  
}

인터페이스 뒤에 꺾쇠 괄호가 추가된다는 점을 제외하면 기본 유형과 다르지 않습니다. 꺾쇠 괄호 안에는 유형 매개변수가 있습니다(정의되면 형식화된 유형 매개변수입니다. 유형을 대체하기 위해 구체적인 유형을 호출할 때 사용됩니다.

이렇게 생각하시면 됩니다. Listc0f559cc8d56b43654fcbe4aa9df7b4a는 List의 유형 매개변수 E가 Integer로 대체된다는 의미입니다.

public interface IntegerList {  
<span style="white-space: pre;">    </span>void add(Integer x)  
<span style="white-space: pre;">    </span>Iterator<Integer> iterator();  
}

유형 삭제는 유형 매개변수 병합을 통해 일반 유형 인스턴스를 동일한 바이트코드에 연결하는 것을 의미합니다. 컴파일러는 일반 유형에 대해 하나의 바이트코드만 생성하고 해당 인스턴스를 이 바이트코드와 연결하므로 일반 유형의 정적 변수는 모든 인스턴스에서 공유됩니다. 또한 클래스가 인스턴스화되지 않았기 때문에 정적 메서드는 제네릭 클래스의 형식 매개 변수에 액세스할 수 없습니다. 따라서 정적 메서드가 제네릭 기능을 사용해야 하는 경우 제네릭 메서드로 만들어야 합니다. 유형 삭제의 핵심은 제네릭 유형에서 유형 매개변수에 대한 정보를 지우고 필요한 경우 유형 검사 및 유형 변환 방법을 추가하는 것입니다. 제네릭을 사용하면 구체적인 유형은 모두 지워지고 객체를 사용하고 있다는 사실만 알 수 있습니다. 예를 들어, List과 List는 실제로 동일한 유형입니다. 그것들은 모두 기본 유형인 목록으로 지워집니다. 컴파일 중에 유형 삭제가 발생하므로 동일한 일반 클래스의 인스턴스로 메소드를 구별할 수 없습니다. 예를 들어 다음 예제에서는 유형 삭제 후 두 메소드가 모두 List 유형의 매개변수이므로 컴파일 중에 오류가 발생합니다. 제네릭 클래스의 유형에 따라 메소드를 구별할 수 없습니다.

 public class Erasure{  
            public void test(List<String> ls){  
                System.out.println("Sting");  
            }  
            public void test(List<Integer> li){  
                System.out.println("Integer");  
            }  
  }

그러면 컴파일 과정에서 메소드와 클래스의 실제 타입 정보가 지워지는데, 객체를 반환할 때 구체적인 타입을 어떻게 알 수 있느냐는 문제가 있습니다. 예를 들어 List의 String 정보는 컴파일 후에 삭제됩니다. 그러면 List에 있는 개체가 런타임 시 반복자를 통해 반환될 때 List에 저장된 개체가 String 유형 개체인지 어떻게 알 수 있을까요?

삭제는 메소드 본문에서 유형 정보를 제거하므로 런타임 시 문제는 객체가 메소드에 들어오고 나가는 경계입니다. 이는 컴파일러가 유형 검사를 수행하고 컴파일 타임에 캐스트를 삽입하는 위치입니다. 코드의. 제네릭의 모든 작업은 경계에서 발생합니다. 전달된 값에 대해 추가 컴파일 타임 검사가 수행되고 전달된 값에 대한 캐스트가 삽입됩니다.

3. 제네릭 및 하위 유형

제네릭을 완전히 이해하기 위한 예는 다음과 같습니다. (Apple은 Fruit의 하위 클래스입니다

List<Apple> apples = new ArrayList<Apple>(); //1  
List<Fruit> fruits = apples; //2

第1行代码显然是对的，但是第2行是否对呢？我们知道Fruit fruit = new Apple()，这样肯定是对的，即苹果肯定是水果，但是第2行在编译的时候会出错。这会让人比较纳闷的是一个苹果是水果，为什么一箱苹果就不是一箱水果了呢？可以这样考虑，我们假定第2行代码没有问题，那么我们可以使用语句fruits.add(new Strawberry())（Strawberry为Fruit的子类）在fruits中加入草莓了，但是这样的话，一个List中装入了各种不同类型的子类水果，这显然是不可以的，因为我们在取出List中的水果对象时，就分不清楚到底该转型为苹果还是草莓了。

通常来说，如果Foo是Bar的子类型，G是一种带泛型的类型，则G4ee996100bf04ab273e687539c860625不是Gad40e550a33cb99ea30eede96e03e60e的子类型。这也许是泛型学习里面最让人容易混淆的一点。

 

4.通配符

4.1通配符？

先看一个打印集合中所有元素的代码。

void printCollection(Collection c) {                  
<span style="white-space: pre;">    </span>Iterator i=c.iterator();  
<span style="white-space: pre;">    </span>for (k=0;k < c.size();k++) {  
<span style="white-space: pre;">        </span>System.out.println(i.next());  
<span style="white-space: pre;">    </span>}  
}

void printCollection(Collection<Object> c) {  
for (Object e:c) {  
System.out.println(e);  
}  
}

   很容易发现，使用泛型的版本只能接受元素类型为Object类型的集合如ArrayLista87fdacec66f0909fc0757c19f2d2b1d();如果是ArrayListf7e83be87db5cd2d9a8a0b8117b38cd4，则会编译时出错。因为我们前面说过，Collectiona87fdacec66f0909fc0757c19f2d2b1d并不是所有集合的超类。而老版本可以打印任何类型的集合，那么如何改造新版本以便它能接受所有类型的集合呢？这个问题可以通过使用通配符来解决。修改后的代码如下所示：

//使用通配符？，表示可以接收任何元素类型的集合作为参数  
void printCollection(Collection<?> c) {  
<span style="white-space: pre;">    </span>for (Object e:c) {  
<span style="white-space: pre;">        </span>System.out.println(e);  
<span style="white-space: pre;">    </span>}  
}

这里使用了通配符？指定可以使用任何类型的集合作为参数。读取的元素使用了Object类型来表示，这是安全的，因为所有的类都是Object的子类。这里就又出现了另外一个问题，如下代码所示，如果试图往使用通配符？的集合中加入对象，就会在编译时出现错误。需要注意的是，这里不管加入什么类型的对象都会出错。这是因为通配符？表示该集合存储的元素类型未知，可以是任何类型。往集合中加入元素需要是一个未知元素类型的子类型，正因为该集合存储的元素类型未知，所以我们没法向该集合中添加任何元素。唯一的例外是null，因为null是所有类型的子类型，所以尽管元素类型不知道，但是null一定是它的子类型。

Collection<?> c=new ArrayList<String>();  
c.add(newObject()); //compile time error，不管加入什么对象都出错，除了null外。  
c.add(null); //OK

另一方面，我们可以从List6b3d0130bba23ae47fe2b8e8cddf0195 lists中获取对象，虽然不知道List中存储的是什么类型，但是可以肯定的是存储的类型一定是Object的子类型，所以可以用Object类型来获取值。如for(Object obj: lists)，这是合法的。

4.2边界通配符

   1）？extends通配符

假定有一个画图的应用，可以画各种形状的图形，如矩形和圆形等。为了在程序里面表示，定义如下的类层次：

public abstract class Shape {  
<span style="white-space: pre;">    </span>public abstract void draw(Canvas c);  
}  
  
public class Circle extends Shape {  
<span style="white-space: pre;">    </span>private int x,y,radius;  
<span style="white-space: pre;">    </span>public void draw(Canvas c) { ... }  
}  
  
public class Rectangle extends Shape  
<span style="white-space: pre;">    </span>private int x,y,width,height;  
<span style="white-space: pre;">    </span>public void draw(Canvasc) { ... }  
}

为了画出集合中所有的形状，我们可以定义一个函数，该函数接受带有泛型的集合类对象作为参数。但是不幸的是，我们只能接收元素类型为Shape的List对象，而不能接收类型为Listbd5f0b6be71dcbe6e9e8a42cca8c5100的对象，这在前面已经说过。为了解决这个问题，所以有了边界通配符的概念。这里可以采用public void drawAll(Listd77674685afc6c34e7798aac36bbe2b7shapes)来满足条件，这样就可以接收元素类型为Shape子类型的列表作为参数了。

//原始版本  
public void drawAll(List<Shape> shapes) {  
<span style="white-space: pre;">    </span>for (Shapes:shapes) {  
<span style="white-space: pre;">        </span>s.draw(this);  
<span style="white-space: pre;">    </span>}  
}

//使用边界通配符的版本  
public void drawAll(List<？exends Shape> shapes) {  
<span style="white-space: pre;">    </span>for (Shapes:shapes) {  
<span style="white-space: pre;">        </span>s.draw(this);  
<span style="white-space: pre;">    </span>}  
}

这里就又有个问题要注意了，如果我们希望在List3713e1cf25733a9d265f2d98a96f6589 shapes中加入一个矩形对象，如下所示：

shapes.add(0, new Rectangle()); //compile-time error

那么这时会出现一个编译时错误，原因在于：我们只知道shapes中的元素时Shape类型的子类型，具体是什么子类型我们并不清楚，所以我们不能往shapes中加入任何类型的对象。不过我们在取出其中对象时，可以使用Shape类型来取值，因为虽然我们不知道列表中的元素类型具体是什么类型，但是我们肯定的是它一定是Shape类的子类型。

 

2）？super通配符

       这里还有一种边界通配符为？super。比如下面的代码：

List<Shape> shapes = new ArrayList<Shape>();  
List<? super Cicle> cicleSupers = shapes;  
cicleSupers.add(new Cicle()); //OK, subclass of Cicle also OK  
cicleSupers.add(new Shape()); //ERROR

       这表示cicleSupers列表存储的元素为Cicle的超类，因此我们可以往其中加入Cicle对象或者Cicle的子类对象，但是不能加入Shape对象。这里的原因在于列表cicleSupers存储的元素类型为Cicle的超类，但是具体是Cicle的什么超类并不清楚。但是我们可以确定的是只要是Cicle或者Circle的子类，则一定是与该元素类别兼容。

 

3)边界通配符总结

437fcc348f7b1c54dc1b8f8cb5743cbcl         04c6c2c265887a55041405a81efec09a如果你想从一个数据类型里获取数据，使用 ? extends 通配符

437fcc348f7b1c54dc1b8f8cb5743cbcl         04c6c2c265887a55041405a81efec09a如果你想把对象写入一个数据结构里，使用 ? super 通配符

437fcc348f7b1c54dc1b8f8cb5743cbcl         04c6c2c265887a55041405a81efec09a如果你既想存，又想取，那就别用通配符。

 

5.泛型方法

考虑实现一个方法，该方法拷贝一个数组中的所有对象到集合中。下面是初始的版本：

static void fromArrayToCollection(Object[]a, Collection<?> c) {  
<span style="white-space: pre;">    </span>for (Object o:a) {  
<span style="white-space: pre;">        </span>c.add(o); //compile time error  
<span style="white-space: pre;">    </span>}  
}

可以看到显然会出现编译错误，原因在之前有讲过，因为集合c中的类型未知，所以不能往其中加入任何的对象（当然，null除外）。解决该问题的一种比较好的办法是使用泛型方法，如下所示：

static <T> void fromArrayToCollection(T[] a, Collection<T>c){  
<span style="white-space: pre;">    </span>for(T o : a) {  
<span style="white-space: pre;">        </span>c.add(o);// correct  
<span style="white-space: pre;">    </span>}  
}

注意泛型方法的格式，类型参数8742468051c85b06f0a0af9e3e506b5c需要放在函数返回值之前。然后在参数和返回值中就可以使用泛型参数了。具体一些调用方法的实例如下：

Object[] oa = new Object[100];  
Collection<Object>co = new ArrayList<Object>();  
fromArrayToCollection(oa, co);// T inferred to be Object  
String[] sa = new String[100];  
Collection<String>cs = new ArrayList<String>();  
fromArrayToCollection(sa, cs);// T inferred to be String  
fromArrayToCollection(sa, co);// T inferred to be Object  
Integer[] ia = new Integer[100];  
Float[] fa = new Float[100];  
Number[] na = new Number[100];  
Collection<Number>cn = new ArrayList<Number>();  
fromArrayToCollection(ia, cn);// T inferred to be Number  
fromArrayToCollection(fa, cn);// T inferred to be Number  
fromArrayToCollection(na, cn);// T inferred to be Number  
fromArrayToCollection(na, co);// T inferred to be Object  
fromArrayToCollection(na, cs);// compile-time error

注意到我们调用方法时并不需要传递类型参数,系统会自动判断类型参数并调用合适的方法。当然在某些情况下需要指定传递类型参数，比如当存在与泛型方法相同的方法的时候（方法参数类型不一致），如下面的一个例子：

public  <T> void go(T t) {  
    System.out.println("generic function");  
}  
public void go(String str) {  
    System.out.println("normal function");  
}  
public static void main(String[] args) {  
        FuncGenric fg = new FuncGenric();  
        fg.go("haha");//打印normal function  
        fg.<String>go("haha");//打印generic function  
        fg.go(new Object());//打印generic function  
        fg.<Object>go(new Object());//打印generic function  
}

如例子中所示，当不指定类型参数时，调用的是普通的方法，如果指定了类型参数，则调用泛型方法。可以这样理解，因为泛型方法编译后类型擦除，如果不指定类型参数，则泛型方法此时相当于是public void go(Object t)。而普通的方法接收参数为String类型，因此以String类型的实参调用函数，肯定会调用形参为String的普通方法了。如果是以Object类型的实参调用函数，则会调用泛型方法。

6.其他需要注意的小点

1）方法重载

在JAVA里面方法重载是不能通过返回值类型来区分的，比如代码一中一个类中定义两个如下的方法是不容许的。但是当参数为泛型类型时，却是可以的。如下面代码二中所示，虽然形参经过类型擦除后都为List类型，但是返回类型不同，这是可以的。

/*代码一：编译时错误*/   
public class Erasure{  
            public void test(int i){  
                System.out.println("Sting");  
            }  
            public int test(int i){  
                System.out.println("Integer");  
            }  
  }

/*代码二：正确 */  
 public class Erasure{  
            public void test(List<String> ls){  
                System.out.println("Sting");  
            }  
            public int test(List<Integer> li){  
                System.out.println("Integer");  
            }  
  }

2）泛型类型是被所有调用共享的

       所有泛型类的实例都共享同一个运行时类，类型参数信息会在编译时被擦除。因此考虑如下代码，虽然ArrayListf7e83be87db5cd2d9a8a0b8117b38cd4和ArrayListc0f559cc8d56b43654fcbe4aa9df7b4a类型参数不同，但是他们都共享ArrayList类，所以结果会是true。

List<String>l1 = new ArrayList<String>();  
List<Integer>l2 = new ArrayList<Integer>();  
System.out.println(l1.getClass() == l2.getClass()); //True

3）instanceof

不能对确切的泛型类型使用instanceOf操作。如下面的操作是非法的，编译时会出错。

Collection cs = new ArrayList<String>();  
if (cs instanceof Collection<String>){…}// compile error.如果改成instanceof Collection<?>则不会出错。

4)泛型数组问题

不能创建一个确切泛型类型的数组。如下面代码会出错。

Listf7e83be87db5cd2d9a8a0b8117b38cd4[] lsa = new ArrayListf7e83be87db5cd2d9a8a0b8117b38cd4[10]; //compile error.

       因为如果可以这样，那么考虑如下代码，会导致运行时错误。

List<String>[] lsa = new ArrayList<String>[10]; // 实际上并不允许这样创建数组  
Object o = lsa;  
Object[] oa = (Object[]) o;  
List<Integer>li = new ArrayList<Integer>();  
li.add(new Integer(3));  
oa[1] = li;// unsound, but passes run time store check  
String s = lsa[1].get(0); //run-time error - ClassCastException

       因此只能创建带通配符的泛型数组，如下面例子所示，这回可以通过编译，但是在倒数第二行代码中必须显式的转型才行，即便如此，最后还是会抛出类型转换异常，因为存储在lsa中的是Listc0f559cc8d56b43654fcbe4aa9df7b4a类型的对象，而不是Listf7e83be87db5cd2d9a8a0b8117b38cd4类型。最后一行代码是正确的，类型匹配，不会抛出异常。

ist<?>[] lsa = new List<?>[10]; // ok, array of unbounded wildcard type  
Object o = lsa;  
Object[] oa = (Object[]) o;  
List<Integer>li = new ArrayList<Integer>();  
li.add(new Integer(3));  
oa[1] = li; //correct  
String s = (String) lsa[1].get(0);// run time error, but cast is explicit  
Integer it = (Integer)lsa[1].get(0); // OK

更多Java泛型编程最全总结相关文章请关注PHP中文网！