匿名内部类怎么用？有什么号的总结么？或者是很经典的例子也好。

内部类的总结
  1. 成员位置内部类，可以被成员修饰符修饰
    内部类可以直接使用外部类成员
  
  调用内部类方法三种格式：
    外部类.内部类 变量名 = new 外部类().new内部类();
    内部类，内部类方法，都是非静态

    外部类.内部类.方法()
    内部类静态，内部类方法静态

    外部类.内部类 变量 = new 外部类.内部类();
    内部类静态，内部类方法非静态

  2. 局部位置内部类
    运行局部位置内部类，必须依靠外部类中的方法，这个方法中创建内部类对象
    局部位置内部类，访问局部变量加final,原因是生命周期问题
    final的方法，巧妙的解决的生命周期

  3. 匿名内部了
    匿名内部类，是一种简化形式，简化子类或者实现类的一种写法
    格式：
      new 接口或者父类(){
        重写方法
      }.方法();

      接口或者父类 变量 = new 接口或者父类(){
        重写多个方法
      };
      变量.方法();
      变量.方法();

class Oute{
        private static int x =3;
       
        static class Inner{ //静态内部类
                static void function(){
                        System.out.println("Inner:" + x);//1. 可以直接访问外部类静态成员变量
                }
        }
        public static void show(){
                new Inner2().method();//2. 外部类静态方法访问内部类时，内部类也必须是静态的。
        }
}
－－－－－－－－－－－－－－－－－－－－3. 变量访问形式－－－－－－－－－－－－－－－－－－
class Outer{
        private int x = 3;
        class Inner{
                int x = 5;
                void show(){
                        int x = 7;
                        System.out.println(Outer.this.x);//访问外部变量
                        System.out.println(this.x);//访问内部变量
                        System.out.println(x);//访问局部变量
                }
        }
        void show(){
                Inner in = new Inner();//外部类访问内部，需要创建内部类对象
                in.show();
        }
}

－－－－－－－－－－－－－－－－－4. 内部类调用形式－－－－－－－－－－－－－－－－－－－－－
public class _Inner_static {

        public static void main(String[] args) {
                // TODO Auto-generated method stub
                new Oute.Inner().function();//在外部其他类中，访问内部类的非静态成员方式
                Oute.Inner.function();//在外部其他类中，访问内部类的静态成员方式
               
                new Oute().show();//调用外部类方法方式
        }
}

希望对你有帮助............

匿名内部类：
1，匿名内部类其实就是内部类的简写格式
2,定义匿名内部类的前提：
        内部类必须继承一个类或者实现接口。
3,匿名内部类的格式： new 父类或者接口(){定义子类的内容}
4，其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖，可以理解为带内容的对象。
5，匿名内部类中定义的方法最好不超过3个。
interface Inter
{
        void method();
}

class Test
{
        //补足代码，通过匿名内部类
       
        /*
        static class Inter implements Inner
        {
                public void method()
                {
                        System.out.println("method run");
                }
        }
        */


        static Inter function()
        {
                return new Inter()
                {
                        public void method()
                        {
                                System.out.println("mnetod run");
                        }
                };
        }
}


class InnerClassTest
{
        public static void main(String[] args)
        {
                //Test.function().method();
                //.method();function这个方法运算后的结果是一个对象，而且是一个Inter类型的独享
                //因为只有是Inter类型对象，才可以调用method方法。

                Test.function().method();
                //Inter in = Test.function();
                //in.method();       
       
                /*
                show(new Inter()
                {
                        public void method()
                        {
                                System.out.println("mnetod run");
                        }
                });
                */       
        }

        public static void show(Inter in)
        {
                in.method();
        }
}

class InnerTest
{
       
        public static void main(String[] args)
        {
                new Object();
                {
                        public void function()
                        {
                               
                        }
                }.function();
        }
}

看上面两个答案那么详细，我就不说啦，希望楼主学好哦