Java匿名类和内部类是怎么区分的，一般用来做什么呢

该贴已经同步到 郝锡强的微博

内部类被编译成名为OuterClassName$InnerClassName.class的类。  
内部类可以引用定义在它嵌套的外部类中的数据和方法，所以不需要将外部类对象的引用传递给内部类的构造方法，因此，内部类可以拿程序简单和简洁。  
声明用可见性修饰符声明内部类，遵从应用于一般类成员的可见性规则。  
可以将内部类声明为static。一个static内部类可以使用外部类的名字访问。一个static类是不能访问外部类的非静态成员的。  
内部类的对象经常在外部类中创建。但是也可以从另一个类中创建一个内部类的对象。如果该内部是非静态的，就必须先创建一个外部类的实例，然后用下面的语法创建一个内部类的对象：  
Java代码
OuterClass.InnerClass innerObject ＝ OutObject.new Innerclass()   
OuterClass.InnerClass innerObject ＝ OutObject.new Innerclass()
.如果内部类是静态的，那么使用下面的语法为它创建一个对象：

Java代码
OuterClass.InnerClass innerObject ＝ new OutObject.Innerclass()   
OuterClass.InnerClass innerObject ＝ new OutObject.Innerclass()
匿名内部类是一种特殊的内部类，所以有很多方面都应把它当作内部类对待。除此之外，它还不以下特征。

匿名内部类必须是扩展父类或实现接口的。但是它不能有明确的extends或implements语句。  
匿名内部类必须实现父类或接口中所有的抽象方法。  
匿名内部类总是使用父类的无参数构造方法来创建实例。如果匿名内部类实现了接口，构造方法就是Object().  
匿名内部类编译为名为OuterClassName$n.class的类。如，如果外部类Test有两个匿名类，那么它们就编译成Test$1.class和Test$2.class。  

匿名内部类只能使用一次，不区分static和非static。如果用到外部类的变量的话，必须是类变量或者实例变量，就是必须是类定义的变量，或者final的局部变量。匿名内部类如果是继承某个类的话是可以重写那个类的方法的，这个和普通内部类一样

内部类可以是static的或者非static的，static内部类只能包含静态方法和静态类变量，只能访问外部类的静态元素，内部类可以实例化，多次使用

所有可以用匿名内部类的地方都可以用内部类替换，但是用匿名内部类编码非常简洁，也容易读懂，除非你需要多次使用那个内部类，不然总是建议使用匿名内部类

1、内部类分为成员内部类、静态嵌套类、方法内部类、匿名内部类。
几种内部类的共性：
A、内部类仍然是一个独立的类，在编译之后会内部类会被编译成独立的.class文件，但是前面冠以外部类的类命和$符号。
B、内部类不能用普通的方式访问。内部类是外部类的一个成员，因此内部类可以自由地访问外部类的成员变量，无论是否是private的。
2、成员内部类：形式如下
    class Outer {
        class Inner{}
    }      
编译上述代码会产生两个文件：Outer.class和Outer$Inner.class。
3、方法内部类。
顾名思义，把类放在方法内。
    class Outer {
        public void doSomething(){
            class Inner{
                public void seeOuter(){
                }
            }   
        }
    }
A、方法内部类只能在定义该内部类的方法内实例化，不可以在此方法外对其实例化。
B、方法内部类对象不能使用该内部类所在方法的非final局部变量。
因为方法的局部变量位于栈上，只存在于该方法的生命期内。当一个方法结束，其栈结构被删除，局部变量成为历史。但是该方法结束之后，在方法内创建的内部类对象可能仍然存在于堆中！例如，如果对它的引用被传递到其他某些代码，并存储在一个成员变量内。正因为不能保证局部变量的存活期和方法内部类对象的一样长，所以内部类对象不能使用它们。
例子：
    class Outer {
        public void doSomething(){
            final int a =10;
            class Inner{
                public void seeOuter(){
                    System.out.println(a);
                }
            }   
            Inner in = new Inner();
            in.seeOuter();
        }
        public static void main(String[] args) {
            Outer out = new Outer();
            out.doSomething();
        }
     }
