【Java】面向对象编程（OOP）在Java中的应用

啊松同学

于 2025-02-15 14:52:15 发布

阅读量934

点赞数 21

分类专栏： Java 文章标签： java 后端面向对象

本文链接：https://blog.youkuaiyun.com/weixin_50591390/article/details/145590256

版权

Java 专栏收录该内容

19 篇文章

订阅专栏

前言

面向对象编程（Object-Oriented Programming, OOP） 是一种以“对象”为核心的编程范式，其核心思想是通过对现实世界的抽象和建模，提高代码的可复用性、可维护性和扩展性。Java 作为一门纯面向对象的语言，完美支持 OOP 的四大核心特性：封装、继承、多态、抽象。本文将通过通俗易懂的解释和代码示例，深入解析这些特性在 Java 中的实际应用。

一、封装（Encapsulation）：保护数据，隐藏细节

1. 什么是封装？

封装是将数据（属性）和行为（方法）绑定在一个类中，并通过访问控制（如 private）隐藏内部细节，仅暴露必要的接口。

2. 代码示例

public class BankAccount {
    // 私有属性：外部无法直接访问
    private String accountNumber;
    private double balance;

    // 公有方法：提供可控的访问接口
    public BankAccount(String accountNumber) {
        this.accountNumber = accountNumber;
        this.balance = 0.0;
    }

    // 存款操作（封装业务逻辑）
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
            System.out.println("存款成功，当前余额：" + balance);
        } else {
            System.out.println("存款金额必须大于0");
        }
    }

    // 获取余额（隐藏实现细节）
    public double getBalance() {
        return balance;
    }
}

// 使用示例
public class Main {
    public static void main(String[] args) {
        BankAccount account = new BankAccount("123456789");
        account.deposit(1000);  // 输出：存款成功，当前余额：1000.0
        System.out.println("当前余额：" + account.getBalance()); // 输出：1000.0
    }
}

3. 封装的优势

安全性：防止外部直接修改敏感数据（如余额）。
灵活性：内部逻辑修改不影响外部调用（例如修改存款手续费计算方式）。

二、继承（Inheritance）：复用与扩展

1. 什么是继承？

继承允许子类复用父类的属性和方法，并通过扩展或重写实现功能增强。

2. 代码示例

// 父类：动物
class Animal {
    private String name;

    public Animal(String name) {
        this.name = name;
    }

    public void eat() {
        System.out.println(name + "正在吃东西");
    }
}

// 子类：猫（继承Animal）
class Cat extends Animal {
    public Cat(String name) {
        super(name); // 调用父类构造方法
    }

    // 扩展新方法
    public void meow() {
        System.out.println("喵喵叫");
    }

    // 重写父类方法
    @Override
    public void eat() {
        super.eat(); // 调用父类方法
        System.out.println("并且吃的是猫粮");
    }
}

// 使用示例
public class Main {
    public static void main(String[] args) {
        Cat cat = new Cat("Tom");
        cat.eat();  // 输出：Tom正在吃东西 并且吃的是猫粮
        cat.meow(); // 输出：喵喵叫
    }
}

3. 继承的应用场景

代码复用：多个类有共同属性和方法时（如 Animal 和 Dog）。
功能扩展：在现有类基础上添加新功能（如 Cat 添加 meow()）。

三、多态（Polymorphism）：同一接口，多种实现

1. 什么是多态？

多态允许不同对象对同一方法调用做出不同响应，分为 编译时多态（方法重载） 和 运行时多态（方法重写）。

2. 代码示例

编译时多态（方法重载）

class Calculator {
    // 重载add方法
    public int add(int a, int b) {
        return a + b;
    }

    public double add(double a, double b) {
        return a + b;
    }
}

public class Main {
    public static void main(String[] args) {
        Calculator calc = new Calculator();
        System.out.println(calc.add(2, 3));     // 输出：5（调用int版本）
        System.out.println(calc.add(2.5, 3.5)); // 输出：6.0（调用double版本）
    }
}

运行时多态（方法重写 + 接口）

// 定义接口
interface USB {
    void transferData();
}

// 实现类1：U盘
class FlashDrive implements USB {
    @Override
    public void transferData() {
        System.out.println("通过U盘传输数据");
    }
}

// 实现类2：鼠标
class Mouse implements USB {
    @Override
    public void transferData() {
        System.out.println("通过鼠标传输指令");
    }
}

public class Main {
    public static void main(String[] args) {
        USB device1 = new FlashDrive();
        USB device2 = new Mouse();

        device1.transferData(); // 输出：通过U盘传输数据
        device2.transferData(); // 输出：通过鼠标传输指令
    }
}

3. 多态的优势

灵活性：同一接口适应不同实现（如不同USB设备）。
可扩展性：新增实现类无需修改现有代码。

四、抽象（Abstraction）：定义规范，隐藏复杂性

1. 什么是抽象？

抽象通过 抽象类（Abstract Class） 和 接口（Interface） 定义规范，强制子类实现特定方法。

2. 代码示例

抽象类

// 抽象类：图形
abstract class Shape {
    // 抽象方法（无实现）
    public abstract double calculateArea();

    // 具体方法
    public void printArea() {
        System.out.println("面积为：" + calculateArea());
    }
}

// 子类：圆形
class Circle extends Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

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

public class Main {
    public static void main(String[] args) {
        Shape circle = new Circle(3);
        circle.printArea(); // 输出：面积为：28.274333882308138
    }
}

接口

// 接口：可排序
interface Sortable {
    void sort(int[] array);
}

// 实现类：冒泡排序
class BubbleSort implements Sortable {
    @Override
    public void sort(int[] array) {
        // 实现冒泡排序逻辑
        System.out.println("使用冒泡排序");
    }
}

// 实现类：快速排序
class QuickSort implements Sortable {
    @Override
    public void sort(int[] array) {
        // 实现快速排序逻辑
        System.out.println("使用快速排序");
    }
}

public class Main {
    public static void main(String[] args) {
        Sortable sorter = new QuickSort();
        int[] data = {5, 2, 9, 1};
        sorter.sort(data); // 输出：使用快速排序
    }
}