10.1 什么是面向对象？类和对象是什么？

面向对象编程的概念

面向对象编程（Object-Oriented Programming，OOP）是一种编程范式，它将现实世界中的事物抽象为对象，通过对象之间的交互来实现程序功能。面向对象编程的核心思想是封装、继承和多态。

面向对象编程的特点

1. 封装：将数据和方法封装在对象中，对外只暴露必要的接口
2. 继承：子类可以继承父类的属性和方法，实现代码复用
3. 多态：不同对象对同一消息做出不同的响应
4. 抽象：将复杂的现实世界抽象为简单的对象模型

类和对象的概念

类（Class）

类是对象的蓝图或模板，它定义了对象的属性和方法。类是面向对象编程的基本单位。

示例：

public class Person {
    // 属性（成员变量）
    private String name;
    private int age;
    private String address;
    
    // 方法
    public void eat() {
        System.out.println(name + " is eating.");
    }
    
    public void sleep() {
        System.out.println(name + " is sleeping.");
    }
}

对象（Object）

对象是类的实例，是具体的、实际存在的事物。对象具有状态（属性）和行为（方法）。

示例：

// 创建 Person 类的对象
Person person = new Person();

类和对象的关系

类是对象的模板，对象是类的实例。一个类可以创建多个对象，每个对象都具有类定义的属性和方法，但属性的值可能不同。

示例：

// 创建两个 Person 对象
Person person1 = new Person();
Person person2 = new Person();

// 设置对象的属性
person1.setName("John");
person1.setAge(25);

person2.setName("Jane");
person2.setAge(30);

// 调用对象的方法
person1.eat(); // 输出 "John is eating."
person2.eat(); // 输出 "Jane is eating."

面向对象编程的优势

1. 代码复用：通过继承实现代码复用
2. 封装性：隐藏实现细节，提高代码的安全性
3. 可维护性：代码结构清晰，易于维护
4. 可扩展性：通过继承和多态，易于扩展功能
5. 模块化：将复杂系统分解为多个对象，便于管理

面向对象编程的基本概念

1. 属性（Attribute）

属性是对象的状态，也称为成员变量。属性定义了对象的特征。

示例：

public class Person {
    // 属性
    private String name; // 姓名
    private int age; // 年龄
    private String address; // 地址
}

2. 方法（Method）

方法是对象的行为，定义了对象可以执行的操作。

示例：

public class Person {
    // 方法
    public void eat() {
        System.out.println("Eating...");
    }
    
    public void sleep() {
        System.out.println("Sleeping...");
    }
}

3. 构造方法（Constructor）

构造方法是一种特殊的方法，用于创建对象时初始化对象的属性。

示例：

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

4. 访问修饰符（Access Modifier）

访问修饰符用于控制属性和方法的访问权限。Java 提供了四种访问修饰符：public、protected、default 和 private。

示例：

public class Person {
    public String publicAttribute; // 公共属性
    protected String protectedAttribute; // 受保护属性
    String defaultAttribute; // 默认属性
    private String privateAttribute; // 私有属性
    
    public void publicMethod() {}
    protected void protectedMethod() {}
    void defaultMethod() {}
    private void privateMethod() {}
}

示例：类和对象的使用

public class Car {
    // 属性
    private String brand;
    private String model;
    private int year;
    private String color;
    
    // 构造方法
    public Car(String brand, String model, int year, String color) {
        this.brand = brand;
        this.model = model;
        this.year = year;
        this.color = color;
    }
    
    // 方法
    public void start() {
        System.out.println(brand + " " + model + " is starting.");
    }
    
    public void stop() {
        System.out.println(brand + " " + model + " is stopping.");
    }
    
    public void drive() {
        System.out.println(brand + " " + model + " is driving.");
    }
    
    // 获取属性的方法
    public String getBrand() {
        return brand;
    }
    
    public String getModel() {
        return model;
    }
    
    public int getYear() {
        return year;
    }
    
    public String getColor() {
        return color;
    }
}

public class CarExample {
    public static void main(String[] args) {
        // 创建 Car 对象
        Car car1 = new Car("Toyota", "Camry", 2020, "Red");
        Car car2 = new Car("Honda", "Civic", 2021, "Blue");
        
        // 调用对象的方法
        car1.start();
        car1.drive();
        car1.stop();
        
        car2.start();
        car2.drive();
        car2.stop();
        
        // 获取对象的属性
        System.out.println("Car 1: " + car1.getBrand() + " " + car1.getModel() + " " + car1.getYear() + " " + car1.getColor());
        System.out.println("Car 2: " + car2.getBrand() + " " + car2.getModel() + " " + car2.getYear() + " " + car2.getColor());
    }
}

面向对象编程与面向过程编程的对比

特性	面向对象编程	面向过程编程
核心	对象	函数
数据和行为	封装在对象中	分离
代码复用	通过继承	通过函数调用
可维护性	高	低
可扩展性	高	低
适用场景	复杂系统	简单任务

常见问题

1. 类和对象的区别

问题：类和对象有什么区别？

解答：类是对象的模板，定义了对象的属性和方法；对象是类的实例，是具体的、实际存在的事物。

2. 面向对象编程的核心概念

问题：面向对象编程的核心概念是什么？

解答：面向对象编程的核心概念是封装、继承和多态。

3. 访问修饰符的作用

问题：访问修饰符有什么作用？

解答：访问修饰符用于控制属性和方法的访问权限，保护数据的安全性。

4. 构造方法的作用

问题：构造方法有什么作用？

解答：构造方法用于创建对象时初始化对象的属性。

总结

面向对象编程是一种编程范式，它将现实世界中的事物抽象为对象，通过对象之间的交互来实现程序功能。类是对象的蓝图或模板，定义了对象的属性和方法；对象是类的实例，是具体的、实际存在的事物。

面向对象编程的核心思想是封装、继承和多态，它具有代码复用、封装性、可维护性、可扩展性和模块化等优势。

通过合理使用面向对象编程，可以使代码结构更清晰，提高代码的可维护性和可扩展性。