1. import java.util.ArrayList;
   
2. import java.util.Collections;
   
3. import java.util.Comparator;
   
4. import java.util.LinkedHashMap;
   
5. import java.util.Map;
   
6. import java.util.Set;
   
7. import java.util.TreeMap;
   
8. 
   
9. 
   
10. 
    
11. public class TreeMapSort {
    
12. 
    
13.         /**
    
14.          * 对TreeMap集合进行值排序，为什么new一个成员方法上的内部类会出错 而new一个匿名内部类和单独外部类而不出错
    
15.          */
    
16.         public static void main(String[] args) {
    
17.                 // TODO Auto-generated method stub
    
18.                 TreeMap<String, Integer> treeMap = new TreeMap<String, Integer>();
    
19.                 treeMap.put("zhangsan", 28);
    
20.                 treeMap.put("lisi", 18);
    
21.                 treeMap.put("wangwu", 18);
    
22.                 treeMap.put("wuxiao",9);
    
23. 
    
24.                 Set<Map.Entry<String, Integer>> entrySet = treeMap.entrySet();
    
25.                 ArrayList<Map.Entry<String, Integer>> list = new ArrayList<Map.Entry<String,Integer>>(treeMap.size());
    
26.                 list.addAll(entrySet);
    
27.                 Collections.sort(list,new myCompartor());//就这就编译报错，只不过new了一个成语方法上的内部类 ，new匿名内部类它就不报错，凭什么？
    
28.                
    
29.                 //匿名内部类
    
30.                 /*Collections.sort(list,new Comparator<Map.Entry<String, Integer>>(){
    
31. 
    
32.                         @Override
    
33.                         public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
    
34.                                 // TODO Auto-generated method stub
    
35.                                 return o1.getValue().compareTo(o2.getValue());
    
36.                         }               
    
37.                 });*/
    
38.                 Map<String, Integer> sortMap = new LinkedHashMap<String, Integer>();
    
39.                 for(Map.Entry<String, Integer> entry:list){
    
40.                         sortMap.put(entry.getKey(),entry.getValue());
    
41.                 }
    
42.                 Set<String> nameSet = sortMap.keySet();
    
43.                 for(String name:nameSet){
    
44.                         System.out.println(name+":"+sortMap.get(name));
    
45.                 }
    
46.         }
    
47.         //成员上的内部类
    
48.         private final class myCompartor implements Comparator<Map.Entry<String, Integer>>{
    
49. 
    
50.                 @Override
    
51.                 public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
    
52.                         // TODO Auto-generated method stub
    
53.                         return o1.getValue().compareTo(o2.getValue());
    
54.                 }               
    
55.         }
    
56. }
    
57. 
    
58. //外部类
    
59. /*class myCompartor implements Comparator<Map.Entry<String, Integer>>{
    
60. 
    
61.         @Override
    
62.         public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
    
63.                 // TODO Auto-generated method stub
    
64.                 return o1.getValue().compareTo(o2.getValue());
    
65.         }               
    
66. }*/

复制代码

找到原因了 在48行private上加 static 因为main方法是static的，访问的成员上的内部类，成员上的内部类也必须用static修饰
一句话就是 类中的静态方法不能访问非静态的成员

楼上的回答不是我所需要的答案 请仔细看我的问题并拿到myEclips上测试  随便回答也给分 我真服了

内部类的好处是有的 但是当程序代码很多的时候 用太多的内部类会使代码的阅读性大大降低，黎活明老师在将android中就提到过

我的问题是 27行编译器为什么报错，27行调用了成员方法上的内部类（48~55行），我不知道错在哪里。而当有用匿名内部类的时候（30~45）而不会提示
错误，功能都是一样的。还有用外部类new对象也不会报错。我的意思是匿名内部类和调用成员方法上的内部功能上是一样的，几乎没什么区别，错再哪里?希望高人给个正确的回答。别为了赚分乱回答

匿名内部类可以减少你命名一个类的烦脑(^^)

其有很多优点
比如可以访问外部类的私有方法

new   YourClass{
...
}

这个例子是一个多线程的小程序，这里面就应用到了匿名内部类，实现了Runnable接口。
匿名内部类的一般好处是：是代码更加简洁，紧凑，但带来的是易读性下降。他一般用在GUI编程中
实现事件处理等等。希望大家一起讨论

public   class   RunnableTest{
public   static   void   main(String[]   args){
MyThread1   mt1   =   new   MyThread1();
MyThread2   mt2   =   new   MyThread2();
MyThread3   mt3   =   new   MyThread3();
mt2.th.start();
mt1.th.start();
mt3.th.start();
}
}

class   MyThread1   implements   Runnable{
Thread   th   =   new   Thread(this);
public   void   run(){
for   (int   i   =   0;   i   <   10;   i++){
System.out.println("BMW"   +   i);
}
}
}

class   MyThread2{
Thread   th   =   new   Thread(){
public   void   run(){
for   (int   i   =   0;   i   <   10;   i++){
System.out.println(i);
}
}
};
}
class   MyThread3{
Runnable   ra   =   new   Runnable(){
public   void   run(){
for   (char   ch   =   65;   ch   <   70;   ch++){
System.out.println(ch);
}
}
};
Thread   th   =   new   Thread(ra);
}

匿名内部类可以访问外部类的私有成员，其他的方式实现接口和继承类做不到
实现方式：
SuperType   aa   =   new   SuperType(construction   parameters){methods   and   data}
或
InterfaceType   aa   =   new   InterfaceType(){methods   and   data}
具体实现时需要把SuperType   和InterfaceType   换成具体的超类和接口。
匿名内部类可以访问外部类的私有成员，其他的方式实现接口和继承类做不到

内部类应该都可以的。
我觉得匿名的应该是隐藏实现，而且用完就out的那种。
这个是关闭内部类的代码：
Button close=new Button("close");
close.addActionListener(this);
close.setActionCommand("close");

外部类要访问内部类的成员必须要建立内部类对象，创建格式：外部类对象.内部对象
可以这样：
Collections.sort(list, new TreeMapSort().new myCompartor());