面向对象编程(Object-Oriented Programming)
面向对象编程把数据和操作数据的方法放进同一个对象里。它有三大特性:封装、继承和多态。封装管住对象的状态,继承让子类在父类的基础上扩展,多态让同一句调用按对象的实际类型执行不同的实现。
面试问到三大特性,只背出定义不够,要能用例子说明每个特性解决什么问题。设计类的时候,还要在接口、抽象类和组合之间做选择。
1. 面试核心
先记住这几条,再读正文- 封装就是只让对象自己的方法修改状态,修改前先检查,保证对象始终处在合法的状态。卡 · 封装
- 继承让子类复用父类的代码,并且可以当作父类型来用;前提是子类遵守父类型的约定。
- 多态是同一句调用按对象的实际类型执行不同的实现,背后的机制是动态分派。
- 重载和重写在不同阶段决定:重载在编译期按实参的静态类型选,重写在运行时按对象的实际类型选。卡 · 重载与重写
- 接口描述调用方需要的能力,抽象类可以共享状态和构造过程,组合则把一部分工作交给另一个可替换的对象。卡 · 接口、抽象类与组合
2. 封装
封装是把对象的数据设为私有,外部只能通过对象自己提供的方法读取和修改。这样,对象就能在每次修改前检查输入,保证自己的数据始终有效。
以银行账户为例,余额不能是负数。如果 balance 是公开字段,任何代码都能把它改成负数。下面的 Account 把 balance 设为 private,只通过构造器和 withdraw 修改它:
final class Account {
private long balance;
Account(long openingBalance) {
if (openingBalance < 0) {
throw new IllegalArgumentException("negative balance");
}
this.balance = openingBalance;
}
void withdraw(long amount) {
if (amount <= 0 || amount > balance) {
throw new IllegalArgumentException("invalid amount");
}
balance -= amount;
}
long balance() {
return balance;
}
}
构造器检查初始余额不能为负,withdraw 检查取款金额必须为正,而且不能超过余额。外部代码只能通过这两个方法修改余额,所以余额不会变成负数。如果再加一个不做检查的 setter,这些检查就被绕过了。
对象不变量是对象在任何时候都必须成立的条件,比如「余额不能为负」。封装要保证的,就是每一次修改都不会破坏它。
集合也有同样的问题。对象内部如果保存了一个可变集合,直接把它返回出去,调用方就能绕过对象去增删元素。一种做法是返回防御性副本,也就是新建一个集合并复制元素,调用方改的是副本,不影响对象内部的集合。另一种做法是返回不可修改视图,调用方不能通过它写入;但对象内部修改了底层集合时,视图里仍然能看到变化。
3. 继承
继承是让一个类在另一个类的基础上扩展:子类自动获得父类中可见的字段和方法,只需要写出自己不同的部分。下面的 Dog 和 Cat 都继承 Animal:
class Animal {
private final String name;
Animal(String name) {
this.name = name;
}
String introduce() {
return name + " says " + sound();
}
String sound() {
return "...";
}
}
class Dog extends Animal {
Dog(String name) {
super(name);
}
@Override
String sound() {
return "woof";
}
}
class Cat extends Animal {
Cat(String name) {
super(name);
}
@Override
String sound() {
return "meow";
}
}
Dog 没有声明 introduce,却可以直接调用,这是继承带来的复用。构造器不会被继承,所以 Dog 要自己声明构造器,再用 super(name) 交给父类初始化。Dog 和 Cat 还各自重新实现了 sound,这叫作重写,规则见 4.2 节。所以 new Dog("Buddy").introduce() 返回 Buddy says woof:introduce 来自 Animal,里面调用的 sound 执行的是 Dog 的版本。
继承同时表示「是一种」的关系:狗是一种动物,所以需要 Animal 的地方都可以传入 Dog。这有一个前提:父类型对方法的输入、输出和行为有约定,也叫契约,子类必须遵守。比如 sound 约定返回叫声,某个子类却返回 null,introduce 就会得到 Buddy says null。
如果两个类只是有几段代码相同,并不是「是一种」的关系,就不该为了复用代码而继承,第 5 节的组合更合适。
4. 多态
多态是指同一句方法调用,会根据对象的实际类型执行不同的实现。继续用上面的 Animal:
Animal[] animals = {new Dog("Buddy"), new Cat("Kitty")};
for (Animal animal : animals) {
System.out.println(animal.sound());
}
// woof
// meow
循环里写的都是 animal.sound(),变量类型也都是 Animal,狗和猫却发出了不同的声音。调用方不用判断「这是狗还是猫」,每个对象执行自己的实现。
静态类型是变量声明时写的类型,也叫编译时类型。这里 animal 的静态类型是 Animal,实际指向的对象是 Dog 或 Cat。编译时,编译器只看静态类型,确认 Animal 里有 sound 方法,就允许这次调用;运行时,Java 再按对象的实际类型选择要执行的方法。这个机制叫动态分派,也叫动态绑定。
实现接口也会建立「是一种」的关系,实际项目里的多态更多是通过接口来用的。下面的代码里,调用方只依赖 PricePolicy 接口,具体怎么打折交给实现类 DiscountPolicy:
interface PricePolicy {
long calculate(long originalPrice);
}
final class DiscountPolicy implements PricePolicy {
@Override
public long calculate(long originalPrice) {
return originalPrice * 80 / 100;
}
}
PricePolicy policy = new DiscountPolicy();
long price = policy.calculate(1_000); // 800
policy.calculate(1_000) 执行的是 DiscountPolicy 的实现,所以 price 是 800。调用方只依赖 PricePolicy,以后换一种折扣算法,调用方的代码不用改。这就是多态在工程上的价值。
4.1 静态绑定与成员隐藏
动态分派只对可重写的实例方法生效。下面几种成员在编译时就确定了,不看对象的实际类型:
- 字段:访问哪个字段,由引用的静态类型决定。父类和子类有同名字段时,通过父类型的变量访问,拿到的是父类的字段。
- 静态方法:属于类本身。子类声明同名的静态方法不算重写,而是把父类的方法隐藏起来,调用哪个同样看静态类型。
private方法:子类继承不到,也就谈不上重写。final方法:子类不能重写,执行的始终是父类的实现。
4.2 重载与重写
重载是指几个方法名字相同、参数列表不同,比如下面两个 print:
void print(String value) {}
void print(Object value) {} // 重载
调用 print(x) 时,编译器根据 x 的静态类型挑出最匹配的版本,这一步在编译期就定下来了。只改返回类型不算重载,因为编译器靠方法名和参数类型来区分方法。
重写是子类重新实现父类型里签名相同的实例方法,前面的 Dog.sound 和 DiscountPolicy.calculate 都是例子。重写的方法要能顶替原来的方法:原来调用父类方法、处理它的返回值和异常的代码,换成子类之后仍然要能正常工作。所以重写有三条限制:
- 返回类型可以更具体,也就是协变返回类型(covariant return type):子类方法的返回类型,可以是父类方法返回类型的子类型。比如父类方法返回
Animal,子类重写时可以返回Dog,因为调用方拿到Dog也能当Animal用。这条只适用于引用类型;返回基本类型时,必须和父类方法完全一致。 - 访问权限不能缩小。父类方法是
public,子类重写后也必须是public,否则原来能调用它的代码就调用不了了。 - 受检异常不能变宽。子类方法不能抛出父类方法没有声明的受检异常,只能少抛,或者抛更具体的子类异常,这样调用方原来的
catch仍然够用。
5. 接口、抽象类与组合
接口、抽象类和组合解决的问题不同:接口描述调用方需要的能力,抽象类让子类共享状态和流程,组合把一部分工作交给可替换的对象。三者的对比如下:
| 方式 | 适合表达 | 主要限制 |
|---|---|---|
| 接口 | 调用方依赖的能力或协议 | 实例状态由实现类保存 |
| 抽象类 | 同一类对象共享的状态、构造过程或模板流程 | Java 只有单类继承,子类与基类耦合较强 |
| 组合 | 一个对象使用可替换的策略或协作者 | 需要显式转发调用和管理依赖 |
一个类可以实现多个接口,但只能继承一个类,这是选择时最直接的限制。接口里除了抽象方法,还可以写下面几种方法:
- 抽象方法:没有方法体,由实现类实现。
default方法:带默认实现。给已有接口加新方法时,旧的实现类不用修改也能继续使用。- 静态方法:属于接口本身,用接口名调用。
private方法:只给接口内部的其他方法复用代码。
组合是另一种思路:不继承谁,而是把另一个对象作为字段保存起来,需要时把工作交给它。比如订单服务要算价格,它不继承任何计价类,而是持有一个 PricePolicy:
final class OrderService {
private final PricePolicy policy;
OrderService(PricePolicy policy) {
this.policy = policy;
}
long quote(long originalPrice) {
return policy.calculate(originalPrice);
}
}
OrderService 通过构造器拿到一个 PricePolicy,quote 里直接调用 policy.calculate。想换一种报价规则,传入另一个 PricePolicy 实现即可,OrderService 本身不用改。
所以,如果会变的只是计价、存储、通知这类可替换的策略,接口加组合更灵活。多个子类确实要共享字段和固定的处理流程时,再考虑抽象类。
6. 重载选择与动态分派
重载和重写同时出现时,把两步分开看:先在编译期按实参的静态类型选出方法签名,再在运行时按接收者的实际类型,找到这个签名的实现。接收者就是调用时点号前面的对象,下例中是 service。
class Parent {
String show(Object value) { return "parent-object"; }
String show(String value) { return "parent-string"; }
}
class Child extends Parent {
@Override
String show(Object value) { return "child-object"; }
}
Parent service = new Child();
Object value = "java";
System.out.println(service.show(value)); // child-object
value 实际是一个字符串,但它的静态类型是 Object,所以编译期选中的是 show(Object),而不是 show(String)。运行时,service 实际指向 Child,于是执行 Child 重写的 show(Object),输出 child-object。
接口的默认方法和其他方法签名相同时,用哪一个按下面的规则决定:
- 类里的方法优先:父类有具体的实例方法时,用父类的,接口默认方法不生效。
- 更具体的接口优先:子接口的默认方法覆盖父接口的默认方法。
- 分不出先后时必须自己选:两个互不相关的接口提供了相同的默认方法,实现类必须重写这个方法,否则无法通过编译。
7. 常见问题
7.1 有 getter 和 setter 就完成封装了吗?
不一定。getter 和 setter 只是换了一种访问字段的方式。如果 setter 什么值都接受,调用方仍然能把余额设成负数。封装有没有起作用,要看修改状态的入口有没有做检查。
7.2 什么时候选择组合,什么时候选择继承?
看会变的是什么。会变的是计价规则这类策略,用组合,换一个对象即可;子类和父类之间确实是「一种」的关系,并且能遵守父类的约定,才用继承。几个子类还共享字段和固定流程时,再把共享部分放进抽象基类。
7.3 为什么频繁向下转型会增加调用方的修改成本?
向下转型是把父类型引用强制转成具体的子类型。如果调用方每次都要先判断对象是哪种子类,再转型调用,说明父类型没有提供调用方需要的操作。这样每新增一种子类,调用方就要多加一个判断分支,要改的地方会随子类数量一起增加。
8. 面试题卡片
9. 参考资料
- dev.java:Object-Oriented Programming Concepts
- dev.java:Interfaces
- Java Language Specification:Classes
- Java Language Specification:Interfaces
- Java Language Specification:Method Invocation Expressions
来源:Coding 101 原文 · 免费阅读,引用请保留出处。内容使用说明