【软件工程】面向对象编程（OOP）概念详解

面向对象（Object-Oriented）是一种程序设计范式，以"对象 "为核心，通过封装、继承、多态和抽象等特性，帮助我们构建结构清晰、可维护性高的软件系统。本文将层次分明地介绍 OOP 的核心概念，并配以 Java 示例代码，帮助你快速掌握面向对象编程的思想与实践。

类与对象

类（Class）：对一类事物的抽象描述，定义了该类事物拥有的属性（field）和行为（method）。
对象（Object）：类的实例，具备类所定义的属性值和行为能力。

java 复制代码

// 定义一个"汽车"类
public class Car {
    // 属性（成员变量）
    private String brand;
    private String color;
    private int speed;

    // 构造方法
    public Car(String brand, String color) {
        this.brand = brand;
        this.color = color;
        this.speed = 0;
    }

    // 行为（成员方法）
    public void accelerate(int increment) {
        speed += increment;
        System.out.println(brand + " 加速到 " + speed + " km/h");
    }

    public void brake(int decrement) {
        speed = Math.max(0, speed - decrement);
        System.out.println(brand + " 减速到 " + speed + " km/h");
    }
}

// 在 main 方法中创建对象
public class Main {
    public static void main(String[] args) {
        Car myCar = new Car("Tesla Model 3", "红色");
        myCar.accelerate(50);
        myCar.brake(20);
    }
}

封装（Encapsulation）

封装是指将对象的状态（属性）和行为（方法）打包在一起，对外隐藏内部实现细节，只暴露必要的接口。这能有效提高代码的 安全性 与 可维护性。

java 复制代码

public class Account {
    private String accountNo;
    private double balance;

    public Account(String accountNo, double initBalance) {
        this.accountNo = accountNo;
        this.balance = initBalance;
    }

    // 存款
    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;
    }

    // 对外只暴露余额查询接口
    public double getBalance() {
        return balance;
    }
}

private 修饰字段，禁止外部直接访问。
通过 public 方法控制对内部状态的合法操作。

继承（Inheritance）

继承是面向对象的重要特性，通过子类继承父类的属性和方法，实现 代码重用 与 层次结构 。子类可对父类行为进行扩展或重写（Override）。

java 复制代码

// 父类
public class Animal {
    public void eat() {
        System.out.println("动物进食");
    }
}

// 子类继承 Animal
public class Dog extends Animal {
    // 扩展方法
    public void bark() {
        System.out.println("小狗汪汪叫");
    }

    // 重写父类方法
    @Override
    public void eat() {
        System.out.println("小狗啃骨头");
    }
}

// 测试继承
public class TestInheritance {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat();  // 输出：小狗啃骨头
        dog.bark(); // 输出：小狗汪汪叫
    }
}

多态（Polymorphism）

多态允许同一操作作用于不同类型的对象上，表现出不同的行为。Java 中多态的实现依赖于 方法重写 和 向上转型。

java 复制代码

public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("小猫吃鱼");
    }
}

public class TestPolymorphism {
    public static void main(String[] args) {
        Animal a1 = new Dog();  // 向上转型
        Animal a2 = new Cat();

        a1.eat(); // 小狗啃骨头
        a2.eat(); // 小猫吃鱼
    }
}

变量声明类型为父类，实际引用子类对象。
调用 eat() 时，根据对象的实际类型动态绑定方法。

抽象（Abstraction）与接口（Interface）

抽象类：包含抽象方法（没有实现的方法）的类，不能被实例化，子类必须实现其抽象方法。
接口：纯抽象的"契约"，Java8+ 支持默认方法（default）和静态方法。

java 复制代码

// 抽象类示例
public abstract class Shape {
    // 抽象方法
    public abstract double area();

    public void describe() {
        System.out.println("我是一个图形");
    }
}

// 子类实现
public class Circle extends Shape {
    private double radius;
    public Circle(double r) { this.radius = r; }

    @Override
    public double area() {
        return Math.PI * radius * radius;
    }
}

// 接口示例
public interface Drawable {
    void draw();  // 抽象方法
}

// 实现接口
public class Rectangle implements Drawable {
    @Override
    public void draw() {
        System.out.println("绘制矩形");
    }
}

设计原则简介（SOLID）

为了编写高质量的面向对象代码，还应遵循一些经典设计原则：

Single Responsibility（单一职责）
Open/Closed（开闭原则）
Liskov Substitution（里氏替换）
Interface Segregation（接口隔离）
Dependency Inversion（依赖倒置）

这些原则能让系统更易扩展、维护，并提高代码的可测试性。

如果觉得不错的话，不妨给作者点个赞！