Noções básicas de Java: classes internas

1. Conceito de classe interna

2. Classe interna do membro

Classes internas de membro geralmente representam classes internas modificadas não estáticas

Classes internas modificadas estáticas são geralmente chamadas de classes internas estáticas

Ao usar Outer.Inner oi = new Outer().new Inner(), para criar uma classe interna, o valor de endereço Outer this de um objeto de classe externa será criado automaticamente no objeto de classe interna na memória heap.

3. Classe interna estática

Desde que seja estático, você pode usar (nome da classe.) para obtê-lo.O mesmo vale para classes internas estáticas.

O novo no lado direito da equação é usado para representar interno, não externo.

4. Classe interna local

5. Classe interna anônima

Na verdade, é mais correto chamar o objeto de classe interna anônima.

Classes que implementam interfaces também podem ser atribuídas a classes de interface (polimorfismo), o que é equivalente a subclasses que implementam classes pai também podem ser atribuídas a classes pai.

O tipo do objeto criado depende principalmente do tipo depois de novo no lado direito da equação

Uma classe interna anônima é uma classe interna membro em uma classe e uma classe interna local em um método

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