Java 面向对象编程概念

学习目标

理解面向对象编程（OOP）的基本思想及其在 Java 中的重要性
掌握 OOP 的六大核心概念：类、对象、抽象、封装、继承、多态
能够在实际开发中应用 OOP 原则编写结构清晰、可维护、可复用的代码
了解 OOP 相对于过程式编程的优势与局限性

正文内容

什么是面向对象编程

在 OOP 出现之前，大多数程序采用过程式编程，即通过一系列函数按步骤执行任务。这种方式在小型项目中尚可管理，但在大型系统中会导致代码冗余、难以维护和复用。

面向对象编程（Object-Oriented Programming, OOP）通过将数据和操作数据的方法组织成“对象”，有效解决了上述问题。Java 是一门完全基于 OOP 设计的语言，其核心思想是：

万物皆对象，程序即对象间的交互。

OOP 的主要优势包括：

代码模块化、结构清晰
支持代码复用（DRY 原则：Don’t Repeat Yourself）
提高安全性（通过封装限制数据访问）
易于扩展和维护

OOP 六大核心概念

1. 类

类是创建对象的蓝图或模板，定义了对象的属性（字段）和行为（方法）。

类名通常首字母大写（如 Employee）
可包含：修饰符、字段、构造器、方法等
一个类可创建多个具有相同结构的对象

public class Employee {
    private String name;
    private float salary;

    public Employee(String name, float salary) {
        this.name = name;
        this.salary = salary;
    }

    public void displayDetails() {
        System.out.println("Employee: " + name);
        System.out.println("Salary: " + salary);
    }
}

关键点：类是抽象的，对象是具体的实例。

2. 对象

对象是类的实例，代表现实世界中的实体。每个对象具有三个基本特征：

特征	说明
状态	由字段（变量）表示，如员工的姓名、薪资
行为	由方法表示，如 `displayDetails()`
身份	对象在内存中的唯一标识（即使内容相同，也是不同对象）

Employee emp = new Employee("张三", 15000.0f);
emp.displayDetails();

输出：

Employee: 张三
Salary: 15000.0

3. 抽象

抽象是指隐藏复杂的实现细节，仅暴露必要的功能接口给用户。

用户只需知道“能做什么”，无需关心“如何做”
在 Java 中通过 abstract class 和 interface 实现
接口可实现 100% 抽象

abstract class Vehicle {
    abstract void accelerate(); // 抽象方法：只声明，不实现
    abstract void brake();

    void startEngine() {
        System.out.println("引擎已启动！");
    }
}

class Car extends Vehicle {
    @Override
    void accelerate() {
        System.out.println("汽车加速中...（内部逻辑隐藏）");
    }

    @Override
    void brake() {
        System.out.println("汽车刹车中...");
    }
}

好处：降低系统耦合度，提升可维护性。

4. 封装

封装是将数据（字段）和操作数据的方法绑定在一起，并对外部隐藏内部实现细节。

通常将字段设为 private
通过 public 的 getter/setter 方法控制访问
也称为“数据隐藏”（Data Hiding）

class Employee {
    private int id;
    private String name;

    public void setId(int id) { this.id = id; }
    public int getId() { return id; }

    public void setName(String name) { this.name = name; }
    public String getName() { return name; }
}

使用示例：

Employee emp = new Employee();
emp.setId(101);
emp.setName("李四");
System.out.println("ID: " + emp.getId()); // 安全访问

安全机制：防止非法修改（如在 setter 中加入校验逻辑）

5. 继承

继承允许一个类（子类）获取另一个类（父类）的属性和方法，实现代码复用。

使用 extends 关键字
体现 “is-a” 关系（如：狗 is-a 动物）
子类可扩展或重写父类功能

class Animal {
    void eat() { System.out.println("动物在进食..."); }
}

class Dog extends Animal {
    void bark() { System.out.println("狗在汪汪叫！"); }
}

// 使用
Dog myDog = new Dog();
myDog.eat();  // 继承自 Animal
myDog.bark(); // 自有方法

输出：

动物在进食...
狗在汪汪叫！

复用性：避免重复编写通用逻辑。

6. 多态

多态意为“多种形态”，指同一操作作用于不同对象时产生不同行为。Java 中多态分为两类：

类型	别名	实现方式	决定时机
方法重载（Overloading）	编译时多态	同一类中方法名相同、参数不同	编译期
方法重写（Overriding）	运行时多态	子类重写父类方法	运行期

示例：重载 + 重写

class Parent {
    public void func() { System.out.println("Parent.func()"); }
    public void func(int a) { System.out.println("Parent.func(int): " + a); }
}

class Child extends Parent {
    @Override
    public void func(int a) { System.out.println("Child.func(int): " + a); }
}

public class Main {
    public static void main(String[] args) {
        Parent p = new Parent();
        Child c = new Child();
        Parent poly = new Child(); // 多态引用

        p.func();          // Parent.func()
        p.func(10);        // Parent.func(int): 10
        c.func(20);        // Child.func(int): 20
        poly.func(30);     // Child.func(int): 30（运行时决定）
    }
}

核心价值：提升代码灵活性和可扩展性。

OOP 与过程式编程

对比项	过程式编程	面向对象编程
核心单位	函数	对象
数据与行为	分离	封装在一起
代码复用	通过函数调用	通过继承和组合
可维护性	较低（尤其大型项目）	高（模块化设计）
扩展性	困难	容易（开闭原则）

OOP 的优缺点

优点

高复用性：通过继承和组合减少重复代码
高可维护性：模块清晰，修改局部不影响整体
安全性强：封装保护数据不被随意篡改
贴近现实：用对象模拟真实世界更直观

缺点

学习曲线陡峭：初学者需理解类、对象、继承等抽象概念
小项目“杀鸡用牛刀”：简单脚本用 OOP 反而增加复杂度
性能开销：对象创建和方法调用有一定内存与时间成本
调试复杂度上升：多层继承或接口可能使调用链变长

重点总结

类是模板，对象是实例
抽象隐藏实现，封装保护数据
继承实现复用，多态提供灵活性
OOP 不是万能药，应根据项目规模合理选择编程范式
Java 的强大之处在于其完整的 OOP 支持体系

思考题

为什么说“封装”不仅是一种技术手段，更是一种设计思想？
在什么场景下，使用接口（interface）比抽象类（abstract class）更合适？
如果一个类既没有继承也没有被继承，它是否仍然属于 OOP 范畴？为什么？