封装、继承、多态

夜不眠，码三千

于 2024-04-06 19:03:14 发布

阅读量989

点赞数 8

文章标签： java

本文链接：https://blog.csdn.net/m0_74064480/article/details/137435056

版权

一、引言

面向对象编程（Object-Oriented Programming, OOP）的三大特征是封装、继承和多态，它们共同构成了面向对象编程的基本原则，有助于编写模块化、可维护和可扩展的代码。
1. 封装（Encapsulation）：
封装是指将数据（属性）和行为（方法）捆绑在一起，形成一个对象，并通过公共接口来访问这个对象。封装的目的是保护对象的内部状态，防止外部直接访问和修改对象的数据，确保数据的完整性和程序的安全性。
2. 继承（Inheritance）：
继承是允许新的类（子类）继承一个现有类（父类）的属性和方法。继承促进了代码的复用和模块化，通过继承一个基类，子类可以继承基类的所有特性，同时还可以添加新的特性或者覆盖基类中的方法。
3. 多态（Polymorphism）：
多态性指的是同一个行为具有多个不同表现形式的特性。在面向对象编程中，多态性常用于实现接口或继承父类的对象，这样不同的子类对象就可以用相同的接口来调用其独特的方法。这使得程序设计更加灵活，可以对不同的数据类型进行统一处理。

二、封装

        封装（Encapsulation）是面向对象编程的三大基本特性之一，它指的是将数据（属性）和行为（方法）捆绑在一起，形成一个对象，并且只通过公开的接口来访问这个对象。封装的目的是为了保护对象的内部状态，防止外部直接访问和修改对象的数据，确保数据的完整性和程序的安全性。
        在Java这样的面向对象语言中，封装通常通过使用访问修饰符来控制。例如，使用private关键字修饰的属性或方法只能在类的内部访问，而使用public关键字修饰的属性或方法则可以从类的任何外部访问。
        下面是一个简单的Java代码例子，展示了封装的概念：

public class Car {
    // 私有属性，不能直接从类的外部访问
    private String color;
    private int speed;
    // 公开的方法，用于访问私有属性
    public String getColor() {
        return color;
    }
    public void setColor(String color) {
        this.color = color;
    }
    public int getSpeed() {
        return speed;
    }
    public void setSpeed(int speed) {
        if (speed >= 0 && speed <= 120) { // 限制速度的有效性
            this.speed = speed;
        } else {
            System.out.println("Invalid speed!");
        }
    }
    // 公开的方法，执行操作（如开车）
    public void drive() {
        System.out.println("The car is driving with speed " + speed + " km/h.");
    }
}
public class Main {
    public static void main(String[] args) {
        Car myCar = new Car();
        // 通过公共方法设置车辆颜色
        myCar.setColor("Red");
        // 通过公共方法获取车辆颜色
        System.out.println("Car color: " + myCar.getColor());
        // 通过公共方法设置车辆速度
        myCar.setSpeed(60);
        // 通过公共方法执行驾驶操作
        myCar.drive();
    }
}

在这个例子中，Car类有两个私有属性 color 和 speed，以及几个公开的方法。这些公开的方法提供了控制车辆属性的安全接口。例如，setColor方法用于设置车辆的颜色，而 `setSpeed` 方法用于设置车辆的速度，同时检查速度是否在合理的范围内。这种方式确保了外部代码不能直接访问或修改 color 和 speed属性，必须通过 getColor、setColor、getSpeed 和 setSpeed这些公共方法来间接访问。这样的封装保证了类的内部状态不会被非法操作，同时也保护了代码的完整性。

三、继承

继承是面向对象编程的另一个核心概念，它允许新的类（子类）继承一个现有类（父类）的属性和方法。继承机制使得子类能够重用父类的代码，从而促进代码的复用和模块化。在Java等面向对象的语言中，继承是通过使用继承关键字（如Java中的`extends`）来实现的。
继承分为两种类型：
1. 单继承：一个子类只能继承一个父类。
2. 多继承：一个子类可以继承多个父类。不过，在Java这样的语言中，是不支持多继承的，每个类只能有一个基类。
下面是一个简单的Java代码例子，展示了单继承的概念：

// 父类
class Animal {
    protected String name;
    public Animal(String name) {
        this.name = name;
    }
    public void makeSound() {
        System.out.println("The animal makes a sound.");
    }
}
// 子类
class Dog extends Animal {
    public Dog(String name) {
        super(name); // 调用父类的构造函数
    }
    @Override
    public void makeSound() {
        System.out.println("The dog barks.");
    }
}
public class Main {
    public static void main(String[] args) {
        Dog myDog = new Dog("Buddy");
        myDog.makeSound(); // 输出：The dog barks.
    }
}

在这个例子中，Dog 类继承了 Animal类。因此，Dog类自动拥有了 Animal类的所有公共属性和方法。Dog类还可以添加自己特有的属性和方法，或者覆盖（重写）父类的方法，如 makeSound 方法就被 Dog 类覆盖以实现狗的叫声。Animal类中的 name属性被标记为 protected，这意味着它可以在 Animal类的子类中访问。
继承的关系形象地表示了类的层次结构，父类像是模板，而子类则是基于父类模板创建的特定实例。这种模型有助于组织类，使得类的继承体系更加清晰和易于理解。

四、多态

多态（Polymorphism）是面向对象编程的第三个核心概念，它指的是同一个行为具有多个不同表现形式的特性。在面向对象编程中，多态通常通过继承和接口来实现。多态允许不同类的对象对同一消息做出响应，即同一消息可以根据发送对象的不同而采用不同的处理方式。
多态有两种主要形式：
1. 编译时多态（静态多态）：这是通过方法重载实现的，方法重载发生在编译时期，编译器根据方法的参数类型和数量来决定调用哪个方法。
2. 运行时多态**（动态多态）：这是通过继承和接口实现的，运行时根据对象的实际类型来决定调用哪个方法。
下面是一个简单的Java代码例子，展示了运行时多态的概念：

// 父类
class Animal {
    public void makeSound() {
        System.out.println("The animal makes a sound.");
    }
}
// 子类
class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("The dog barks.");
    }
}
class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("The cat meows.");
    }
}
public class Main {
    public static void main(String[] args) {
        Animal myAnimal = new Animal();
        Animal myDog = new Dog();
        Animal myCat = new Cat();
        myAnimal.makeSound(); // 输出：The animal makes a sound.
        myDog.makeSound();    // 输出：The dog barks.
        myCat.makeSound();    // 输出：The cat meows.
        // 编译时多态示例
        makeSound(new Animal()); // 输出：The animal makes a sound.
        makeSound(new Dog());    // 输出：The dog barks.
        makeSound(new Cat());    // 输出：The cat meows.
    }
    // 运行时多态示例
    public static void makeSound(Animal animal) {
        animal.makeSound();
    }
}

在这个例子中，Animal类有一个 makeSound方法，而 Dog和 Cat类都重写了 makeSound方法。当我们创建 `Animal` 类型的引用指向 Dog或 Cat对象，并调用 makeSound方法时，程序会根据对象的的实际类型来调用相应的 makeSound方法，这就是运行时多态。
多态性的好处在于它提供了一个接口，使得对新增的子类能够做到“开闭原则”（即对扩展开放，对修改封闭），不需要修改现有的代码即可扩展新的功能。这在设计软件系统时非常有用，可以提高代码的可维护性和可扩展性。