Java面向对象三大特性深度解析
一、封装 (Encapsulation)
1.1 核心实现
public class BankAccount {
// 私有化字段
private String accountNumber;
private double balance;
private String owner;
// 构造方法封装初始化逻辑
public BankAccount(String accountNumber, String owner) {
if(accountNumber == null || accountNumber.isEmpty()) {
throw new IllegalArgumentException("账号不能为空");
}
this.accountNumber = accountNumber;
this.owner = owner;
this.balance = 0.0;
}
// 受控的访问方法
public void deposit(double amount) {
if(amount <= 0) {
throw new IllegalArgumentException("存款金额必须为正数");
}
this.balance += amount;
}
public void withdraw(double amount) {
if(amount <= 0) {
throw new IllegalArgumentException("取款金额必须为正数");
}
if(amount > balance) {
throw new IllegalStateException("余额不足");
}
this.balance -= amount;
}
// 只读访问
public double getBalance() {
return balance;
}
}
1.2 核心价值
- 安全性：防止非法数据修改（如余额不能直接设置）
- 可维护性：内部实现变更不影响调用方（如余额存储单位从元改为分）
- 数据验证：保证对象始终处于有效状态（如取款不能超过余额）
1.3 设计模式应用
- 工厂模式：封装对象创建过程
- 建造者模式：封装复杂对象的构建过程
- 代理模式：封装实际对象的访问
二、继承 (Inheritance)
2.1 完整示例
// 基类
abstract class Shape {
protected String color;
public Shape(String color) {
this.color = color;
}
// 抽象方法强制子类实现
public abstract double area();
public void display() {
System.out.println("这是" + color + "的图形");
}
}
// 子类继承
class Circle extends Shape {
private double radius;
public Circle(String color, double radius) {
super(color); // 调用父类构造
this.radius = radius;
}
@Override
public double area() {
return Math.PI * radius * radius;
}
// 子类特有方法
public double perimeter() {
return 2 * Math.PI * radius;
}
}
// 多层继承
class Cylinder extends Circle {
private double height;
public Cylinder(String color, double radius, double height) {
super(color, radius);
this.height = height;
}
@Override
public double area() {
// 重写父类方法
return 2 * super.area() + perimeter() * height;
}
public double volume() {
return super.area() * height;
}
}
2.2 核心价值
- 代码复用：共用父类属性和方法
- 扩展性：通过继承扩展新功能
- 多态基础：为运行时多态提供条件
2.3 设计模式应用
- 模板方法模式：父类定义算法骨架
- 装饰器模式：通过继承扩展功能
- 组合模式：处理树形结构
三、多态 (Polymorphism)
3.1 完整示例
interface Payment {
void pay(double amount);
}
class CreditCard implements Payment {
@Override
public void pay(double amount) {
System.out.println("信用卡支付：" + amount + "元");
}
}
class Alipay implements Payment {
@Override
public void pay(double amount) {
System.out.println("支付宝支付：" + amount + "元");
}
}
class PaymentProcessor {
public void processPayment(Payment payment, double amount) {
// 多态调用
payment.pay(amount);
}
}
// 使用示例
public class Main {
public static void main(String[] args) {
PaymentProcessor processor = new PaymentProcessor();
// 同一接口不同表现
processor.processPayment(new CreditCard(), 100.0);
processor.processPayment(new Alipay(), 200.0);
// 运行时多态
Payment payment = Math.random() > 0.5 ? new CreditCard() : new Alipay();
payment.pay(300.0);
}
}
3.2 核心价值
- 扩展性：新增支付方式无需修改处理器代码
- 解耦：调用方只依赖抽象接口
- 灵活性：运行时动态决定具体实现
3.3 设计模式应用
- 策略模式：算法可互换
- 命令模式：将请求封装为对象
- 观察者模式：事件处理多态
四、三大特性协同应用
4.1 典型协作示例
// 封装基础
public abstract class Employee {
private String name;
private int id;
public Employee(String name, int id) {
this.name = name;
this.id = id;
}
// 封装通用行为
public void work() {
System.out.println(name + "开始工作");
}
// 多态接口
public abstract void calculateSalary();
}
// 继承扩展
class FullTimeEmployee extends Employee {
private double monthlySalary;
public FullTimeEmployee(String name, int id, double monthlySalary) {
super(name, id);
this.monthlySalary = monthlySalary;
}
@Override
public void calculateSalary() {
System.out.println("固定月薪：" + monthlySalary);
}
}
class PartTimeEmployee extends Employee {
private double hourlyRate;
private int hours;
public PartTimeEmployee(String name, int id, double hourlyRate, int hours) {
super(name, id);
this.hourlyRate = hourlyRate;
this.hours = hours;
}
@Override
public void calculateSalary() {
System.out.println("计时工资：" + (hourlyRate * hours));
}
}
// 使用多态
class PayrollSystem {
private List<Employee> employees = new ArrayList<>();
public void addEmployee(Employee emp) {
employees.add(emp);
}
public void processPayroll() {
for(Employee emp : employees) {
emp.work();
emp.calculateSalary(); // 多态调用
}
}
}
4.2 协同价值
- 封装保证对象内部状态安全
- 继承实现代码复用和层次化设计
- 多态提供统一接口处理不同实现
4.3 综合设计模式案例
工厂方法模式：
// 产品接口（多态）
interface Logger {
void log(String message);
}
// 具体产品（继承）
class FileLogger implements Logger {
@Override
public void log(String message) {
System.out.println("文件记录：" + message);
}
}
class DatabaseLogger implements Logger {
@Override
public void log(String message) {
System.out.println("数据库记录：" + message);
}
}
// 工厂基类（封装创建逻辑）
abstract class LoggerFactory {
// 工厂方法（多态）
public abstract Logger createLogger();
// 封装通用逻辑
public void writeLog() {
Logger logger = createLogger();
logger.log("测试日志");
}
}
// 具体工厂（继承）
class FileLoggerFactory extends LoggerFactory {
@Override
public Logger createLogger() {
return new FileLogger();
}
}
class DatabaseLoggerFactory extends LoggerFactory {
@Override
public Logger createLogger() {
return new DatabaseLogger();
}
}