Java 静态内部类 匿名内部类 局部内部类

一、内部类

Java 内部类是在另一个类的主体内定义的。Java 内部类可以声明为私有、公共、受保护或具有默认访问权限，而外部类只能具有公共或默认访问权限。
类的五大成员：属性、方法、构造器、内部类、代码块。
内部类可以直接访问该类中的私有属性。

二、静态和非静态嵌套类

1、静态嵌套类
如果嵌套类是静态的，则称为静态嵌套类。静态嵌套类只能访问外部类的静态成员。静态嵌套类与任何其他顶级类相同，嵌套只是为了方便打包。由于静态嵌套类是不依赖于对象，所以他可以由外部类直接创建对象。

OutClass.InnerClass1 innerClass1 = new OutClass.InnerClass1();

public class InnerClassTest {
    public static void main(String[] args) {
        OutClass.InnerClass1 innerClass1 = new OutClass.InnerClass1();
    }
}
class OutClass {
    private String outName;
    private int outAge = 10;
    public void outEat() {
        System.out.println("OutClass.outEat");
    }
    static class InnerClass1 {
        private String innerName;
        private int innerAge;
        public void innerEat() {
            System.out.println("InnerClass1.innerEat");
        }
    }
    @Override
    public String toString() {
        return "OutClass{" +
                "outName='" + outName + '\'' +
                ", outAge=" + outAge +
                '}';
    }
}

2、非静态嵌套类
任何非静态嵌套类在 Java 中都称为内部类。Java内部类与类的对象相关联，可以访问外部类的所有变量和方法。
由于内部类与实例相关联，因此我们不能在其中包含任何静态变量。
java内部类的对象是外部类对象的一部分，要创建内部类的实例，首先需要创建外部类的实例。

OutClass outclass = new OutClass();
OutClass.InnerClass1 innerClass1 = new outclass.InnerClass1();

public class InnerClassTest {
    public static void main(String[] args) {
    	OutClass outclass = new OutClass();
        OutClass.InnerClass1 innerClass1 = new outclass.InnerClass1();
    }
}
class OutClass {
    private String outName;
    private int outAge = 10;
    public void outEat() {
        System.out.println("OutClass.outEat");
    }
    class InnerClass2 {
        private String innerName;
        private int innerAge;
        public void innerEat() {
            System.out.println("InnerClass2.innerEat");
        }
    }
    @Override
    public String toString() {
        return "OutClass{" +
                "outName='" + outName + '\'' +
                ", outAge=" + outAge +
                '}';
    }
}

三、局部内部类

在方法体中定义了一个类，则称它为局部内部类。

public class InnerClassTest {
    public static void main(String[] args) {
        OutClass outClass = new OutClass();
        outclass.outFun();
    }
}
class OutClass {
    private String outName;
    private int outAge = 10;
    public void outEat() {
        System.out.println("OutClass.outEat");
    }
    public void outFun() {
        class FunInnerClass {
            private String funInnerName;
            public void f1() {
                outAge = 20;
                System.out.println("outAge" + outAge);
            }
        }
        FunInnerClass funInnerClass = new FunInnerClass();
        funInnerClass.f1();
    }

    @Override
    public String toString() {
        return "OutClass{" +
                "outName='" + outName + '\'' +
                ", outAge=" + outAge +
                '}';
    }
}

1、局部内部类是定义在外部类的局部位置，通常在方法
2、可以直接访问外部类的所有成员，包含私有的
3、不能添加访问修饰符，但是可以使用final和abstract修饰
4、作用域：只能在定义它的方法或代码块中
5、局部内部类可以直接访问外部类的成员

四、匿名内部类

可以在定义一个类的同时对其进行实例化。它与局部类很相似，它没有类名，如果某个局部类你只使用一次，那么你就可以使用匿名内部类。
匿名类是一个表达式。

语法规则

new 类/接口(){

};

实现接口匿名类

public class AnonymousInnerClassTest {
    public static void main(String[] args) {
        AnonymousInnerClass anonymousInnerClass = new AnonymousInnerClass();
        anonymousInnerClass.fun1();
    }
}
class AnonymousInnerClass {
    private String name;
    private int age;
    public void fun() {
        System.out.println("AnonymousInnerClass.fun");
    }
    public void fun1() {
        Io io = new Io() {
            @Override
            public void func() {
                System.out.println("AnonymousInnerClass.func");
            }
        };
        io.func();
    }
}
interface Io {
    void func();
}

执行结果 AnonymousInnerClass.func

对于上述代码，在AnonymousInnerClass 类中有一个fun1的方法，在方法中实现了接口匿名类，此接口实质是Io接口的子类并且重写了接口中的方法。我们都知道类都有自己的名字，那么这个子类的名字又是什么呢？

public void fun1() {
	Io io = new Io() {
		@Override
		public void func() {
			System.out.println("AnonymousInnerClass.func");
		}
	};
	io.func();
	System.out.println(io.getClass());
}

输出结果：AnonymousInnerClass$1@14ae5a5
我们可以看到由底层给我们自动创建了AnonymousInnerClass$1的子类名称。

匿名子类（继承父类）

public class AnonymousInnerClassTest {
    public static void main(String[] args) {
        AnonymousInnerClass anonymousInnerClass = new AnonymousInnerClass();
        anonymousInnerClass.fun2();
    }
}
class AnonymousInnerClass {
    private String name;
    private int age;
    public void fun() {
        System.out.println("AnonymousInnerClass.fun");
    }
    public void fun2() {
        Book book = new Book(){
            @Override
            public void b() {
                super.b();
            }
        };
        book.b();
        System.out.println(book);
    }
}
class Book {

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

执行结果 Book.b

匿名内部类可以访问外部的所有成员，不能定义静态属性、方法，可以有常量属性（final修饰的属性），可以定义属性，可以有额外的方法（父接口、类中没有的方法），可以定义内部类，可以对其他类进行实例化。