1, Inner class

Java inner classes are defined within the body of another class. Java inner classes can be declared private, public, protected or have default access rights, while outer classes can only have public or default access rights.
Class: attribute, method, constructor, internal class and code block.
Internal classes can directly access private properties in the class.

2, Static and non static nested classes

1. Static nested class
If a nested class is static, it is called a static nested class. Static nested classes can only access static members of external classes. Static nested classes are the same as any other top-level classes, nested just for packaging purposes. Because the static nested class does not depend on objects, it can create objects directly from external classes.

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. Non static nested class
Any non static nested class is called an inner class in Java. The Java internal class is associated with the object of the class and can access all variables and methods of the external class.
Because the inner class is associated with an instance, we cannot include any static variables in it.
java internal class objects are part of external class objects. To create an instance of an internal class, you first need to create an instance of an external class.

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 +
                '}';
    }
}

3, Local inner class

If a class is defined in the method body, it is called a local inner class.

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. A local inner class is defined locally in an outer class, usually in a method
2. You can directly access all members of an external class, including private
3. Access modifiers cannot be added, but final and abstract modifiers can be used
4. Scope: can only be in the method or code block that defines it
5. Local inner classes can directly access members of external classes

4, Anonymous inner class

You can instantiate a class while defining it. It is very similar to a local class. It has no class name. If you use a local class only once, you can use an anonymous inner class.
An anonymous class is an expression.

rule of grammar

new class/Interface(){

};

Implementation interface anonymous class

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();
}

Execution result anonymousnerclass.func

For the above code, there is a fun1 method in the anonymousnerclass class, which implements the interface anonymous class. This interface is essentially a subclass of the Io interface and overrides the methods in the interface. We all know that classes have their own names, so what is the name of this subclass?

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

Output result: anonymous innerclass$ 1@14ae5a5
We can see that the subclass name of anonymousnerclass $1 is automatically created by the bottom layer.

Anonymous subclass (inheriting parent class)

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");
    }
}

Execution result Book.b

Anonymous internal classes can access all external members, and cannot define static properties and methods. They can have constant properties (final modified properties), define properties, and have additional methods (parent interfaces and methods not in the class). They can define internal classes and instantiate other classes.