java中的内部类

一、成员内部类
成员内部类中不能写静态的 变量，方法，但是如果该静态变量被final修饰的时候，是可以的
代码：

class Aoo {
    int x = 3;
    class Boo {
        int x = 4;
        public void f() {
            int x = 5;
            // 要打印Aoo中的x,用以下写法
            System.out.println(Aoo.this.x);
        }
    }
}
class Aoo {
    int x = 3;
    class Boo {
        int x = 4;
        public void f() {
            int x = 5;
            // 要打印Boo中的x,用以下写法
            System.out.println(this.x);
        }
    }
}
class Aoo {
    int x = 3;
    class Boo {
        int x = 4;
        public void f() {
            int x = 5;
            // 要打印f方法中的x,用以下写法
            System.out.println(x);
        }
    }
}
public class TestDemo {
    public static void main(String[] args) {
    // 要实例化内部类，需要先实例化外部类
        Aoo aoo = new Aoo();
        Aoo.Boo boo = aoo.new Boo();
        Aoo.Boo boo1 = new Aoo().new Boo();
        boo.f();
    }
}

二、静态内部类
1、静态内部类只能直接访问外部类中的静态方法，不能直接访问外部类的非静态方法；

class Coo {
    int x = 3;
    static int y = 4;
    static class Doo {
        int a = 5;
        public void f() {
            System.out.println(y);
        }
    }
}

2、如果需要访问外部类中的非静态方法，需要new一个外部类的对象，然后通过 对象.变量访问；

class Coo {
    int x = 3;
    static int y = 4;
    static class Doo {
        int a = 5;
        public void f() {
            System.out.println(new Coo().x);
        }
    }
}

3、静态内部类实例化的时候，不需要先实例化外部类，可以直接通过 new 外部类.内部类() 来创建;

  public static void main(String[] args) {
        Coo.Doo doo = new Coo.Doo();
        doo.f();
    }

三、匿名内部类

public class TestDemo {
    public static void main(String[] args) {
        f();
    }
    public static void f() {
        /**
         * 匿名内部类只能被创建一次，必须依赖于其他类；
         * 此处的new  new的是匿名内部类,相当于声明的是父类，new的是子类
         * 匿名内部类没有构造器，{}里面的就是匿名内部类
         * 如果Goo是一个接口，则匿名内部类实现了这个接口，如果Goo是一个类，则匿名内部类继承了这个类
         * 匿名内部类一般是写在方法里面的，也叫局部内部类，如果匿名内部类需要访问类中的变量，则这个变量需要被final修饰
         */
        Goo goo = new Goo(){
            @Override
            public void ff() {
                System.out.println("匿名内部类");
            }
        };
        System.out.println(goo.x);
        //这一步是声明的父类，new的子类，调用方法的时候是子类的方法，即ff()方法输出的是 “匿名内部类”
        goo.ff();
        Hoo hoo = new Hoo() {
            @Override
            public void h() {
                // 匿名内部类实现了Hoo接口，声明的是父类，new的是子类，调用的是子类的h(),输出的是 "TestDemo.h"
                System.out.println("TestDemo.h");
            }
        };
        hoo.h();
    }
}

class Goo {
    int x = 4;
    public void ff() {
        System.out.println("Goo.ff");
    }
}

interface Hoo{
    void h();
}