什么是内部类?

前面学习类时,接触过成员变量、成员方法、构造方法和代码块。除此之外,我们还可以在一个类的内部再定义一个类,这个定义在里面的类就叫作内部类。

例如,在 Outer 类中定义 Inner 类:

java
public class Outer {
    public class Inner {
    }
}

这里的 Outer 是外部类,Inner 是内部类。

为什么要使用内部类?

假如现在要写一个 Car 类描述汽车,需要记录汽车的品牌、车龄、颜色,以及发动机的品牌和使用年限。

最直接的写法,就是把这些内容全部定义成 Car 的成员变量:

java
public class Car {
    String carName;
    int carAge;
    String carColor;
    String engineName;
    int engineAge;
}

这样当然能存储数据。不过仔细想想,发动机本身也是一个部件,有自己的品牌和使用年限。如果把发动机的信息单独放在一个 Engine 类里,结构会更清楚。

那要不要直接在外面定义一个独立的 Engine 类呢?也可以。不过在这个例子中,我们主要是想通过汽车来管理发动机的信息,于是可以把 Engine 定义在 Car 内部:

java
public class Car {
    String carName;
    int carAge;
    String carColor;

    class Engine {
        String engineName;
        int engineAge;
    }
}

这样一看就知道,Engine 是和 Car 联系在一起的。当一个类主要是为了配合另一个类使用时,就可以考虑使用内部类。 但这不是说发动机只能写成内部类,具体还是要看实际需求。

内部类主要分为四种:成员内部类、静态内部类、局部内部类和匿名内部类。先了解前三种的写法,重点看看最后的匿名内部类是怎么使用的。

成员内部类

像上面写在 Car 成员位置的 Engine,就是一个成员内部类。它和普通成员变量、成员方法一样,都定义在类里面、方法外面。

内部类和外部类如何访问成员?

成员内部类有两个比较方便的地方:

  • 内部类可以直接访问外部类的成员,即使是 private 修饰的成员也可以。
  • 外部类访问内部类的实例成员时,需要先有内部类对象,然后通过对象访问。

还是用汽车和发动机来看:

java
public class Test1 {
    public static void main(String[] args) {
        Car c = new Car("宝马");
        c.show();
    }
}

class Car {
    private String carName;
    private int carAge;
    private String carColor;

    public Car(String carName) {
        this.carName = carName;
    }

    class Engine {
        private String engineName = "发动机A";
        private int engineAge = 2;

        public void show() {
            // 直接访问内部类自己的成员变量
            System.out.println("发动机使用年限:" + engineAge);
            // 也能直接访问外部类的 private 成员变量
            System.out.println("所属汽车:" + carName);
        }
    }

    public void show() {
        System.out.println("汽车品牌:" + carName);

        // 不能在这里直接写 engineName,得先创建 Engine 对象
        Engine e = new Engine();
        System.out.println("发动机品牌:" + e.engineName);
        e.show();
    }
}

输出:

纯文本
汽车品牌:宝马
发动机品牌:发动机A
发动机使用年限:2
所属汽车:宝马

注意,carName 虽然是 Car 的私有成员,但 Engine 中的 show() 依然可以直接访问它。而 Car 想读取 Engine 对象中的 engineName,就需要先创建 Engine 对象,再通过 e.engineName 访问。

如何创建成员内部类对象?

如果是在外部类自己的普通成员方法里,可以直接写 new Inner()。但如果想在其他类中创建成员内部类对象,就需要知道它属于哪个外部类对象。

常见的写法有两种:

第一种:让外部类提供一个方法,返回内部类对象。

第二种:先有外部类对象,再通过它创建内部类对象。

java
public class Test1 {
    public static void main(String[] args) {
        Outer o = new Outer();

        // 方式一:通过外部类的方法获得内部类对象
        Outer.Inner i1 = o.getInstance();
        i1.show();

        // 方式二:通过外部类对象创建内部类对象
        Outer.Inner i2 = o.new Inner();
        i2.show();

        // 也可以合起来写:new Outer().new Inner()
    }
}

class Outer {
    class Inner {
        public void show() {
            System.out.println("我是内部类");
        }
    }

    public Inner getInstance() {
        return new Inner();
    }
}

输出:

纯文本
我是内部类
我是内部类

第二种写法也可以记成:

java
外部类名.内部类名 对象名 = 外部类对象.new 内部类名();

如果成员内部类被 private 修饰呢?

前面的 Inner 没有使用 private 修饰,所以我们可以在测试类中写 Outer.Inner,直接声明变量或创建对象。