4、匿名内部类。
顾名思义，没有名字的内部类。表面上看起来它们似乎有名字，实际那不是它们的名字。
A、继承式的匿名内部类。
    class Car {
        public void drive(){
            System.out.println("Driving a car!");
        }
    }
   
    class Test{
        public static void main(String[] args) {
            Car car = new Car(){
                public void drive(){
                    System.out.println("Driving another car!");
                }
            };
            car.drive();
        }
    }
结果输出了：Driving another car! Car引用变量不是引用Car对象，而是Car匿名子类的对象。
B、接口式的匿名内部类。
    interface  Vehicle {
        public void drive();
    }
   
    class Test{
        public static void main(String[] args) {
            Vehicle v = new Vehicle(){
                public void drive(){
                    System.out.println("Driving a car!");
                }
            };
            v.drive();
        }
    }
接口式的匿名内部类是实现了一个接口的匿名类。而且只能实现一个接口。
C、参数式的匿名内部类。
class Bar{
    void doStuff(Foo f){}
}

interface Foo{
    void foo();
}

class Test{
    static void go(){
        Bar b = new Bar();
        b.doStuff(new Foo(){
            public void foo(){
                System.out.println("foofy");
            }
        });
    }
}
5、静态嵌套类。
从技术上讲，静态嵌套类不属于内部类。因为内部类与外部类共享一种特殊关系，更确切地说是对实例的共享关系。而静态嵌套类则没有上述关系。它只是位置在另一个类的内部，因此也被称为顶级嵌套类。

内部类定义在类的内部，匿名类应该算是内部类的一种，因为它肯定也要定义在其他类的内部，只不过它没有名字
内部类就是不希望除了拥有它的外部类以外的其他类访问。
比如
当前你在自己的类中有一些方法和属性值得refact一个新类，而又不希望其他的类来访问，你可以把这个refact的新类作成内部类。只有外部类可以访问它。
这只是一方面

多谢各位了

嵌套类可分为两种不同的类型：使用static修饰的嵌套类称为静态嵌套类；而非static得嵌套类被称为内部类。
其中内部类又可细分为三种形式：
1）普通的内部类
2）局部内部类
3）匿名内部类：也称为匿名类，定义在方法或语句块中，该类没有名字、只能在其所在之处使用一次。
内部类使用举例：
class A {
        private int s;
        public class B{
                public void mb() {
                        s = 100;     
                        System.out.println("在内部类B中s=" + s);
                }
        }
        public void ma() {
                B i = new B();
                i.mb();
        }
}

public class TestInner {       
        public static void main(String args[]){
                A o = new A();
                o.ma();
        }
}
内明类使用举例：
public interface Swimmer{
        public abstract void swim();       
}
class TestAnonymous2{
        public static void main(String args[]){
                TestAnonymous2 ta = new TestAnonymous2();
                ta.test(new Swimmer(){
                        public void swim(){
                                System.out.println("I'swimming!");       
                        }       
                });

        }       
        public void test(Swimmer swimmer){
                swimmer.swim();       
        }
}

嵌套类可分为两种不同的类型：使用static修饰的嵌套类称为静态嵌套类；而非static得嵌套类被称为内部类。
其中内部类又可细分为三种形式：
1）普通的内部类
2）局部内部类
3）匿名内部类：也称为匿名类，定义在方法或语句块中，该类没有名字、只能在其所在之处使用一次。


内部类使用举例：
class A {
        private int s;
        public class B{
                public void mb() {
                        s = 100;     
                        System.out.println("在内部类B中s=" + s);
                }
        }
        public void ma() {
                B i = new B();
                i.mb();
        }
}

public class TestInner {        
        public static void main(String args[]){
                A o = new A();
                o.ma();
        }
}


匿名类使用举例：
public interface Swimmer{
        public abstract void swim();        
}
class TestAnonymous2{
        public static void main(String args[]){
                TestAnonymous2 ta = new TestAnonymous2();
                ta.test(new Swimmer(){
                        public void swim(){
                                System.out.println("I'swimming!");        
                        }        
                });

        }        
        public void test(Swimmer swimmer){
                swimmer.swim();        
        }
}