Java—内部类

内部类：定义在类中的类。 也是一种扩展, 扩展外部类没有的功能。分为四种：

• 普通内部类、
• 局部内部类、
• 静态内部类、
• 匿名内部类

普通内部类

1)普通内部类中不能有静态的变量和方法
2)普通内部类可以直接访问外部类的所有属性和方法
Outer：

public class Outer {
    private String name="cao";
    class Inner{
        String name ="chen";

        public void show(){
            System.out.println("hello inner...");
            System.out.println(name);
            // 访问外部类的同名变量
            System.out.println(Outer.this.name);
        }
    }
}

Test:

public class Test {
    public static void main(String[] args) {
        // 访问普通内部类
        Outer outer=new Outer();
        Outer.Inner inner=outer.new Inner();
        inner.show();
    }
}

hello inner...
chen
cao

局部内部类

定义在方法中的,就像局部变量一样

Outer：

public class Outer {
    public void show() {
        /**
         * 只能作用在这个方法
         */
        class Inner {
            String string = "hello Inner...";

            public void eat() {
                System.out.println(string);
            }
        }
        Inner inner = new Inner();
        inner.eat();
    }
}

Test：

public class Test {
    public static void main(String[] args) {
        Outer outer=new Outer();
        outer.show();
    }
}

hello Inner...

静态内部类

静态内部类中可以有静态属性和静态方法
静态方法的访问不需要创建对象,因而当调用静态方法的时候成员变量还没有初始化，因此静态内部类不能访问外部类的成员属性和方法，只能访问外部类的静态属性和静态方法
Outer：

public class Outer {
    public  String name0="666";
    private static String name="chen";
    
    static class Inner {
        static String NAME = "cao";
       
        public static void show() {
            //System.out.println(Outer.name0);name0不是静态变量，会报错
            System.out.println(Outer.name);//Outer.name和name一致
            System.out.println("public static void show()");
        }

        public void eat() {
            System.out.println("public void eat()");
        }
    }
}

Test：

public class Test {
    public static void main(String[] args) {
        // 方法static修饰的属性和方法 不需要创建对象 可以通过类名直接调用
        System.out.println(Outer.Inner.NAME);
        Outer.Inner.show();
        // 访问成员方法需要创建对象
        Outer.Inner inner=new Outer.Inner();
        inner.eat();

    }
}

cao
chen
public static void show()
public void eat()

匿名内部类

看作是方法重写
Outer:

public class Outer {

    public void show() {
    }

}

Test:

public class Test {
    public static void main(String[] args) {
        Outer outer = new Outer() {
            // 声明外部类的接口来访问内部类的方法
            public void show() {
                System.out.println("public void show()");
            }
        };
        outer.show();
    }
}

public void show()