什么是内部类?
前面学习类时,接触过成员变量、成员方法、构造方法和代码块。除此之外,我们还可以在一个类的内部再定义一个类,这个定义在里面的类就叫作内部类。
例如,在 Outer 类中定义 Inner 类:
public class Outer {
public class Inner {
}
}这里的 Outer 是外部类,Inner 是内部类。
为什么要使用内部类?
假如现在要写一个 Car 类描述汽车,需要记录汽车的品牌、车龄、颜色,以及发动机的品牌和使用年限。
最直接的写法,就是把这些内容全部定义成 Car 的成员变量:
public class Car {
String carName;
int carAge;
String carColor;
String engineName;
int engineAge;
}这样当然能存储数据。不过仔细想想,发动机本身也是一个部件,有自己的品牌和使用年限。如果把发动机的信息单独放在一个 Engine 类里,结构会更清楚。
那要不要直接在外面定义一个独立的 Engine 类呢?也可以。不过在这个例子中,我们主要是想通过汽车来管理发动机的信息,于是可以把 Engine 定义在 Car 内部:
public class Car {
String carName;
int carAge;
String carColor;
class Engine {
String engineName;
int engineAge;
}
}这样一看就知道,Engine 是和 Car 联系在一起的。当一个类主要是为了配合另一个类使用时,就可以考虑使用内部类。 但这不是说发动机只能写成内部类,具体还是要看实际需求。
内部类主要分为四种:成员内部类、静态内部类、局部内部类和匿名内部类。先了解前三种的写法,重点看看最后的匿名内部类是怎么使用的。
成员内部类
像上面写在 Car 成员位置的 Engine,就是一个成员内部类。它和普通成员变量、成员方法一样,都定义在类里面、方法外面。
内部类和外部类如何访问成员?
成员内部类有两个比较方便的地方:
- 内部类可以直接访问外部类的成员,即使是
private修饰的成员也可以。 - 外部类访问内部类的实例成员时,需要先有内部类对象,然后通过对象访问。
还是用汽车和发动机来看:
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()。但如果想在其他类中创建成员内部类对象,就需要知道它属于哪个外部类对象。
常见的写法有两种:
第一种:让外部类提供一个方法,返回内部类对象。
第二种:先有外部类对象,再通过它创建内部类对象。
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();
}
}输出:
我是内部类
我是内部类第二种写法也可以记成:
外部类名.内部类名 对象名 = 外部类对象.new 内部类名();如果成员内部类被 private 修饰呢?
前面的 Inner 没有使用 private 修饰,所以我们可以在测试类中写 Outer.Inner,直接声明变量或创建对象。
但如果把它改成 private class Inner,情况就不一样了。private 表示这个内部类只能在外部类允许的范围内使用。 对于测试类来说,Inner 虽然确实存在,但我们没有权限直接使用它的类名,所以不能再写 Outer.Inner i = ...。
那如果 Outer 已经提供了 getInstance(),能不能把它创建的内部类对象返回出来呢?可以。这里正好可以联系到前面学过的多态。
我们知道,Java 中如果一个类没有显式继承其他类,它默认继承 Object。Inner 也是如此,因此 Inner 对象也可以交给 Object 类型的变量接收。
来看一段完整的代码:
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 方法这里可以一步一步理解:
Outer内部可以创建Inner对象,因为它本身能够访问自己的私有内部类。- 测试类不能写
Outer.Inner,因为Inner是private的。但Inner默认继承Object,所以Object obj = o.getInstance();没有问题。接收成功,并不意味着外部就能直接使用Inner这个类型。 obj虽然实际指向Inner对象,但它声明的类型是Object。如果写obj.show(),编译器先检查Object有没有show(),发现没有,就会报错。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.变量名:
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()。
Outer.Inner i = new Outer.Inner();静态内部类可以直接访问外部类的静态成员;如果要访问外部类的普通成员变量或普通成员方法,就需要先有外部类对象。
例如:
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.方法名()。
局部内部类
前面两种内部类都写在成员位置。如果把类定义在一个方法里面,就叫作局部内部类,位置上和局部变量有点像。
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 接口,只是想临时写一段游泳功能。如果专门创建一个类去实现接口,写完可能只用一次,就有点麻烦。这时候可以直接使用匿名内部类。
基本写法
匿名内部类常见的格式是:
new 类名或接口名() {
// 重写需要的方法
};例如:
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() 时写一个匿名内部类就行了:
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();
}输出:
狗吃骨头这里可以分开看:
new Animal() { ... }临时创建了一个继承Animal的匿名子类对象,并重写eat()。- 这个对象被直接传给
method(Animal a)。因为它本身就是Animal的子类对象,所以可以用Animal类型接收。 method()中执行a.eat(),调用的就是匿名子类重写后的eat()。
这和前面学习的多态正好联系起来了:参数写的是父类类型,实际传入的是子类对象,因此会执行子类重写后的方法。
如果使用匿名内部类,就不用额外定义一个只会使用一次的 Dog 类。接口也可以按同样的思路使用:当方法接收一个接口类型的参数时,可以直接传入实现该接口的匿名内部类对象。
当然,如果某个实现需要在很多地方重复使用,单独定义一个有名字的类会更合适。
内部类这一部分先记住各自最常见的用法即可:成员内部类与外部类对象关联;静态内部类可以直接通过外部类名创建;局部内部类定义在方法等局部位置;匿名内部类适合临时提供某个类或接口的实现,尤其是只使用一次的情况。
聊两句
评论审核后显示有疑问、补充,或者想交流一下,都可以写在这里。
评论区将在滚动到这里时加载。