java内部类

java中四种内部类：普通内部类，静态内部类，匿名内部类，局部内部类

1. 普通内部类

public class CommonOuterClass {
    private String outerName = "外部类";

    CommonOuterClass() {
        System.out.println(this.getClass().getSimpleName());
        CommonInnerClass c = new CommonInnerClass();
        System.out.println(c.innerName);
    }

    class CommonInnerClass {
        private String innerName ="内部类";

        public CommonInnerClass() {
            System.out.println(this.getClass().getSimpleName());
            System.out.println(outerName);
        }
    }

    public static void main(String[] args) {
        new CommonOuterClass();
    }

运行结果：

CommonOuterClass
CommonInnerClass
外部类
内部类

总结：
普通内部类可以看作外部类的一个成员变量，内部类对象依赖外部类对象

2. 静态内部类

public class StaticOuterClass {
    private String outerName = "外部类";
    private static String static_outerName = "静态外部类";

    StaticOuterClass() {
        System.out.println(this.getClass().getSimpleName());
        CommonInnerClass c = new CommonInnerClass();

        System.out.println(c.innerName);  // 外部类可以访问静态内部类的变量
    }

    /**
     * 静态内部类就像外部类的静态成员一样，因此对静态内部类的访问不依赖与外部类的对象，
     *
     */
    static class CommonInnerClass {
        private String innerName ="内部类";
        private static String static_innerName ="静态内部类";

        public CommonInnerClass() {
            System.out.println(this.getClass().getSimpleName());
            //System.out.println(outerName);  //编译报错，静态内部类无法访问外部类的非静态变量
        }
    }

    public static void main(String[] args) {
        //new CommonInnerClass();  //可以直接new内部类对象，访问内部类静态变量
        //System.out.println(CommonInnerClass.static_innerName);
        new StaticOuterClass();
    }
}

运行结果：
StaticOuterClass
CommonInnerClass
内部类

总结：
静态内部类可以看作外部类的一个静态变量，因此静态内部类独立于外部类对象

3. 匿名内部类

public class AnonymousOuterClass {

    AnonymousOuterClass() {
    }

    //自定义接口
    interface MyInterface{
        void say(String name);
    }

    // 实现方式1：
    // 在方法中或代码块中，通过实现 接口或抽象类或继承父类 的方式new出对象，在new对象过程中具体实现类不出现
    public void sayHello() {
        MyInterface m1 = new MyInterface() {
            @Override
            public void say(String name) {
                System.out.println(name + " say hello...");

            }
        };
        // 调用匿名内部类
        m1.say("xiaoli");
    }

	// 实现方式2：在调用对象时 重写对象的方法
	public void sayWang(Object o) {
        System.out.println(o.hashCode());
    }
    
    public static void main(String[] args) {
        //new AnonymousOuterClass().sayHello();

		new AnonymousOuterClass().sayWang(new Object(){
            @Override
            public int hashCode() {
                return 100;
            }
        });
    }
}

总结：
匿名内部类是在方法或代码块中，通过实现 接口或抽象类或继承父类 的方式new出对象，在new对象过程中具体实现类不出现

4. 局部内部类

是在方法或代码块中定义的内部类，定义的方法和属性只在方法或代码块内部起作用，实际用的不多