Java 面向对象简介

面向对象编程（OOP）是现代编程的一种主流方式，Java 作为一门典型的面向对象编程语言，广泛应用于软件开发中。OOP 提供了通过类和对象的概念来管理程序复杂性的方式。本节将详细介绍面向对象编程的基本概念，并通过实例演示如何在 Java 中应用这些概念。

1. 面向对象的基本概念

1.1 类和对象

在 Java 中，类是对象的模板或蓝图，而对象则是类的实例。类定义了对象的属性（成员变量）和行为（方法）。每个对象都是类的一个实例，它具有类中定义的属性和行为。

类的定义

一个类是用来描述某一类事物的基本特征的。例如，假设我们要描述“学生”这一类事物，那么可以定义一个 Student 类，它包括学生的姓名、年龄、学号等属性，以及学生的行为（如：学习、考试等）。

1.2 封装

封装是面向对象编程的核心特性之一。通过封装，类将数据（属性）和行为（方法）结合在一起，同时提供控制数据访问的机制。封装通过访问控制符（如 private、public、protected 等）来限制对象的属性和方法的访问权限，保证数据的安全性。

1.3 继承

继承是面向对象编程中的另一个重要概念。通过继承，一个类可以继承另一个类的属性和方法。继承帮助我们避免代码重复，并且可以在父类的基础上扩展新的功能。

1.4 多态

多态指的是同一个方法在不同情况下表现出的不同行为。Java 中的多态体现在方法重载和方法重写两种形式。方法重载是指在同一个类中定义多个同名但参数不同的方法；方法重写则是指子类重新定义从父类继承来的方法。

1.5 抽象

抽象是指通过提取共性来创建抽象类或接口。抽象类和接口只能作为其他类的基类，不能直接实例化。它们帮助我们将共同的行为提取到父类中，从而简化代码设计。

2. 类和对象的代码示例

2.1 创建类和对象

以下是一个简单的 Student 类的例子，展示了如何定义类和创建对象：

public class Student {
    // 成员变量（属性）
    String name;  // 学生姓名
    int age;      // 学生年龄
    String studentId; // 学号

    // 构造方法，用于初始化对象
    public Student(String name, int age, String studentId) {
        this.name = name;
        this.age = age;
        this.studentId = studentId;
    }

    // 方法（行为）
    public void study() {
        System.out.println(name + " is studying.");
    }

    // 方法（行为）
    public void exam() {
        System.out.println(name + " is taking an exam.");
    }

    public static void main(String[] args) {
        // 创建一个Student类的对象
        Student student1 = new Student("Alice", 20, "S001");
        // 调用对象的方法
        student1.study();
        student1.exam();
    }
}

解释：

Student 类定义了三个属性：name、age 和 studentId，这些是每个学生对象的特征。
通过构造方法 Student(String name, int age, String studentId) 来初始化这些属性。
study() 和 exam() 方法定义了学生的行为，分别模拟学习和考试的动作。
在 main 方法中，我们通过 new 关键字创建了一个 Student 类的对象，并调用了其方法。

3. 封装的代码示例

封装是指将对象的状态（属性）和行为（方法）封装在一起，并通过访问控制符来保护数据的安全性。Java 提供了 private、public、protected 等访问控制符来控制数据的访问权限。

3.1 使用封装保护数据

public class Student {
    // 私有的成员变量，外部无法直接访问
    private String name;
    private int age;

    // 公共的构造方法，用于初始化属性
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 公共的 getter 方法，获取 name 的值
    public String getName() {
        return name;
    }

    // 公共的 setter 方法，设置 name 的值
    public void setName(String name) {
        this.name = name;
    }

    // 公共的 getter 方法，获取 age 的值
    public int getAge() {
        return age;
    }

    // 公共的 setter 方法，设置 age 的值
    public void setAge(int age) {
        this.age = age;
    }

    public static void main(String[] args) {
        // 创建一个Student类的对象
        Student student1 = new Student("Alice", 20);

        // 使用 getter 方法访问属性
        System.out.println("Student Name: " + student1.getName());
        System.out.println("Student Age: " + student1.getAge());

        // 使用 setter 方法修改属性
        student1.setName("Bob");
        student1.setAge(22);

        System.out.println("Updated Name: " + student1.getName());
        System.out.println("Updated Age: " + student1.getAge());
    }
}

解释：

在 Student 类中，name 和 age 成员变量被声明为 private，这意味着它们不能直接在类外部访问。
提供了公共的 getter 和 setter 方法，允许外部代码通过这些方法来访问或修改 name 和 age 的值。
通过封装，我们确保了数据的保护，同时提供了对数据的控制访问。

4. 继承的代码示例

继承是面向对象编程的核心概念之一，它使得子类能够继承父类的属性和方法，从而避免了重复代码。

4.1 继承示例

// 定义一个父类 Person
class Person {
    String name;
    int age;

    // 父类构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 父类方法
    public void greet() {
        System.out.println("Hello, my name is " + name + " and I am " + age + " years old.");
    }
}

// 定义一个子类 Student，继承 Person
class Student extends Person {
    String studentId;

    // 子类构造方法
    public Student(String name, int age, String studentId) {
        super(name, age); // 调用父类的构造方法
        this.studentId = studentId;
    }

    // 子类方法
    public void study() {
        System.out.println("Student " + name + " is studying.");
    }

    public static void main(String[] args) {
        // 创建一个 Student 对象
        Student student1 = new Student("Alice", 20, "S001");

        // 调用继承自父类的方法
        student1.greet();
        // 调用子类特有的方法
        student1.study();
    }
}

解释：

Person 类是一个父类，包含了基本的属性（name 和 age）以及一个 greet() 方法。
Student 类继承了 Person 类，添加了一个新的属性 studentId 和一个新的方法 study()。
子类 Student 通过 super() 调用了父类的构造方法，从而继承了父类的属性和方法。

5. 多态的代码示例

Java 中的多态性使得相同的操作可以作用于不同类型的对象。它包括方法重载和方法重写。

5.1 方法重载（编译时多态）

public class Calculator {
    // 方法重载，两个整数相加
    public int add(int a, int b) {
        return a + b;
    }

    // 方法重载，三个整数相加
    public int add(int a, int b, int c) {
        return a + b + c;
    }

    public static void main(String[] args) {
        Calculator calculator = new Calculator();

        // 调用 add() 方法时，根据参数数量不同，调用不同的重载版本
        System.out.println("Sum of 2 numbers: " + calculator.add(10, 20));
        System.out.println("Sum of 3 numbers: " + calculator.add(10, 20, 30));
    }
}

解释：

add() 方法有两个不同的版本：一个接受两个整数作为参数，另一个接受

三个整数作为参数。Java 会根据调用时传入的参数数量来确定使用哪个版本。

5.2 方法重写（运行时多态）

class Animal {
    // 父类方法
    public void sound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    // 子类重写父类的方法
    @Override
    public void sound() {
        System.out.println("Dog barks");
    }
}

class Main {
    public static void main(String[] args) {
        Animal animal = new Animal();
        Dog dog = new Dog();

        // 运行时多态：根据实际对象的类型调用相应的方法
        animal.sound();
        dog.sound();
    }
}

解释：