看视屏过程中经常会看到匿名类和内置类。到底什么时候用匿名类什么时候用内置类咧！

定义在类中方法之外的内部类分为实例内部类和静态内部类.实例内部类自动持有外部类的实例的引用，即可以访问外部类的所有变量；定义在方法中的内部类叫局部内部类，该类只能访问被final修饰的局部变量和参数。匿名内部类既然叫匿名，那么名字对于该类来说已经不重要，因为该匿名类的实例本来就不打算给别的类使用或重复使用，仅限于类内部使用或使用一次，所以就不需要类名了，不过因为没有类名匿名内部类也就没有构造函数了。

内部类分四种：成员内部类、局部内部类、静态内部类和匿名内部类。
1.首先，把内部类作为外部类的一个特殊的成员来看待，因此它有类成员的修饰符：private ,protected,默认(friendly),public,static,final,abstract.
2.非静态内部类nested inner class,内部类隐含有一个外部类的指针this,它可以访问外部类的一切资源（包括私有）;外部类访问内部类的成员，先要取得内部类的对象,并且取决于内部类成员的封装等级;且不能包含任何static成员.
3.静态内部类：static inner class,不再包含外部类的this指针，并且在外部类装载时初始化;静态内部类能包含static或非static成员;静态内部类只能访问外部类static成员;外部类访问静态内部类的成员，对于static成员，用类名.成员即可访问，对于非static成员，只能用对象.成员进行访问.
4.对于局部内部类只能访问块中或方法中的final变量。类成员有两种static , non-static，同样内部类也有这两种：
①.non-static 内部类的实例，必须在外部类的方法中创建或通过外部类的实例来创建(OuterClassInstanceName.new innerClassName(ConstructorParameter)),并且可直接访问外部类的信息,外部类对象可通过OuterClassName.this来引用
②.static 内部类的实例, 直接创建即可，没有对外部类实例的引用。
内部类不管static还是non-static都有对外部类的引用；non-static 内部类不允许有static成员.
方法中的内部类只允许访问方法中的final局部变量和方法的final参数列表，所以说方法中的内部类和内部类没么区别;但方法中的内部类不能在方法以外访问，方法中的不可以有static内部类.
5.匿名内部类是一种特殊的局部内部类，它是通过匿名类实现接口.
①,一个类用于继承其他类或是实现接口，并不需要增加额外的方法，只是对继承方法的事先或是覆盖.
②,只是为了获得一个对象实例，不需要知道其实际类型.
③,类名没有意义，也就是不需要使用到类名.
匿名内部类如果继承自接口,必须实现指定接口的方法,且无参数;匿名内部类如果继承自类,参数必须按父类的构造函数的参数传递

匿名类也有匿名内部类和普通的匿名类区别。我们经常使用是普通的匿名类，对于匿名内部类要求其内部的方法尽量少，否则在使用过程中过于复杂、代码过长。
内部类也有多种：成员内部类、局部内部类、还有被static修饰的静态内部类。需要注意的是对内部类的方法调用。关于内部类使用，最重要的是理清思路，例如
我们要访问某个人的什么东西，这个东西本身就是一个对象、人也是对象而且有附属关系，这种情况下建立内部类。

