📚 Java面向对象编程详解

Java作为一门纯面向对象的编程语言，其核心思想体现在封装、继承和多态这三个基本特征上。这三大特性是Java编程的基石，掌握它们对于写出高质量、可维护的代码至关重要。

一、封装（Encapsulation）

核心概念：封装是指将数据和操作数据的方法绑定在一起，形成一个独立的单元，并尽可能隐藏对象的内部细节。封装是面向对象编程的第一道防线，通过限制对对象内部状态的访问来确保数据的安全性。

知识点详解：

• 访问修饰符：private（私有）、protected（受保护）、public（公共）、package-private（包级别，默认）
• 封装的目的是隐藏实现细节，只暴露必要的接口
• 通过getter/setter方法控制对私有属性的访问
• 提高代码的安全性、可维护性和可重用性

代码示例：

public class BankAccount {
    private double balance; // 私有属性，外部无法直接访问
    private String accountNumber;
    
    public BankAccount(String accountNumber, double initialBalance) {
        this.accountNumber = accountNumber;
        this.balance = initialBalance;
    }
    
    // 公共方法来安全地访问私有属性
    public double getBalance() {
        return balance;
    }
    
    // 控制对余额的修改
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }
    
    public boolean withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
            return true;
        }
        return false;
    }
}

最佳实践：

• 将类的属性设为private，通过公共方法提供访问
• 对setter方法进行参数验证
• 对于集合类型的属性，返回副本而非引用
• 不可变对象是封装的高级形式

二、继承（Inheritance）

核心概念：继承允许一个类（子类）获得另一个类（父类）的属性和方法。通过继承，我们可以实现代码重用，减少冗余代码，建立类之间的层次关系。Java中使用extends关键字来实现继承关系。

知识点详解：

• 单继承：Java只支持单继承，一个类只能继承一个父类
• 继承链：可以有多层继承，形成继承树
• 子类拥有父类的所有public和protected成员
• 方法重写（Override）：子类可以重新定义父类的方法
• super关键字：用于访问父类的成员

代码示例：

// 父类
abstract class Animal {
    protected String name;
    protected int age;
    
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    // 抽象方法，子类必须实现
    public abstract void makeSound();
    
    public void eat() {
        System.out.println(name + " is eating.");
    }
}

// 子类
class Dog extends Animal {
    private String breed;
    
    public Dog(String name, int age, String breed) {
        super(name, age); // 调用父类构造函数
        this.breed = breed;
    }
    
    @Override
    public void makeSound() {
        System.out.println("Woof! Woof!");
    }
    
    public void wagTail() {
        System.out.println(name + " is wagging tail.");
    }
}

最佳实践：

• 优先使用组合而非继承
• 使用抽象类或接口来定义通用行为
• 遵循里氏替换原则（LSP）
• 谨慎使用多重继承的替代方案（接口）

三、多态（Polymorphism）

核心概念：多态是指同一个接口或基类引用可以指向不同的实现类或子类对象，在运行时根据实际对象类型来决定调用哪个方法。多态是面向对象编程最强大的特性之一，它提高了代码的灵活性和扩展性。

知识点详解：

• 编译时多态：方法重载（Overload）
• 运行时多态：方法重写（Override）+ 向上转型
• 动态绑定：运行时确定调用哪个方法
• 接口多态：通过接口实现多态
• 多态的实现依赖于继承或接口实现

代码示例：

// 定义形状接口
interface Shape {
    double calculateArea();
    void draw();
}

// 圆形实现
class Circle implements Shape {
    private double radius;
    
    public Circle(double radius) {
        this.radius = radius;
    }
    
    @Override
    public double calculateArea() {
        return Math.PI * radius * radius;
    }
    
    @Override
    public void draw() {
        System.out.println("Drawing a circle");
    }
}

// 矩形实现
class Rectangle implements Shape {
    private double width, height;
    
    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }
    
    @Override
    public double calculateArea() {
        return width * height;
    }
    
    @Override
    public void draw() {
        System.out.println("Drawing a rectangle");
    }
}

// 多态使用示例
public class ShapeDemo {
    public static void main(String[] args) {
        Shape[] shapes = {
            new Circle(5.0),
            new Rectangle(4.0, 6.0),
            new Circle(3.0)
        };
        
        for (Shape shape : shapes) { // 多态体现
            shape.draw(); // 运行时决定调用哪个实现
            System.out.printf("Area: %.2f\n", shape.calculateArea());
        }
    }
}

最佳实践：

• 使用接口而非实现类编程
• 利用多态提高代码的可扩展性
• 避免不必要的向下转型
• 在运行时检查类型转换的安全性

四、综合应用示例

在实际开发中，合理运用封装、继承和多态可以大大提高代码的可重用性、可维护性和扩展性。让我们看一个综合示例：

import java.util.Arrays;

public class OOPExample {
    public static void main(String[] args) {
        // 创建不同类型的员工
        Employee manager = new Manager("Alice", 8000.0, 5000.0);
        Employee developer = new Developer("Bob", 6000.0, "Java");
        Employee designer = new Designer("Cathy", 5500.0, "UI/UX");
        
        Employee[] employees = {manager, developer, designer};
        
        // 利用多态计算薪资和展示信息
        for (Employee emp : employees) {
            System.out.println("Name: " + emp.getName());
            System.out.println("Salary: " + emp.calculateSalary());
            emp.work(); // 多态调用
            System.out.println("-------------------");
        }
    }
}

// 抽象基类 - 封装了公共属性
abstract class Employee {
    private String name; // 封装
    protected double baseSalary;
    
    public Employee(String name, double baseSalary) {
        this.name = name;
        this.baseSalary = baseSalary;
    }
    
    public String getName() { // 提供访问方法
        return name;
    }
    
    // 抽象方法，由子类实现
    public abstract double calculateSalary();
    public abstract void work();
}

// 经理类 - 继承并重写
class Manager extends Employee {
    private double bonus;
    
    public Manager(String name, double baseSalary, double bonus) {
        super(name, baseSalary); // 继承父类构造器
        this.bonus = bonus;
    }
    
    @Override
    public double calculateSalary() { // 多态 - 方法重写
        return baseSalary + bonus;
    }
    
    @Override
    public void work() { // 多态 - 方法重写
        System.out.println(getName() + " is managing the team.");
    }
}

// 开发者类
class Developer extends Employee {
    private String programmingLanguage;
    
    public Developer(String name, double baseSalary, String programmingLanguage) {
        super(name, baseSalary);
        this.programmingLanguage = programmingLanguage;
    }
    
    @Override
    public double calculateSalary() {
        return baseSalary;
    }
    
    @Override
    public void work() {
        System.out.println(getName() + " is coding in " + programmingLanguage + ".");
    }
}

// 设计师类
class Designer extends Employee {
    private String specialty;
    
    public Designer(String name, double baseSalary, String specialty) {
        super(name, baseSalary);
        this.specialty = specialty;
    }
    
    @Override
    public double calculateSalary() {
        return baseSalary;
    }
    
    @Override
    public void work() {
        System.out.println(getName() + " is designing " + specialty + ".");
    }
}

五、设计模式应用

封装、继承和多态是许多设计模式的基础。例如：

• 策略模式：利用多态实现算法的可替换性
• 模板方法模式：利用继承实现算法框架
• 工厂模式：利用多态创建不同类型的对象

掌握封装、继承和多态三大特性是成为优秀Java开发者的必经之路。在实际开发中，这三大特性往往结合使用，相互配合，共同构建出健壮、灵活、可维护的软件系统。理解它们的原理和应用场景，有助于编写出高质量的面向对象代码。