讨论一下，java内部类的区别：静态成员类，成员类，局部类，和匿名类，他们分别最适合在是什么场合使用

Question

静态成员类：Helper，Util类
成员类指得是啥？一般的类吗？
局部类：控制名字空间和可见性的一种手段
匿名类：Event处理等抽象类：Template Mehtod Pattern；
接口：进行关注点分离

Answer 1

静态成员类//把堆栈用链表实现的类
public class LinkedStack{
   //静态成员接口定义了对象是如何链接的  
   public static interface Linkable{
        public Linkable getNext();
        public void setNext(Linkable node);
     }
//链表的头节点是Linkbable类型的对象
     Linkbable head;//省略了方法的主体部分
public void push(Linkable node){...}
public Object pop(){...}//这个类是实现的是静态成员接口
class LinkableInteger implements LinkedStatck.linkable{
    //这里定义了节点的数据和构造函数
    int i;
    
    public LinkableInteger(int i){this.i = i;}
//这里是实现接口的所必须数据和方法 
public LinkedStack.Linkable getNext(){return next;}
public void setNext(LinkedStack.Linkable node){next = node}
}//成员类public class LinkedStack {
    //我们的静态成员接口，这里省略了它 的主题部分
    public static interface Linkable{...}
    //链表的头节点
    private Linkable head;
    //这里省略了方法的主体
    public void push(Linkbable node){...}
    public Linkbable pop(){...}
    
    //这里方法为Linkbable，返回一个Enumeberation 对象
    public java.util.Enumeration enumerate<--估计这里是不是Linkbable-->()
    {return new Enumberator();}
    //这里是对定义为成员类的Enumerator接口的实现
    protected class Enumberator implements java.util.Enumberation{
    Linkbable current;
    //构造函数使用了包含类中类型为private 的头接点的字段
    public Enumberator (){ current = head;}
    public boolean hasMoreElements(){return (current != null);}
    public Object nextElement(){
    if (current == null) throw new java.util.NoSuchElementException ();
    Object value = current;
    current = current.getNext();
    return value;
    }
  }
}我自己看了半天也没看出静态成员类和成员类的区别，请大家讨论一下

Answer 2

出自于java 技术手册，坚果系列，

Answer 3

<<think in java>>中说的很详细

Answer 4

在所有类的实例中共享    可以被标记为public或private    如果被标记为public而没有该类的实例，可以从该类的外部访问          
public class Count {  
private int serialNumber;       
private static int counter = 0;   
public Count() { 
counter++; 
serialNumber = counter;
 }
 }有时想有一个可以在类的所有实例中共享的变量。比如，这可以用作实例之间交流的基础或追踪已经创建的实例的数量。
    可以用关键字static来标记变量的办法获得这个效果。这样的变量有时被叫做class variable，以便与不共享的成员或实例变量区分开来。
   public class Count {
             private int serialNumber;
             private static int counter = 0;
             public Count() {
               counter++;
               serialNumber = counter;
             }
           }
    在这个例子中，被创建的每个对象被赋于一个独特的序号，从1开始并继续往上。变量counter在所有实例中共享，所以，当一个对象的构造函数增加counter时，被创建的下一个对象接受增加过的值。  
    Static变量在某种程度上与其它语言中的全局变量相似。Java编程语言没有这样的全局语言，但static变量是可以从类的任何实例访问的单个变量。
    如果static变量没有被标记成private，它可能会被从该类的外部进行访问。要这样做，不需要类的实例，可以通过类名指向它。
