Java 面向对象编程（OOP）

面向对象编程（Object-Oriented Programming, OOP）是 Java 语言的核心思想之一。OOP 提供了一种以对象为中心的编程方式，使得代码更加模块化、可重用且易于维护。本模块将介绍 Java 中的 OOP 基本概念，包括 类与对象、继承、封装、多态，并通过代码示例帮助你掌握这些核心概念。

1. 类与对象
类（Class）是对象的模板或蓝图，它定义了对象的属性和行为。对象（Object）是类的实例，是类的具体实现。

1.1 类的定义
类是 Java 程序的基本组成部分，用于定义对象的属性和行为。

示例：

public class Car {
    // 属性（成员变量）
    String color;
    int speed;
 
    // 方法（行为）
    void start() {
        System.out.println("汽车启动");
    }
 
    void stop() {
        System.out.println("汽车停止");
    }
}

在这个例子中，Car 类有两个属性：color 和 speed，以及两个方法：start() 和 stop()。

1.2 对象的创建与使用
通过 new 关键字可以创建类的对象，然后通过对象调用类的方法或访问属性。

示例：

public class Main {
    public static void main(String[] args) {
        // 创建 Car 类的对象
        Car myCar = new Car();
        myCar.color = "红色";
        myCar.speed = 100;
 
        // 调用对象的方法
        myCar.start();
        System.out.println("汽车颜色: " + myCar.color);
        myCar.stop();
    }
}

在这个例子中，我们创建了 Car 类的对象 myCar，并设置了属性 color 和 speed，然后调用了 start() 和 stop() 方法。

2. 封装
封装（Encapsulation）是一种将数据和操作数据的方法捆绑在一起的机制，目的是隐藏类的内部细节，只对外暴露必要的接口。这有助于提高代码的安全性和可维护性。

2.1 访问修饰符
Java 提供了访问修饰符来实现封装：

public：类、方法或属性对所有代码可见。

private：类的成员只能在该类内部访问，无法从外部访问。

protected：类的成员可以被同一包中的其他类或其子类访问。

默认（无修饰符）：类的成员可以被同一包中的其他类访问。

2.2 使用 Getter 和 Setter 方法
为了实现封装，我们通常将属性设置为 private，并通过 public 的 getter 和 setter 方法来访问和修改属性。

示例：

public class Person {
    // 私有属性
    private String name;
    private int age;
 
    // Getter 方法
    public String getName() {
        return name;
    }
 
    // Setter 方法
    public void setName(String name) {
        this.name = name;
    }
 
    public int getAge() {
        return age;
    }
 
    public void setAge(int age) {
        if (age > 0) {
            this.age = age;
        } else {
            System.out.println("年龄必须大于 0");
        }
    }
}

在这个例子中，name 和 age 是私有的，外部不能直接访问它们。通过 getName() 和 setName()，可以安全地访问和修改 name。

3. 继承
继承（Inheritance）是面向对象编程的重要特性，用于创建一个新类，该新类可以继承现有类的属性和方法。通过继承，可以实现代码重用。

3.1 继承的基本用法
extends 关键字用于声明一个类继承另一个类。

父类（超类）：被继承的类。

子类：继承父类的类。

示例：

// 父类
public class Animal {
    void eat() {
        System.out.println("动物在吃东西");
    }
}
 
// 子类
public class Dog extends Animal {
    void bark() {
        System.out.println("狗在叫");
    }
}
 
public class Main {
    public static void main(String[] args) {
        Dog myDog = new Dog();
        myDog.eat();  // 调用继承自父类的方法
        myDog.bark(); // 调用子类的方法
    }
}

在这个例子中，Dog 类继承了 Animal 类，因此 Dog 类可以使用 Animal 类的 eat() 方法。

3.2 方法重写
方法重写（Method Overriding）是子类提供对从父类继承的方法的具体实现。

使用 @Override 注解标记重写的方法。

子类可以提供自己的实现来覆盖父类的方法。

示例：

public class Dog extends Animal {
    @Override
    void eat() {
        System.out.println("狗在吃狗粮");
    }
}

在这个例子中，Dog 类重写了 Animal 类的 eat() 方法。

4. 多态
多态（Polymorphism）是 OOP 的另一个重要特性，它允许相同的操作作用于不同的对象。多态的实现有两种方式：编译时多态（方法重载）和运行时多态（方法重写）。

4.1 编译时多态（方法重载）
方法重载（Method Overloading）是在同一个类中定义多个方法，这些方法具有相同的名字，但参数不同（参数类型或参数个数不同）。

示例：

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

在这个例子中，add() 方法被重载了，分别用于处理整数和浮点数的相加。

4.2 运行时多态（方法重写）
运行时多态通过方法重写实现，父类的引用可以指向子类的对象，调用的方法根据引用指向的对象类型来确定。

示例：

public class Main {
    public static void main(String[] args) {
        Animal myAnimal = new Dog();  // 父类引用指向子类对象
        myAnimal.eat();  // 调用 Dog 类的 eat() 方法
    }
}

在这个例子中，虽然 myAnimal 的类型是 Animal，但它指向 Dog 对象，因此调用的是 Dog 类的 eat() 方法。

5. 面向对象编程的优势
模块化：将功能封装在类中，使代码更加模块化。

代码重用：通过继承和组合可以重用已有的代码。

灵活性和可维护性：通过多态和接口，可以更灵活地扩展代码，提高可维护性。

总结与后续
在本模块中，我们学习了 Java 的面向对象编程概念，包括类与对象、封装、继承和多态。这些概念是 Java 编程的重要基础，使得代码更加结构化和可维护。

在下一模块中，我们将深入探讨 Java 中的 抽象类 和 接口，学习如何通过抽象和接口提高代码的灵活性和复用性，进一步掌握 Java 的面向对象特性。