Java語言的局部類

假如你有一個 Integer 對象的列表，並且你想使用 Coolections.sort 來對它們進行排序。另外，你還要自己指定一個比較器，因為你想按降序而不是升序排列它們。這裡有一些代碼示例說明了該怎麼做：

import java.util.*;
public class LocalDemo1 {
// 使用實現了 Comparator 的匿名類排序。
static void sortanon(List list) {
Collections.sort(list, new Comparator() {
public int compare(
Object o1, Object o2) {int cc = ((Integer)o1).compareTo(o2);return (cc < 0 ? 1 : cc > 0 ? -1 : 0);
}
});
}
// 使用實現了 Comparator 的局部類排序
static void sortlocal(List list) {class MyComparator implements Comparator {
public int compare(Object o1, Object o2) {int cc = ((Integer)o1).compareTo(o2);return (cc < 0 ? 1 : cc > 0 ? -1 : 0);
}};
Collections.sort(list, new MyComparator());
}
public static void main(String[] args) {
List list1 = new ArrayList();
list1.add(new Integer(1));
list1.add(new Integer(2));
list1.add(new Integer(3));
sortanon(list1);
System.out.println(list1);
List list2 = new ArrayList();
list2.add(new Integer(1));
list2.add(new Integer(2));
list2.add(new Integer(3));
sortlocal(list2);
System.out.println(list2);
}}

這段程序的輸出如下：

[3, 2, 1]

[3, 2, 1]

上列中使用兩種不同的方法實現了 Comparator 接口。第一種方法使用匿名類，第二種方法使用局部類，二者有何區別：一點區別是格式上的??匿名類的定義比較簡捷，它實際上是下面這個表達式的一部分：

Comparator c = new Comparator() {...};

與之相反，局部類的定義看起來非常類似於常規的類定義，略為煩瑣。例如，定義局部類內時可能用到 “implements”語句，而在匿名類中不需要顯示的使用這條語句。

哪一種格式“更好”取決於你自己的觀點。匿名類的定義會比較難讀，但在不需要使用局部類的地方使用局部類會造成一些錯覺，讓人覺得需要做的事比實際要做的事更多。

讓我們來看看另一個例子，更深層的比較匿名類和局部類：

import java.util.*;
public class LocalDemo2 {
// 使用兩個單獨的匿名類實例對兩個列表進行排序
static void sort1(List list1, List list2) {
Collections.sort(list1, new Comparator() {
public int compare(Object o1, Object o2) {int cc = ((Integer)o1).compareTo(o2);
return (cc < 0 ? 1 : cc > 0 ? -1 : 0);
}
});
Collections.sort(list2, new Comparator() {public int compare(
Object o1, Object o2) {int cc = ((Integer)o1).compareTo(o2);return (cc < 0 ? 1 : cc > 0 ? -1 : 0);
}});
}
// 使用一個局部類的兩個實例來對兩個列表進行排序
static void sort2(List list1, List list2) {
class MyComparator implements Comparator {
public int compare(Object o1, Object o2) {int cc = ((Integer)o1).compareTo(o2);return (cc < 0 ? 1 : cc > 0 ? -1 : 0);
}}
Collections.sort(list1, new MyComparator());
Collections.sort(list2, new MyComparator());
}
// 使用一個匿名類的一個實例來對兩個列表進行排序
static void sort3(List list1, List list2) {Comparator cmp = new Comparator() {
public int compare(Object o1, Object o2) {int cc = ((Integer)o1).compareTo(o2);return (cc < 0 ? 1 : cc > 0 ? -1 : 0);
}};
Collections.sort(list1, cmp);
Collections.sort(list2, cmp);
}
// 使用一個局部類的一個實例來對兩個列表進行排序
static void sort4(List list1, List list2) {class MyComparator implements Comparator {
public int compare(Object o1, Object o2) {int cc = ((Integer)o1).compareTo(o2);return (cc < 0 ? 1 : cc > 0 ? -1 : 0);
}}
Comparator cmp = new MyComparator();
Collections.sort(list1, cmp);Collections.sort(list2, cmp);
}
static class AppComparator implements
Comparator {public int compare(Object o1, Object o2) {int cc = ((Integer)o1).compareTo(o2);return (cc < 0 ? 1 : cc > 0 ? -1 : 0);
}}
static Comparator appcomparator = new AppComparator();
// 使用應用程序中定義的比較器來對兩個列表進行排序
static void sort5(List list1, List list2) {Collections.sort(list1, appcomparator);
Collections.sort(list2, appcomparator);
}
public static void main(String[] args) {
List list1 = new ArrayList();
list1.add(new Integer(1));
list1.add(new Integer(2));
list1.add(new Integer(3));
List list2 = new ArrayList();
list2.add(new Integer(4));
list2.add(new Integer(5));
list2.add(new Integer(6));
//sort1(list1, list2);
//sort2(list1, list2);
//sort3(list1, list2);
//sort4(list1, list2);
sort5(list1, list2);
System.out.println(list1);
System.out.println(list2);
}}

