面向对象编程

2025/8/24大约 6 分钟

面向对象编程

面向对象编程（Object-Oriented Programming，OOP）是一种编程范式，它使用"对象"来设计应用程序和计算机程序。面向对象编程的主要特点包括封装、继承、多态和抽象。

面向对象编程概述

什么是面向对象编程

面向对象编程是一种基于"对象"的编程范式，对象是包含数据（属性）和行为（方法）的实体。面向对象编程的核心思想是将现实世界中的事物抽象为程序中的对象，通过对象之间的交互来完成任务。

面向对象编程的特点

封装：将数据和方法封装在一个单元（对象）中，隐藏内部实现细节。
继承：允许一个类继承另一个类的属性和方法，实现代码复用。
多态：允许不同类的对象对同一消息做出不同的响应。
抽象：忽略不重要的细节，专注于本质特征。

面向对象编程与面向过程编程的区别

面向过程编程：关注"如何做"（How），以过程为中心，分析解决问题的步骤。
面向对象编程：关注"做什么"（What），以对象为中心，将问题分解为对象之间的交互。

类与对象

什么是类

类是对象的模板或蓝图，它定义了对象的属性和方法。类是一种抽象的数据类型，它描述了一类对象的共同特征。

什么是对象

对象是类的实例，它是具有具体属性值和行为的实体。一个类可以创建多个对象。

类的定义

// 类的定义
public class Person {
    // 属性（成员变量）
    private String name;
    private int age;

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

    // 方法（成员方法）
    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void sayHello() {
        System.out.println("Hello, my name is " + name + ", I'm " + age + " years old.");
    }
}

对象的创建与使用

// 创建对象
Person person = new Person("Alice", 25);

// 使用对象
person.sayHello();  // 调用方法
String name = person.getName();  // 获取属性值
person.setAge(26);  // 设置属性值

封装

什么是封装

封装是将数据和方法封装在一个单元（对象）中，隐藏内部实现细节，只对外提供公共接口。封装的目的是保护数据的安全性和完整性。

封装的实现

在Java中，封装通过访问控制修饰符来实现：

private：只有类内部可以访问。
default（无修饰符）：同一个包内可以访问。
protected：同一个包内或子类可以访问。
public：任何地方都可以访问。

封装的优点

保护数据的安全性和完整性。
隐藏内部实现细节，减少耦合。
提高代码的可维护性和可重用性。

继承

什么是继承

继承是允许一个类（子类）继承另一个类（父类）的属性和方法，实现代码复用的机制。子类可以扩展父类的功能，添加新的属性和方法。

继承的实现

// 父类
public class Animal {
    protected String name;

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

    public void eat() {
        System.out.println(name + " is eating.");
    }
}

// 子类
public class Dog extends Animal {
    public Dog(String name) {
        super(name);  // 调用父类的构造方法
    }

    public void bark() {
        System.out.println(name + " is barking.");
    }
}

继承的优点

实现代码复用，减少重复代码。
建立类之间的层次关系，提高代码的可维护性。
支持多态的实现。

继承的注意事项

Java支持单继承，一个类只能有一个直接父类。
子类不能访问父类的私有成员。
子类可以重写父类的方法，但不能重写父类的私有方法。

多态

什么是多态

多态是指允许不同类的对象对同一消息做出不同的响应。多态的实现基于继承和方法重写。

多态的实现

// 父类
public class Animal {
    public void makeSound() {
        System.out.println("Animal is making sound.");
    }
}

// 子类1
public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Dog is barking.");
    }
}

// 子类2
public class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Cat is meowing.");
    }
}

// 使用多态
Animal animal1 = new Dog();
Animal animal2 = new Cat();
animal1.makeSound();  // 输出：Dog is barking.
animal2.makeSound();  // 输出：Cat is meowing.

多态的优点

提高代码的灵活性和可扩展性。
简化代码，减少条件语句的使用。
支持动态绑定，提高程序的可维护性。

抽象类与接口

抽象类

抽象类是不能被实例化的类，它用于定义子类的共同特征和行为。抽象类可以包含抽象方法和非抽象方法。

// 抽象类
public abstract class Shape {
    protected String color;

    public Shape(String color) {
        this.color = color;
    }

    // 抽象方法
    public abstract double getArea();

    // 非抽象方法
    public void display() {
        System.out.println("This is a " + color + " shape.");
    }
}

// 具体子类
public class Circle extends Shape {
    private double radius;

    public Circle(String color, double radius) {
        super(color);
        this.radius = radius;
    }

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

接口

接口是一种特殊的抽象类，它只包含抽象方法和常量。接口用于定义类的行为规范，一个类可以实现多个接口。

// 接口
public interface Flyable {
    void fly();
}

// 实现接口的类
public class Bird implements Flyable {
    @Override
    public void fly() {
        System.out.println("Bird is flying.");
    }
}

// 实现多个接口
public class Plane implements Flyable, Runnable {
    @Override
    public void fly() {
        System.out.println("Plane is flying.");
    }

    @Override
    public void run() {
        System.out.println("Plane's engine is running.");
    }
}