匿名内部类

一：首先创建一个静态成员内部类（因为在方法外面）

public class Outer01 {
    public static class Inner{
        public static void run(){
            System.out.println("加油吧少年");
        }
    }
}

测试：内部类是static修饰的，所以可以用类名点属性名的方式调用方法

public class InnerTest {
    @Test
    public void outer01(){
        Outer01.Inner.run();
    }
}

二：去掉内部类的静态修饰符static

public class Outer02 {
    public class Inner{
        public static void run(){
            System.out.println("加油吧少年");
        }
    }
}

                测试：依然可以用类名点属性名的方式调用方法

                        （关键不在于你的内部类是否用静态修饰修饰，

                            关键在于方法是否被静态修饰符修饰）

public class InnerTest {
     @Test
    public void outer02(){
        Outer02.Inner.run();
    }
}

三：将方法前的静态修饰符也去掉

public class Outer03 {
    public class Inner{
        public void run(){
            System.out.println("加油吧少年");
        }
    }
}

                测试：这时就需要一步一步的实例化对象啦

public class InnerTest {
     @Test
    public void outer03(){
        new Outer03().new Inner().run();
    }
}

四：公有方法innerRun（不要加static）访问私有内部类

public class Outer04 {
    public class Inner {
        public void run() {
            System.out.println("加油吧少年");
        }
    }

    public void innerRun() {
        new Inner().run();
    }
}

                测试：这样就不用实例化外部类啦

public class InnerTest {
      @Test
    public void outer04(){
        new Outer04().innerRun();
    }
}

五：把内部静态类放在公有方法里，将它变为内部静态局部变量

public class Outer05 {

    public static void innerRun() {
        class Inner {
            public static void run() {
                System.out.println("加油吧少年");
            }
        }
        Inner.run();
    }
}

                测试：

public class InnerTest {
     @Test
    public void outer05(){
        Outer05.innerRun();
    }
}

  六:将内部类里的方法的static去掉   ，这是公有方法里就需要实例化对象啦，

        不能直接类名点属性名啦    

public class Outer06 {

    public static void innerRun() {
        class Inner {
            public void run() {
                System.out.println("加油吧少年");
            }
        }
        new Inner().run();
    }
}

                测试：

public class InnerTest {
     @Test
    public void outer06(){
        Outer06.innerRun();
    }
}

七：将公有方法变为非静态的

public class Outer07 {

    public void innerRun() {
        class Inner {
            public void run() {
                System.out.println("加油吧少年");
            }
        }
        new Inner().run();
    }
}

                测试：可以实例化对象调用

 @Test
    public void outer07(){
        new Outer07().innerRun();
    }

八：公有方法里的内部类里什么也没写

public class Outer08 {

    public void innerRun() {
        class Inner{}
        new Inner(){
            public void run(){
                System.out.println("加油吧少年");
            }
        };
    }
}

                测试：在实例化对象里写方法，但这个方法不会运行

  @Test
    public void outer08(){
        new Outer08().innerRun();
    }

九：实例化对象后点属性名，则实例化对象里的方法就能运行啦

public class Outer09 {

    public void innerRun() {
        class Inner{}
        new Inner(){
            public void run(){
                System.out.println("加油吧少年");
            }
        }.run();
    }
}

                测试：

 @Test
    public void outer09(){
        new Outer09().innerRun();
    }

十：使用object超级类，就不用在声明一个类啦（匿名内部类）

public class Outer10 {

    public void innerRun() {
        new Object(){
            public void run(){
                System.out.println("加油吧少年");
            }
        }.run();
    }
}

                测试：

 @Test
    public void outer10(){
        new Outer10().innerRun();
    }