輸出結果是：

[3, 2, 1]

[6, 5, 4]

程序中所有這些排序的方法都做同樣的事情??降序排序兩個列表中的 Integer 對象。

sort1 使用兩個匿名類，每個都實現了 Comparator 接口。這兩個類是相對獨立的，但在邏輯上是重復的 (這樣的代碼非常糟糕)。

sort2 方法使用了一個局部類的兩個實例。這是比 sort1 更好的方法，但這並不是最有效率的。

sort3 和 sort4 方法分均是使用的一個類的一個實例，它們在邏輯上也沒有重復，所以是比較有效率的代碼。這兩段代碼也有不同之處：sort3 比 sort4 更簡捷，但 sort4 更具可讀性。除了可讀性，在這種情況下使用局部類沒有更多的意義。

如果你需要在一個應用程序中使用同一種排序的策略，那麼上述的四種方法都不是完全正確的。這種情況下，最好使用一個全局類或者內部類 (MyComparator)，或者創建一個單獨的可用於應用程序中任何地方的比較器實例。sort5 就是這種情況下的例子。

關於匿名類的另一個問題是它們必須基於一個已經存在的類或者接口創建，例如，你使用下面這句代碼的時候：

Comparator c = new Comparator() {...};

實際上發生的事情是：從一個沒有名字的類創建了實例，而這個類實現了 Comparator 接口。而對於局部類則沒有這種限制。

匿名類和局部類更深層次的區別在於：匿名類不能定義構造器，因為它是沒有名字的。不過它還是可以通過 {...} 格式的初始化代碼塊做一些簡單的初始化，例如：

import java.util.*;
public class LocalDemo3 {public static void main(String[] args) {
Comparator cmp1 = new Comparator() {
{
System.out.println(
);}
public int compare(Object o1, Object o2) {int cc = ((Integer)o1).compareTo(o2);
return (cc < 0 ? 1 : cc > 0 ? -1 : 0);
};};
class MyComparator implements Comparator {public MyComparator(int x) {
System.out.println(+< with value > + x);
}
public int compare(Object o1, Object o2) {int cc = ((Integer)o1).compareTo(o2);
return (cc < 0 ? 1 : cc > 0 ? -1 : 0);
};
};
Comparator cmp2 = new MyComparator(100);
}}

這段程序將輸出：

object initialization

constructor called with value 100

局部類可以擁有通過常規方法使用的構造器，而匿名類地必須通過 {...} 來實現初始化。

再次考慮關於對例表進行排序的例子。為局部類或內部類定義一個構造器，並通過傳遞參數的辦法可以指定這個類的實例在操作過程中是按升序還是降序。在匿名類中要做到這一點則需要定義一個類成員級別的 final 變量。

在對類的主流應用中更適合使用局部類，因為你更熟悉。局部類也比匿名類更具可讀性。同時，局部類的功能往往會超出你所需要的，那麼這個時候，就更適合使用匿名類了。