public class StaticVar {
  public static int number;
}
public class OtherClass [
  public void method() {
    int x = StaticVar.number;
  }
} 当没有一个特殊对象变量的实例的时候，有时需要访问程序代码。用关键字static标记的方法可以这样使用，有时被称做class method。static方法可以用类名而不是引用来访问，如：
public class GeneralFunction {
             public static int addUp(int x, int y) {
               return x + y;
             }
           }
           public class UseGeneral {
             public void method() {
               int a = 9;
               int b = 10;
               int c = GeneralFunction.addUp(a, b);
               System.out.println("addUp() gives " + c);
             }
           }    因为static方法不需它所属的类的任何实例就会被调用，因此没有this值。结果是，static方法不能访问与它本身的参数以及static变量分离的任何变量。访问非静态变量的尝试会引起编译错误。/////////////////////////////抽象类 有时在库开发中，要创建一个体现某些基本行为的类，并为该类声明方法，但不能在该类中实现该行为。取而代之，在子类中实现该方法。知道其行为的其它类可以在类中实现这些方法。
    例如，考虑一个Drawing类。该类包含用于各种绘图设备的方法，但这些必须以独立平台的方法实现。它不可能去访问机器的录像硬件而且还必须是独立于平台的。其意图是绘图类定义哪种方法应该存在，但实际上，由特殊的从属于平台子类去实现这个行为。
    正如Drawing类这样的类，它声明方法的存在而不是实现，以及带有对已知行为的方法的实现，这样的类通常被称做抽象类。通过用关键字abstract进行标记声明一个抽象类。被声明但没有实现的方法（即，这些没有程序体或{}），也必须标记为抽象。
           public abstract class Drawing {
           public abstract void drawDot(int x, int y);
           public void drawLine(int x1, int y1,
                               int x2, int y2) {
             // draw using the drawDot() method repeatedly.
           }
         }    不能创建abstract类的实例。然而可以创建一个变量，其类型是一个抽象类，并让它指向具体子类的一个实例。不能有抽象构造函数或抽象静态方法。
    Abstract类的子类为它们父类中的所有抽象方法提供实现，否则它们也是抽象类。public class MachineDrawing extends Drawing {
  public void drawDot (int mach x, intmach y) {
           // Draw the dot
  }
}Drawing d = new MachineDrawing();///////////////////////////////////////接口
接口是抽象类的变体。接口中的所有方法都是抽象的，没有一个有程序体。接口只可以定义static final成员变量。
    接口的好处是，它给出了屈从于Java技术单继承规则的假象。当类定义只能扩展出单个类时，它能实现所需的多个接口。
    接口的实现与子类相似，除了该实现类不能从接口定义中继承行为。当类实现特殊接口时，它定义（即，将程序体给予）所有这种接口的方法。然后，它可以在实现了该接口的类的任何对象上调用接口的方法。由于有抽象类，它允许使用接口名作为引用变量的类型。通常的动态联编将生效。引用可以转换到接口类型或从接口类型转换，instanceof运算符可以用来决定某对象的类是否实现了接口。
    接口是用关键字interface来定义的，如下所述：
           public interface Transparency {
             public static final int OPAQUE=1;
             public static final int BITMASK=2;
             public static final int TRANSLUCENT=3;
             public int getTransparency();
           }    类能实现许多接口。由类实现的接口出现在类声明的末尾以逗号分隔的列表中，如下所示：     public class MyApplet extends Applet implements 
       Runnable, MouseListener{
         "..."
       }   下例表示一个简单的接口和实现它的一个类：
    interface SayHello {
        void printMessage();
    }    class SayHelloImpl implements SayHello {
        void printMessage() {
            System.out.println("Hello");
        }
    }    interface SayHello强制规定，实现它的所有的类必须有一个称做printMessage的方法，该方法带有一个void返回类型且没有输入参数。

Answer 5

/////////////////////////////////内部类内部类，有时叫做嵌套类，被附加到JDK1.1及更高版本中。内部类允许一个类定义被放到另一个类定义里。内部类是一个有用的特征，因为它们允许将逻辑上同属性的类组合到一起，并在另一个类中控制一个类的可视性。6.14.1  内部类基础
    下述例子表示使用内部类的共同方法：
