Java Basics: Inner Classes

1. Inner class concept

2. Member inner class

Member inner classes generally represent non-static modified inner classes

Static modified inner classes are generally called static inner classes

When using Outer.Inner oi = new Outer().new Inner(); to create an inner class, the address value Outer this of an outer class object will be automatically created in the inner class object in the heap memory.

3. Static inner class

As long as it is static, you can use (class name.) to get it. The same is true for static inner classes.

The new on the right side of the equation is used to represent Inner, not outer.

4. Local inner class

5. Anonymous inner class

In fact, it is more accurate to call the object of the anonymous inner class.

Classes that implement interfaces can also be assigned to interface classes (polymorphism), which is equivalent to subclasses that implement parent classes can also be assigned to parent classes.

The type of the created object mainly depends on the type after new on the right side of the equation

An anonymous inner class is a member inner class in a class, and a local inner class in a method

// 接口
package cn.ncepu.demo1.a02innerdemo2;

public interface Swim {
    public abstract void swim();
}


// 父类
package cn.ncepu.demo1.a02innerdemo2;

public abstract class Person implements Swim{
    @Override
    public void swim() {
        System.out.println("这是正常的类实现接口");
    }

    public abstract void eat();
}


// 子类
package cn.ncepu.demo1.a02innerdemo2;

public class Student extends Person {
    @Override
    public void eat() {
        System.out.println("老方法:创建一个子类来继承父类");
    }
}


// 测试类
package cn.ncepu.demo1.a02innerdemo2;

public class Test {
    public static void main(String[] args) {
        // 匿名内部类(接口)
        // 两个大括号之间真正代表了匿名内部类, Swim是接口的名字, new是创建该匿名内部类的对象
        // 所以实现接口需要重写所有抽象方法
        new Swim(){
            @Override
            public void swim() {
                System.out.println("这是匿名内部类的实现接口的方法");
            }
        };// 需要;号

        // 匿名内部类(类), 正常实现类是  类名 变量名 = new 类名();
        // 两个大括号之间真正代表了匿名内部类, Person是匿名内部类的父类的名字, new是创建该匿名内部类(子类)的对象
        // 所以继承父类需要重写所有抽象方法
        // 接口多态, p的类型主要看等式右边new表示的类型
        Person p = new Person(){

            @Override
            public void eat() {
                System.out.println("这是匿名内部类的继承父类的方法");
            }
        };

        // 所以可以用匿名类对象直接调用里面的方法
        p.eat();

        // 也可以在大括号之后直接调用
        new Person(){

            @Override
            public void eat() {
                System.out.println("这是匿名内部类的继承父类的方法");
            }
        }.eat();

        // 匿名内部类的使用场景(如:调用method方法)
        // 老方法
        Student student = new Student();
        method(student);

        // 新方法(用匿名内部类)
        // 当该子类只使用一次的情况下用匿名内部类
        method(
                new Person() {
                    @Override
                    public void eat() {
                        System.out.println("新方法:用匿名内部类, 省去了创建子类和对象的时间");
                    }
                }
        );
    }

    public static void method(Person person){
        person.eat();
    }
}