Java作为纯面向对象编程语言,其本质在于将现实世界抽象为类与对象的集合。面向对象编程(OOP)并非仅是语法结构,更是一种思维方式的革新:以对象为中心组织数据与行为,通过封装隐藏细节、通过继承复用逻辑、通过多态实现扩展。
类是对象的模板,是数据(属性)与行为(方法)的封装体。但需注意:类本身不占用运行时内存,仅在JVM中生成Class对象时才完成元数据加载。一个标准类定义应包含:
例如:
public class User {
private String name;
private int age;
public User(String name, int age) {
this.name = name;
this.age = age;
}
public void introduce() {
System.out.println("我是" + name + ",今年" + age + "岁");
}
}
此处的private修饰符体现了封装性——将内部状态保护起来,防止外部随意篡改。若直接暴露字段,可能导致对象处于非法状态(如年龄为负数)。正确做法是提供受控的getter与setter方法。
对象通过new关键字在堆内存中分配空间,由JVM垃圾回收器(GC)自动管理其生命周期。对象的创建过程分为三步:
示例:
User user = new User("张三", 25);
此语句中,user是栈上的引用变量,指向堆中的User实例。若不再有引用指向该对象,GC将在适当时机回收其内存。
封装的核心目标是“高内聚、低耦合”。具体实践包括:
例如,设计一个Money类:
public final class Money {
private final int cents;
public Money(int dollars, int cents) {
if (cents < 0 || cents >= 100) throw new IllegalArgumentException(" cents must be 0-99");
this.cents = dollars * 100 + cents;
}
public int getDollars() { return cents / 100; }
public int getCents() { return cents % 100; }
public Money add(Money other) {
return new Money(0, this.cents + other.cents);
}
}
该类通过final保证不可变性,字段私有化并校验输入,确保对象始终处于合法状态。此类设计在金融系统中尤为重要。
继承用于表达“is-a”关系(如猫是动物),而非“has-a”(如汽车有引擎)。错误继承会导致设计僵化。例如:
❌ 错误设计:
class Stack extends ArrayList {}
问题在于:Stack是ArrayList的特化吗?实际上,栈应基于数组或链表实现,但不应继承其全部接口。这违反了里氏替换原则(LSP)——子类对象无法替代父类对象而不破坏系统逻辑。
✅ 正确设计(组合优于继承):
class Stack {
private final List list = new ArrayList<>();
public void push(T item) { list.add(item); }
public T pop() { return list.remove(list.size()-1); }
public int size() { return list.size(); }
}
通过组合复用ArrayList功能,同时严格限制对外暴露的方法,确保行为符合栈语义。
多层继承链(如A→B→C→D)会导致:
实践中应控制继承深度在2~3层以内。若需复用功能,优先考虑接口+组合方式。
super不仅用于调用父类构造方法,还可访问被隐藏的父类字段或方法:
class Animal {
String name = "动物";
void speak() { System.out.println("动物发声"); }
}
class Dog extends Animal {
String name = "狗";
void speak() {
super.speak(); // 调用父类方法
System.out.println("汪汪");
}
void printName() {
System.out.println("子类名:" + name);
System.out.println("父类名:" + super.name);
}
}
输出结果:
子类名:狗
父类名:动物
当子类定义同名字段时,super可明确访问父类成员,避免歧义。
实现多态需满足:
示例:
Animal animal = new Dog(); // 向上转型
animal.speak(); // 运行时调用Dog.speak()
注意:方法调用在编译期绑定声明类型(Animal),在运行期绑定实际对象类型(Dog)——即动态绑定机制。
Java SPI(Service Provider Interface)是多态的典型应用。以JDBC为例:
public interface Driver {
Connection connect(String url, Properties info) throws SQLException;
}
// MySQL实现
public class MysqlDriver implements Driver {
public Connection connect(...) { }
}
// 加载机制
Class.forName("com.mysql.cj.jdbc.Driver"); // 触发静态注册
Connection conn = DriverManager.getConnection(url, user, pwd); // 多态调用
驱动类通过静态代码块将自身注册到DriverManager,最终通过统一接口获取连接,实现解耦。
多态是开闭原则(OCP)的实现基础:对扩展开放,对修改关闭。例如:
❌ 未使用多态:
void draw(Shape shape) {
if (shape.type == CIRCLE) circle.draw();
else if (shape.type == RECTANGLE) rect.draw();
}
❌ 新增三角形需修改方法,违反OCP。
✅ 使用多态:
abstract class Shape {
abstract void draw();
}
void draw(Shape shape) { shape.draw(); } // 所有子类自动支持
新增Triangle只需继承Shape并实现draw,无需修改调用逻辑。
抽象类用于定义部分实现的模板,适用于:
示例:
public abstract class Logger {
protected String level;
public void log(String message) {
if (shouldLog()) doLog(format(message));
}
protected abstract boolean shouldLog();
protected abstract void doLog(String formatted);
private String format(String msg) { return "[" + level + "] " + msg; }
}
public class FileLogger extends Logger {
protected boolean shouldLog() { return true; }
protected void doLog(String msg) { Files.write(path, msg.getBytes()); }
}
抽象类Logger封装了通用日志逻辑,子类仅需实现差异部分。
Java 8后接口支持默认方法(default)和静态方法,解决了接口演进难题:
问题:若接口新增方法,所有实现类必须修改——破坏兼容性。
解决:使用默认方法提供默认实现:
public interface Iterable {
default void forEach(Consumer super T> action) {
Objects.requireNonNull(action);
for (T t : this) action.accept(t);
}
}
原有实现类无需修改即可获得forEach能力,实现接口的平滑演进。
避免设计“大而全”的接口(如Serializable+Cloneable+Comparable)。推荐小接口组合:
❌ 反例:
interface Worker {
void work();
void eat();
void sleep();
}
✅ 正确做法:
interface Worker { void work(); }
interface Eater { void eat(); }
interface Sleeper { void sleep(); }
class Human implements Worker, Eater, Sleeper {}
class Robot implements Worker {} // 无需实现eat/sleep
符合接口隔离原则(ISP):客户端不应依赖其不需要的接口。
定义创建对象的接口,让子类决定实例化哪个类。典型应用:Java集合框架。
示例:
interface Button { void render(); }
class WindowsButton implements Button { ... }
class MacButton implements Button { ... }
interface Dialog {
Button createButton();
}
class WindowsDialog implements Dialog {
public Button createButton() { return new WindowsButton(); }
}
class MacDialog implements Dialog {
public Button createButton() { return new MacButton(); }
}
客户端代码:
Dialog dialog = new WindowsDialog(); // 或MacDialog
Button button = dialog.createButton();
button.render(); // 多态调用
新增Linux支持只需添加LinuxButton和LinuxDialog,无需修改现有代码。
用于复杂对象构建,避免 telescoping constructor 模式。例如StringBuilder的链式调用:
示例:
public class Pizza {
private final int size;
private final boolean cheese;
private final boolean pepperoni;
public static class Builder {
private int size;
private boolean cheese = false;
private boolean pepperoni = false;
public Builder(int size) { this.size = size; }
public Builder cheese(boolean val) { cheese = val; return this; }
public Builder pepperoni(boolean val) { pepperoni = val; return this; }
public Pizza build() { return new Pizza(this); }
}
private Pizza(Builder builder) {
size = builder.size;
cheese = builder.cheese;
pepperoni = builder.pepperoni;
}
}
使用:
Pizza pizza = new Pizza.Builder(12)
.cheese(true)
.pepperoni(true)
.build();
优势:可读性强,参数可选,避免多构造器爆炸。
动态给对象添加功能,比继承更灵活。I/O流是经典案例:
示例:
InputStream in = new BufferedInputStream(
new FileInputStream("data.txt"));
BufferedInputStream包装FileInputStream,增强缓冲能力,而无需修改原类。
定义算法族,动态切换算法。例如排序中的Comparator:
示例:
class Person { String name; int age; }
List list = Arrays.asList(
new Person("张三", 25),
new Person("李四", 30));
list.sort(Comparator.comparing(Person::getAge)); // 按年龄排序
list.sort(Comparator.comparing(Person::getName)); // 按姓名排序
通过传入不同Comparator实现,无需修改排序逻辑。
重载(Overload):同名方法,参数列表不同(类型/数量),编译期决定。
重写(Override):子类重定义父类方法,运行期动态绑定。
错误示例:
class Base {
void method(List list) { ... }
}
class Child extends Base {
void method(List list) { ... } // ❌ 非重写,是重载!
因泛型擦除,两者在JVM中均为method(List),编译报错:重复方法。
重写equals时必须重写hashCode,否则导致集合行为异常:
Map map = new HashMap<>();
Person p1 = new Person("张三");
map.put(p1, "value");
Person p2 = new Person("张三");
System.out.println(map.get(p2)); // null!因hashCode不等
正确做法:
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof Person)) return false;
Person person = (Person) o;
return Objects.equals(name, person.name);
}
@Override
public int hashCode() {
return Objects.hash(name);
}
单例(Singleton)易导致全局状态,隐藏依赖,增加测试难度。推荐使用依赖注入(DI)替代:
❌ 单例:
public class Service {
private static final Service INSTANCE = new Service();
public static Service getInstance() { return INSTANCE; }
}
✅ 依赖注入:
public class Controller {
private final Service service;
public Controller(Service service) { this.service = service; }
}
通过构造器注入,便于Mock测试与解耦。
订单状态流转:待支付→已支付→已发货→已完成,每状态行为不同。
实现:
interface OrderState {
void pay(OrderContext ctx);
void ship(OrderContext ctx);
void complete(OrderContext ctx);
}
class PendingState implements OrderState {
public void pay(OrderContext ctx) {
System.out.println("支付成功");
ctx.setState(new PaidState()); // 状态切换
}
// 其他方法抛异常或忽略
}
class OrderContext {
private OrderState state = new PendingState();
public void pay() { state.pay(this); }
public void ship() { state.ship(this); }
}
优势:新增状态(如“退款中”)只需实现新类,符合OCP。
统一日志接口:
public abstract class AbstractLogger {
protected abstract String formatLog(String msg);
protected abstract void doLog(String formatted);
public void info(String msg) { doLog(formatLog("[INFO] " + msg)); }
public void error(String msg) { doLog(formatLog("[ERROR] " + msg)); }
}
public class ConsoleLogger extends AbstractLogger {
protected String formatLog(String msg) { return msg; }
protected void doLog(String formatted) { System.out.println(formatted); }
}
通过继承扩展不同日志方式(文件/网络),复用模板逻辑。
抽象类与接口区别:抽象类可包含字段、构造方法、非抽象方法;接口仅能含常量、抽象方法、默认方法。抽象类体现“is-a”关系;接口体现“like-a”能力。Java类单继承抽象类,多实现接口。
重写equals需重写hashCode:因HashMap等集合依赖hashCode定位桶,再用equals比较键。若equals相等但hashCode不同,会导致集合中存入重复键或无法取出值,破坏Map语义。
组合优于继承:继承破坏封装(父类变化影响子类),组合通过“拥有”关系复用代码,更灵活且符合单一职责原则。例如ArrayList使用Object[]数组而非继承数组。
多态实现原理:JVM通过虚方法表(vtable)实现动态绑定。每个类生成vtable,存储方法指针;对象含vtable指针。调用方法时,通过对象指针查表,定位实际方法地址。
Java非纯面向对象:因有8种基本类型(int/char等),非对象,需装箱/拆箱。但Java 5后引入自动装箱,极大简化操作。严格面向对象语言如Smalltalk中一切皆对象。
final关键字用法:
• 类:不可继承(如String)
• 方法:不可重写
• 变量:不可变(基本类型值不变,引用类型地址不变)
• 参数:方法内不可修改
里氏替换原则(LSP):子类对象应能替换父类对象而不影响程序正确性。违反LSP的典型表现:子类方法抛出父类未声明的异常,或子类行为与父类不一致。
避免public字段:直接暴露字段导致:
• 无法校验数据合法性
• 无法控制访问时机
• 破坏封装性
应通过方法提供受控访问,例如getAge()可校验年龄范围。
设计模式使用时机:仅在问题模式匹配时使用,避免“为模式而模式”。例如:
• 需动态切换算法 → 策略模式
• 需扩展对象功能 → 装饰者模式
• 需创建复杂对象 → 建造者模式
学习OOP建议路径:
① 掌握类/对象/方法基础
② 理解封装/继承/多态三大特性
③ 实践设计原则(SOLID)
④ 分析开源项目源码(如JDK集合框架)
⑤ 动手重构遗留代码