JAVA内部类

一：成员内部类

package test;

public class Test4 {
    private String a;
    public static int i = 9;
    public int si = 9;

    public void say() {
        // 外部类直接new 内部类访问内部类XX
        getT().sayT();
    }

    public T getT() {
        return new T();
    }

    public static void main(String[] args) {
        //new Test4().say();
        //创建成员内部类对象

        //第一种方法
        Test4 test4 = new Test4();
        T t =test4.getT();

        //第二种方法
        T t1 = new Test4().new T();
    }

    public class T {
        private String a;
        public int si = 10;

        public void sayT() {
            // 如果外部类与内部类有相同的成员变量和方法，使用外部
            // 类.this.XX 访问外部类XX
            System.out.println(Test4.this.si);
        }
    }
}

再说说修饰符：

两个极端的，public不用说，无论在哪儿，随便访问。private只能在类的内部访问，但是其他地方也是可以访问的，比如一个对象的属性为private，可以开放一个接口供外部引用，也就是setter，getter。protected除了外部包，其余都能访问，default只能在内以及本包访问。虽然protected不能在外部包访问，但是可以在中间加一个类继承有protected属性以及方法的类，然后类再继承这个类就可以访问了。

二：局部内部类
局部内部类是定义在一个方法或者一个作用域里面的类

package test;

public class LocalInner {
    private String a = "1";
    private static int t = 12;
    private final String b = "haha";

    public void getInfo() {
        String b = "ha";
        class Inner {
            private String a = "nidaye";

            public void show() {
                System.out.println(a);
                System.out.println(LocalInner.this.a);
                System.out.println(b);
                System.out.println(LocalInner.this.b);
                System.out.println(t);
            }
        }
        new Inner().show();
    }

    public static void main(String[] args) {
        new LocalInner().getInfo();
    }
}

三：匿名内部类
匿名内部类也就是没有名字的内部类

正因为没有名字，所以匿名内部类只能使用一次，它通常用来简化代码编写

但使用匿名内部类还有个前提条件：必须继承一个父类或实现一个接口

如果一个接口实现只使用一次，可以使用匿名内部类
interface Person {
    public void eat();
}

public class Demo {
    public static void main(String[] args) {
        Person p = new Person() {
            public void eat() {
                System.out.println("eat something");
            }
        };
        p.eat();
    }
}
而不用新建一个实现类然后再实例化实现类。
最常用的情况就是在多线程的实现上，因为要实现多线程必须继承Thread类或是继承Runnable接口

四：静态内部类
就是在成员内部类前加上static，在静态内部类不能访问外部内非static的变量和方法。并且静态内部类在第一次被引用时被加载，而且其加载过程是线程安全的（实现线程安全），所以用来实现单例模式最合适。