但如果把它改成 private class Inner,情况就不一样了。private 表示这个内部类只能在外部类允许的范围内使用。 对于测试类来说,Inner 虽然确实存在,但我们没有权限直接使用它的类名,所以不能再写 Outer.Inner i = ...。

那如果 Outer 已经提供了 getInstance(),能不能把它创建的内部类对象返回出来呢?可以。这里正好可以联系到前面学过的多态。

我们知道,Java 中如果一个类没有显式继承其他类,它默认继承 Object。Inner 也是如此,因此 Inner 对象也可以交给 Object 类型的变量接收。

来看一段完整的代码:

java
public class Test1 {
    public static void main(String[] args) {
        Outer o = new Outer();

        // Inner 被 private 修饰,外部不能直接使用这个类型
        // Outer.Inner i = o.getInstance(); // 编译报错

        // 但 Inner 继承自 Object,可以用 Object 接收返回的对象
        Object obj = o.getInstance();

        // Object 中没有 show(),所以不能直接调用
        // obj.show(); // 编译报错

        // Object 中有 toString(),因此可以调用
        System.out.println(obj.toString());

        // 如果只是想执行 Inner 的 show(),可以让 Outer 帮忙调用
        o.showInner();
    }
}

class Outer {
    private class Inner {
        public void show() {
            System.out.println("内部类的 show 方法");
        }

        @Override
        public String toString() {
            return "我是 Inner 对象";
        }
    }

    // Outer 自己可以使用私有内部类,也可以把对象返回出去
    public Inner getInstance() {
        return new Inner();
    }

    public void showInner() {
        Inner i = new Inner();
        i.show();
    }
}

输出:

纯文本
我是 Inner 对象
内部类的 show 方法

这里可以一步一步理解:

  1. Outer 内部可以创建 Inner 对象,因为它本身能够访问自己的私有内部类。
  2. 测试类不能写 Outer.Inner,因为 Inner 是 private 的。但 Inner 默认继承 Object,所以 Object obj = o.getInstance(); 没有问题。接收成功,并不意味着外部就能直接使用 Inner 这个类型。
  3. obj 虽然实际指向 Inner 对象,但它声明的类型是 Object。如果写 obj.show(),编译器先检查 Object 有没有 show(),发现没有,就会报错。
  4. obj.toString() 却能调用,因为 Object 本来就有 toString()。而 Inner 重写了这个方法,所以实际运行时执行的是 Inner 中的版本,输出“我是 Inner 对象”。

这不正好对应前面多态的规则吗?调用实例方法时,编译先看左边声明的类型有没有这个方法;如果这个方法被子类重写,运行时再根据实际对象调用对应的版本。

所以这里最关键的是:Object 能接收 Inner 对象,不代表通过 Object 变量就能调用 Inner 自己新增的所有方法。

那如果外部确实需要执行 Inner 特有的 show() 呢?一种简单的办法,就是像上面那样,在 Outer 中提供公开的 showInner() 方法。Outer 自己可以创建 Inner 对象并调用 show(),外部只需要写 o.showInner()。如果只是想使用内部类的某个功能,这样比把内部类直接交给外部更方便。

另外还有一个版本上的细节:JDK 16 起,成员内部类可以定义普通静态成员。在更早的版本中,这方面有限制,但符合条件的 static final 常量是例外。现阶段主要掌握成员内部类的创建和访问方式就可以了。

内外部类有同名变量怎么办?

如果内部类和外部类都定义了 name,那么在内部类中直接写 name,会优先使用内部类的成员变量。

想明确访问外部类的 name,可以使用 外部类名.this.变量名:

java
class Outer {
    String name = "外部类";

    class Inner {
        String name = "内部类";

        public void show() {
            System.out.println(this.name);       // 内部类
            System.out.println(Outer.this.name); // 外部类
        }
    }
}

可以简单理解为:this.name 找当前内部类对象中的 name,Outer.this.name 找与它关联的外部类对象中的 name。

静态内部类

如果在成员内部类前面加上 static,就成了我们常说的静态内部类。

它和前面的成员内部类有一个明显区别:静态内部类不需要依附于某个外部类对象,所以创建时不用先 new Outer()。

java
Outer.Inner i = new Outer.Inner();

静态内部类可以直接访问外部类的静态成员;如果要访问外部类的普通成员变量或普通成员方法,就需要先有外部类对象。

例如:

java
public class Test1 {
    public static void main(String[] args) {
        Outer.Inner i = new Outer.Inner();
        i.show();

        // 静态方法直接用类名调用
        Outer.Inner.test();
    }
}

