Java —— 内部类

Java内部类

1.什么是内部类？

将一个类A定义在另一个类B里面，里面的类A就称为内部类（InnerClass），类B则称为外部类（OuterClass）。

2.为什么需要内部类？

具体来说，当一个事物A的内部，还有一个部分需要一个完整的结构B进行描述，
而这个完整的结构B又只为外部事物A提供服务，不在其他地方单独使用，
那么这个内部的完整的结构B最好使用内部类。

3.内部类使用举例

• Thread类内部声明了State类(只有Thread用，其他类不用)，表示线程的生命周期
• HashMap类中声明了Node类（只有HashMap用，设计在内部，内部类），表示封装的key和value

4.内部类的分类（参考变量的分类）

• 成员内部类：直接声明在外部类的里面

  • 使用static修饰的：静态的成员内部类
  • 不使用static修饰的：非静态的成员内部类

• 局部内部类：声明在方法内，构造器内，代码块内的内部类

  • 匿名的局部内部类
  • 非匿名的局部内部类

5.内部类需要理解的知识

• 成员内部类（常用）的理解
• 如何创建成员内部类的实例
• 如何在成员内部类中调用外部类的结构
• 局部内部类的基本使用

6.关于成员内部类的理解

• 从类的角度看

  内部可以声明属性、方法、构造器、代码块、内部类等结构

  此内部类可以声明父类、可以实现接口

  可以使用final修饰（此内部类不能再有子类）

  可以使用abstract修饰

• 从外部类的成员的角度看（似成员变量）

  在内部可以调用外部类的结构。如属性、方法等

  除了使用public、缺省权限修饰之外，还可以使用private、protected修饰（似成员变量）

  可以使用static修饰

7.关于局部内部类的说明

直接在方法内声明类、抽象类、接口的实现类，体现匿名实现类、匿名对象。

局部内部类：声明在方法内，构造器内，代码块内的内部类

• 匿名的局部内部类
• 非匿名的局部内部类

public class OuterClassTest2 {
    public static void main(String[] args) {

        //接口类A：标准写法
        SubA a = new SubA();
        a.method();

        //举例1：提供接口匿名实现类的对象
        A a1 = new A(){
            @Override
            public void method() {
                System.out.println("接口匿名实现类重写的方法method()");
            }
        };

        a1.method();

        //举例2：提供接口匿名实现类的匿名对象
        new A(){
            @Override
            public void method() {
                System.out.println("接口匿名实现类重写的方法method()");
            }
        }.method();

        System.out.println("----------------------------------------------------");

        //抽象类B：标准写法
        SubB s1 = new SubB();
        s1.method1();

        //举例1：继承于抽象类的匿名子类的对象  类名：OuterClassTest2$3
        B b = new B(){
            @Override
            public void method1() {   //实现抽象方法
                System.out.println("继承于抽象类的子类调用的方法1");
            }
        };
        b.method1();
        System.out.println("b.getClass() = " + b.getClass());  //b.getClass() = class com.atguigu09.inner.OuterClassTest2$3
        System.out.println("b.getClass().getSuperclass() = " + b.getClass().getSuperclass()); //b.getClass().getSuperclass() = class com.atguigu09.inner.B

        //举例2：
        new B(){
            @Override
            public void method1() {  //重写抽象方法
                System.out.println("继承于抽象类的匿名子类调用的方法1");
            }
        }.method1();

        System.out.println("----------------------------------------------------------");

        //普通类C：标准写法
        C c = new C();
        c.method2();
        System.out.println("c.getClass() = " + c.getClass());
        System.out.println("c.getClass().getSuperclass() = " + c.getClass().getSuperclass());

        //举例1：提供了一个继承于C的匿名子类的对象
        C c1 = new C(){};//没有重写method2()
        c1.method2();
        System.out.println("c1.getClass() = " + c1.getClass());
        System.out.println("c1.getClass().getSuperclass() = " + c1.getClass().getSuperclass());

        //举例2：提供继承于C的匿名子类的匿名对象
        new C(){
            @Override
            public void method2() {  //重写method2()
                System.out.println("重写C");
            }
        }.method2();

    }
}

//接口A
interface A{
    public void method();
}

//抽象类B
abstract class B{
    public abstract void method1();
}

//普通类C
class C{
    public void method2(){
        System.out.println("C");
    }
}



//实现类已知，非匿名，对应标准写法
class SubA implements A{
    @Override
    public void method() {
        System.out.println("接口A的方法实现");
    }
}

//子类已知，非匿名，对应标准写法
class SubB extends B{

    @Override
    public void method1() {
        System.out.println("抽象B的方法实现");
    }
}