1． import java.awt.*;
2． import java.awt.event.*; 
3． public class MyFrame extends Frame{ 
4．     Button myButton;
5．     TextArea myTextArea;
6．     int count;; 
7．
8．     public MyFrame(){
9．         super("Inner Class Frame");
10．      myButton = new Button("click me");
11．      myTextArea = new TextArea(); 
12．      add(myButton,BorderLayout,CENTER); 
13．      add(myTextArea,BorderLayout,NORTH);
14．      ButtonListener bList = new ButtonListener(); 
15．      myButton.addActionListener(bList); 
16．  } 
17．  class ButtonListener implements ActionListener{ 
18．    public void actionPerformed(ActionEvent e){ 
19．    count ++ 
20．      myTextArea.setText("button clicked" + {
21．          count + "times");
22．    }
23．  }// end of innerclass ButtonListener
24．
25．  public static void main(String args[]){ 
26．    MyFrame f = new MyFrame();
27．    f.setSize(300,300);
28．    f.setVisible(true);
29．  }
30． } // end of class MyFrame     前面的例子包含一个类MyFrame，它包括一个内部类ButtonListener。编译器生成一个类文件，MyFrame$ButtonListener.class以及toMyFrame.class。它包含在MyFrame.class中，是在类的外部创建的。6.14.2  如何做内部类工作？
    内部类可访问它们所嵌套的类的范围。所嵌套的类的成员的访问性是关键而且很有用。对嵌套类的范围的访问是可能的，因为内部类实际上有一个隐含的引用指向外部类上下文（如外部类“this”）。
1. public class MyFrame extends Frame{
2.     Button myButton;
3.     TextArea myTextarea;
4.     public MyFrame(){
5.       ......................
6.       ......................
7.       MyFrame$ButtonListener bList = new 
8.                MyFrame$ButtonListener(this); 
9.       myButton.addActionListener(bList); 
10.    }
11.    class MyFrame$ButtonListener implements 
12.    ActionListener{
13.    private MyFrame outerThis;
14.    Myframe$ButtonListener(MyFrame outerThisArg){ 
15.       outerThis = outerThisArg; 
16.    }
17.    
18.    public void actionPerformed(ActionEvent e) { 
19.    outerThis.MyTextArea.setText("buttonclicked"); 
20.    ......................
21.    ......................
22.    }
23.    public static void main(String args[]){
24.      MyFrame f = new MyFrame();
25.      f.setSize(300,300);
26.      f.setVisible(true);
27.    }
28. } 
    有时可能要从static方法或在没有this的某些其它情况下，创建一个内部类的一个实例（例如，main）。可以如下这么做：
public static void main(String args[]){
    MyFrame f = new MyFrame();
    MyFrame.ButtonListener bList =
           f.new ButtonListener(); 
    f.setSize(50,50);
    f.setVisible(true); 
}
内部类属性：
 内部类有如下属性：
    类名称只能用在定义过的范围中，除非用在限定的名称中。内部类的名称必须与所嵌套的类不同。
    内部类可以被定义在方法中。这条规则较简单，它支配到所嵌套类方法的变量的访问。任何变量，不论是本地变量还是正式参数，如果变量被标记为final，那么，就可以被内部类中的方法访问。
内部类可以使用所嵌套类的类和实例变量以及所嵌套的块中的本地变量。
内部类可以被定义为abstract.
    属性
    只有内部类可以被声明为private或protected，以便防护它们不受来自外部类的访问。访问保护不阻止内部类使用其它类的任何成员，只要一个类嵌套另一个。
    一个内部类可以作为一个接口，由另一个内部类实现。
    被自动地声明为static的内部类成为顶层类。这些内部类失去了在本地范围和其它内部类中使用数据或变量的能力。
    内部类不能声明任何static成员；只有顶层类可以声明static成员。因此，一个需求static成员的内部类必须使用来自顶层类的成员。

Answer 6

静态内部类有static修饰符:
   public static interface Linkable{这是最根本的区别.普通内部类在outter class以外的类中实例化时需要一个outter class的实例:
OutterClass.InnerClass obj = new OutterClass().new InnerClass();
静态内部类就不需要:
OutterClass.InnerStaticClass obj = new OutterClass.InnerStaticClass();

Answer 7

静态成员类，static关键字的
成员类，无static
局部类，{}中定义的类
匿名类，无具体变量引用的类。
他们分别最适合在是什么场合使用？这个要具体情况具体一看，一下子说不清楚何时使用抽象类和何时使用接口？抽象类是为了被继承，为了统一，接口是JAVA为了实现多重继承。

Answer 8

按所在位置不同，可以分为两大类
1、 在类方法中-
特点：
    A、可以访问宿主类的所有元素
    B、保存宿主类对象的引用，创建对象时必须有宿主类对象
    C、不能有静态数据
细分：
    1）本地内部类
    2）匿名内部类
      1）2）的区别在于1）有构造函数，而2）只能实例初始化2、 在类或接口作用域中-
特点：
    A、只能访问宿主类的静态元素
    B、创建对象时和宿主类对象无关
    C、可有静态数据细分：
   1）普通内部类
   2）静态内部类

Answer 9

内部类的作用
1）比interface更彻底解决了Java的“多重继承问题”
2）回调
3）应用于控制框架和图形界面