匿名内置类不能再extends(继承)其它类，因为它已经隐形地extends或者implements了，多重继承是不可能的。但一个内部类可以作为一个接口，由另一个内部类实现，匿名内部类就是实现的接口，继承的父类。那个new xx(){}的xx就是父类和接口的名字。而不是本身类的名字。什么时候用匿名内部类如下面的例子：btn.addActionListener(new ActionListener(){


public void actionPerformed(ActionEvent parm1){


。。。。


System.exit(0);


}

        内部类就是在一个类的内部定义的类，内部类中不能定义静态成员（静态成员不是对象的特性，只是为了找一个容身之处，所以需要放到一个类中而已，这么一点小事，你还要把它放到类内部的一个类中，过分了啊！提供内部类，不是为让你干这种事情，无聊，不让你干。我想可能是既然静态成员类似c语言的全局变量，而内部类通常是用于创建内部对象用的，所以，把“全局变量”放在内部类中就是毫无意义的事情，既然是毫无意义的事情，就应该被禁止），内部类可以直接访问外部类中的成员变量，内部类可以定义在外部类的方法外面，也可以定义在外部类的方法体中，如下所示：
        public class Outer
        {
                        int out_x  = 0;
                        public void method()                {
                                Inner1 inner1 = new Inner1();
                                public class Inner2   //在方法体内部定义的内部类
                                {
                                        public method()
                                        {
                                                out_x = 3;
                                        }
                                }
                                Inner2 inner2 = new Inner2();
                        }
       
                        public class Inner1   //在方法体外面定义的内部类
                        {
                        }
                       
        }
        在方法体外面定义的内部类的访问类型可以是public,protecte,默认的，private等4种类型，这就好像类中定义的成员变量有4种访问类型一样，它们决定这个内部类的定义对其他类是否可见；对于这种情况，我们也可以在外面创建内部类的实例对象，创建内部类的实例对象时，一定要先创建外部类的实例对象，然后用这个外部类的实例对象去创建内部类的实例对象，代码如下：
        Outer outer = new Outer();
        Outer.Inner1 inner1 = outer.new Innner1();
       
        在方法内部定义的内部类前面不能有访问类型修饰符，就好像方法中定义的局部变量一样，但这种内部类的前面可以使用final或abstract修饰符。这种内部类对其他类是不可见的其他类无法引用这种内部类，但是这种内部类创建的实例对象可以传递给其他类访问。这种内部类必须是先定义，后使用，即内部类的定义代码必须出现在使用该类之前，这与方法中的局部变量必须先定义后使用的道理也是一样的。这种内部类可以访问方法体中的局部变量，但是，该局部变量前必须加final修饰符。
        对于这些细节，只要在eclipse写代码试试，根据开发工具提示的各类错误信息就可以马上了解到。
       
        在方法体内部还可以采用如下语法来创建一种匿名内部类，即定义某一接口或类的子类的同时，还创建了该子类的实例对象，无需为该子类定义名称：
        public class Outer
        {
                        public void start()
                        {
                                new Thread(
        new Runable(){
                                                public void run(){};
}
        ).start();
                        }
        }
       
        最后，在方法外部定义的内部类前面可以加上static关键字，从而成为Static Nested Class，它不再具有内部类的特性，所有，从狭义上讲，它不是内部类。Static Nested Class与普通类在运行时的行为和功能上没有什么区别，只是在编程引用时的语法上有一些差别，它可以定义成public、protected、默认的、private等多种类型，而普通类只能定义成public和默认的这两种类型。在外面引用Static Nested Class类的名称为“外部类名.内部类名”。在外面不需要创建外部类的实例对象，就可以直接创建Static Nested Class，例如，假设Inner是定义在Outer类中的Static Nested Class，那么可以使用如下语句创建Inner类：
        Outer.Inner inner = new Outer.Inner();
        由于static Nested Class不依赖于外部类的实例对象，所以，static Nested Class能访问外部类的非static成员变量。当在外部类中访问Static Nested Class时，可以直接使用Static Nested Class的名字，而不需要加上外部类的名字了，在Static Nested Class中也可以直接引用外部类的static的成员变量，不需要加上外部类的名字。
        在静态方法中定义的内部类也是Static Nested Class，这时候不能在类前面加static关键字，静态方法中的Static Nested Class与普通方法中的内部类的应用方式很相似，它除了可以直接访问外部类中的static的成员变量，还可以访问静态方法中的局部变量，但是，该局部变量前必须加final修饰符。      //张孝祥老师整理
   
匿名类就是一些没有名字的类，有些时候我们在程序只要使用一次某个类，其他时候就不再使用，那么为了程序的紧凑，就可以将临时用到的类定义成匿名类，它往往也是内部类，通常称为匿名内部类。通用形式。。。new 接口/抽象类/父类(){
                            //子类代码
                  }          在线程和GUI中我们经常可以看到匿名类的使用。这也是面向对象封装性的体现。

内部类的好处就是可以防问，外部类的私有成员变量。 如果接口的实现类只使用一次的话就没有必要在定义一个类此时使用匿名类。。

内部类总结：
1.首先，把内部类作为外部类的一个特殊的成员来看待，因此它有类成员的封闭等级：private ,protected,默认(friendly),public
                                                      它有类成员的修饰符:   static,final,abstract
2.非静态内部类nested inner class,内部类隐含有一个外部类的指针this,因此，它可以访问外部类的一切资源（当然包括private）
  外部类访问内部类的成员，先要取得内部类的对象,并且取决于内部类成员的封装等级。
  非静态内部类不能包含任何static成员.
3.静态内部类：static inner class,不再包含外部类的this指针，并且在外部类装载时初始化.
  静态内部类能包含static或非static成员.
  静态内部类只能访问外部类static成员.
  外部类访问静态内部类的成员，循一般类法规。对于static成员，用类名.成员即可访问，对于非static成员，只能
    用对象.成员进行访问

4.对于方法中的内部类或块中内部类只能访问块中或方法中的final变量。


类成员有两种static , non-static，同样内部类也有这两种
non-static 内部类的实例，必须在外部类的方法中创建或通过外部类的实例来创建(OuterClassInstanceName.new innerClassName(ConstructorParameter)),并且可直接访问外部类的信息,外部类对象可通过OuterClassName.this来引用
static 内部类的实例, 直接创建即可，没有对外部类实例的引用。
内部类不管static还是non-static都有对外部类的引用
non-static 内部类不允许有static成员

方法中的内部类只允许访问方法中的final局部变量和方法的final参数列表，所以说方法中的内部类和内部类没什麽区别。但方法中的内部类不能在方法以外访问，方法中不可以有static内部类
匿名内部类如果继承自接口,必须实现指定接口的方法,且无参数
匿名内部类如果继承自类,参数必须按父类的构造函数的参数传递

问题. 到底什么时候用匿名类什么时候用内置类咧！

答：
1.内部类不是必须的，为什么要使用内部类？
<1>在某一个类中访问另外一个类的私有成员。
<2>某个类对象依赖于另一个类对象。

2.匿名内部类的特点：继承一个类或实现一个借口并获取一个实现实例。没有类名，没有构造方法，只能产生一个实例。

3.匿名内部类多使用在借口的回调。

4.当使用多个内部类对象时，使用内置类。