class Outer {
    static String message = "外部类的静态变量";
    String name = "外部类的普通变量";

    static class Inner {
        public void show() {
            System.out.println(message);

            // 要访问外部类的普通成员,先创建外部类对象
            Outer o = new Outer();
            System.out.println(o.name);
        }

        public static void test() {
            System.out.println("静态内部类的静态方法");
        }
    }
}

输出:

纯文本
外部类的静态变量
外部类的普通变量
静态内部类的静态方法

这里主要记住两种调用方式:普通方法先创建对象,再用对象调用;静态方法可以直接写 Outer.Inner.方法名()。

局部内部类

前面两种内部类都写在成员位置。如果把类定义在一个方法里面,就叫作局部内部类,位置上和局部变量有点像。

java
class Outer {
    public void method() {
        int num = 10;

        class Inner {
            public void show() {
                System.out.println(num);
            }
        }

        Inner i = new Inner();
        i.show();
    }
}

这里的 Inner 定义在 method() 里面,所以只能在它的作用域内使用,方法外面不能直接写 new Inner()。

局部内部类能够访问外部类的成员,也能访问方法中符合条件的局部变量。例如上面的 num 没有在后面重新赋值,就可以直接在 Inner 中使用。

局部内部类先了解这种写法即可。

匿名内部类

前三种内部类都有明确的类名,而匿名内部类没有自己写出来的类名。

为什么需要它呢?例如我们已经定义了一个 Swim 接口,只是想临时写一段游泳功能。如果专门创建一个类去实现接口,写完可能只用一次,就有点麻烦。这时候可以直接使用匿名内部类。

基本写法

匿名内部类常见的格式是:

java
new 类名或接口名() {
    // 重写需要的方法
};

例如:

java
public class Test1 {
    public static void main(String[] args) {
        new Swim() {
            @Override
            public void swim() {
                System.out.println("重写了游泳方法");
            }
        }.swim();
    }
}

interface Swim {
    void swim();
}

输出:

纯文本
重写了游泳方法

注意这里最后的 .swim():前面的 new Swim() { ... } 已经创建了一个对象,但只是创建对象,并不会自动执行 swim();想打印内容,还需要调用这个方法。

看到 new Swim() 可能会有点疑惑:接口不是不能直接创建对象吗?其实这里创建的不是 Swim 接口本身的对象,而是一个实现了 Swim 的匿名内部类对象。只不过这个实现类没有单独取名字,我们直接把它的实现写在了这里。

可以把它理解为几件事一起完成了:实现接口(或者继承一个类)、重写需要的方法、创建对象。

匿名内部类作为方法参数

匿名内部类一个很方便的用途,就是作为参数直接传给方法。

假如有一个 method(Animal a),它会调用传入对象的 eat() 方法。按照前面学过的写法,我们可以先定义一个 Dog 类继承 Animal,重写 eat(),然后创建 Dog 对象传进去。

但如果这段实现只准备使用一次,直接在调用 method() 时写一个匿名内部类就行了:

java
public class Test1 {
    public static void main(String[] args) {
        method(new Animal() {
            @Override
            public void eat() {
                System.out.println("狗吃骨头");
            }
        });
    }

    public static void method(Animal a) {
        a.eat();
    }
}

abstract class Animal {
    public abstract void eat();
}

输出:

纯文本
狗吃骨头

这里可以分开看:

  1. new Animal() { ... } 临时创建了一个继承 Animal 的匿名子类对象,并重写 eat()。
  2. 这个对象被直接传给 method(Animal a)。因为它本身就是 Animal 的子类对象,所以可以用 Animal 类型接收。
  3. method() 中执行 a.eat(),调用的就是匿名子类重写后的 eat()。

这和前面学习的多态正好联系起来了:参数写的是父类类型,实际传入的是子类对象,因此会执行子类重写后的方法。

如果使用匿名内部类,就不用额外定义一个只会使用一次的 Dog 类。接口也可以按同样的思路使用:当方法接收一个接口类型的参数时,可以直接传入实现该接口的匿名内部类对象。

当然,如果某个实现需要在很多地方重复使用,单独定义一个有名字的类会更合适。

内部类这一部分先记住各自最常见的用法即可:成员内部类与外部类对象关联;静态内部类可以直接通过外部类名创建;局部内部类定义在方法等局部位置;匿名内部类适合临时提供某个类或接口的实现,尤其是只使用一次的情况。

谢谢你读到这里。 ✧

聊两句

评论审核后显示

有疑问、补充,或者想交流一下,都可以写在这里。

评论区将在滚动到这里时加载。