面向对象编程的四大基石：抽象、多态、继承、封装

好奇的菜鸟

于 2025-02-10 16:51:59 发布

阅读量994

点赞数 21

分类专栏： Java 文章标签： java

本文链接：https://blog.csdn.net/qq_29752857/article/details/145553608

版权

Java 专栏收录该内容

352 篇文章

订阅专栏

面向对象编程（OOP）是现代软件开发中的核心范式之一。它通过抽象、多态、继承和封装这四大特性，帮助开发者构建更加模块化、可维护和可扩展的代码。本文将通过Java语言，详细介绍这四大特性，并举例说明它们在实际编程中的应用。

1. 抽象（Abstraction）

什么是抽象？

抽象是指将复杂的现实世界简化为模型，只保留与当前问题相关的部分。在编程中，抽象通常通过类和接口来实现，隐藏不必要的细节，只暴露必要的功能。

Java中的抽象

在Java中，抽象可以通过抽象类（abstract class）和接口（interface）来实现。抽象类可以包含抽象方法（没有实现的方法）和具体方法（有实现的方法），而接口只能包含抽象方法（Java 8之后，接口也可以包含默认方法和静态方法）。

// 抽象类示例
abstract class Animal {
    // 抽象方法
    abstract void makeSound();

    // 具体方法
    void sleep() {
        System.out.println("This animal is sleeping.");
    }
}

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

抽象的好处

简化复杂性：通过隐藏不必要的细节，抽象使得代码更易于理解和维护。
提高复用性：抽象类和接口可以被多个类继承或实现，促进代码复用。

2. 多态（Polymorphism）

什么是多态？

多态是指同一个方法或操作可以在不同的对象上表现出不同的行为。多态性允许我们编写通用的代码，这些代码可以处理不同类型的对象。

Java中的多态

在Java中，多态主要通过方法重载（Overloading）和方法重写（Overriding）来实现。此外，接口和抽象类也是实现多态的重要手段。

class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("Woof!");
    }
}

class Cat extends Animal {
    @Override
    void makeSound() {
        System.out.println("Meow!");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        Animal myCat = new Cat();

        myDog.makeSound(); // 输出: Woof!
        myCat.makeSound(); // 输出: Meow!
    }
}

多态的好处

灵活性：多态使得代码更加灵活，能够处理不同类型的对象。
可扩展性：新增类时，无需修改现有代码，只需确保新类遵循相同的接口或继承关系。

3. 继承（Inheritance）

什么是继承？

继承是指一个类可以继承另一个类的属性和方法。通过继承，子类可以复用父类的代码，并且可以在子类中添加新的属性和方法，或者重写父类的方法。

Java中的继承

在Java中，继承通过extends关键字实现。一个类只能继承一个父类（单继承），但可以实现多个接口。

class Vehicle {
    void run() {
        System.out.println("Vehicle is running.");
    }
}

class Car extends Vehicle {
    @Override
    void run() {
        System.out.println("Car is running.");
    }

    void honk() {
        System.out.println("Honk honk!");
    }
}

public class Main {
    public static void main(String[] args) {
        Car myCar = new Car();
        myCar.run(); // 输出: Car is running.
        myCar.honk(); // 输出: Honk honk!
    }
}

继承的好处

代码复用：通过继承，子类可以复用父类的代码，减少重复代码。
层次结构：继承使得类与类之间形成层次结构，便于理解和组织代码。

4. 封装（Encapsulation）

什么是封装？

封装是指将对象的属性和方法隐藏起来，只暴露必要的接口供外部访问。通过封装，可以控制对对象内部状态的访问，防止外部代码直接修改对象的内部数据。

Java中的封装

在Java中，封装通过访问修饰符（private, protected, public）来实现。通常，类的属性被声明为private，并通过public的getter和setter方法来访问和修改这些属性。

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;
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person();
        person.setName("Alice");
        person.setAge(30);

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