【OOP】面向对象

科马

已于 2024-08-23 17:29:10 修改

阅读量676

点赞数 18

分类专栏： java 文章标签： java 设计规范

于 2024-08-23 17:28:13 首次发布

本文链接：https://blog.csdn.net/weixin_63405049/article/details/141461371

版权

java 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

面向对象OOP

面向对象怎么理解
三大特征
面向对象JAVA
面向对象编程在Java中的实现

面向对象怎么理解

面向对象编程（Object-Oriented Programming, OOP）的思想起源于20世纪60年代，最早由挪威计算机科学家Ole-Johan Dahl和Kristen Nygaard在开发Simula语言时提出的。Simula 67被认为是第一个支持面向对象编程的编程语言。

起源

Simula 67的诞生（1960年代）：

背景：Ole-Johan Dahl和Kristen Nygaard在挪威计算机中心工作，开始开发一种用于模拟现实世界系统的语言。他们意识到，为了更好地模拟复杂系统，需要一种能够处理复杂数据结构和行为的方法。
创新：他们在Simula语言中引入了“类”和“对象”的概念，用于表示现实世界中的实体。类定义了一组具有相同特征的对象，而对象则是类的实例。这个概念成为面向对象编程的核心。

自此，面向对象这个思想就此诞生。

发展

Smalltalk的发展（1970年代）：

背景：Smalltalk是由Xerox帕洛阿尔托研究中心的Alan Kay、Dan Ingalls等人开发的面向对象编程语言。Smalltalk不仅继承了Simula的面向对象思想，还将这些思想进一步推广，并引入了图形用户界面。
创新：Smalltalk彻底拥抱了面向对象的思想，一切皆对象，连数字、字符串等基本数据类型也是对象。Smalltalk的设计极大地推动了面向对象编程的普及。

普及

面向对象的普及（1980年代-1990年代）：

C++和Java的出现：C++是Bjarne Stroustrup在1980年代开发的，它在C语言的基础上引入了面向对象的特性。C++的成功标志着面向对象编程开始进入主流。Java在1990年代问世，它继承了C++的许多面向对象特性，同时通过简化和安全性设计，迅速成为流行的编程语言。
OOP的理论化：随着时间的推移，面向对象编程的思想被进一步理论化，得到了软件工程领域的广泛认可。设计模式（Design Patterns）等概念的引入进一步推动了OOP在软件开发中的应用。

面向对象

我们可以用一个生活故事来说明面向对象的基本思想。想象一下，一个家庭里有各种家电，比如电视、冰箱和洗衣机。每个家电都有不同的功能和特点，但它们也有一些共同的基本属性，比如品牌、型号和功率。
每个家电都有品牌、型号和功率。这些共同的特点让我们能够分类和识别这些家电。比如：

电视：可以播放节目、调节音量。
冰箱：可以存储食物、调节温度。
洗衣机：可以洗衣服、选择洗衣模式。

在管理这些家电时，家庭成员可以这样做：

创建家电清单：列出每个家电的基本信息，比如品牌和型号。
定义操作方法：为每种家电设定具体的操作方法，比如如何开关电视，如何调节冰箱的温度，如何选择洗衣机的模式。
维护记录：记录每个家电的使用情况，比如维修历史和使用频率。

在这个故事中，家电就是一个“类”的概念。每个家电（如电视、冰箱、洗衣机）都是这个类的一个具体实例（对象）。这个“类”包含了所有家电共有的属性和功能。
通过将家电按类别组织，并记录每个家电的具体信息和操作方法，家庭成员可以更加高效地管理家电。这就类似于面向对象编程中的方式，通过对事物进行分类和实例化，使得管理和操作变得更有条理。

总而言之，面向对象思想的核心在于通过定义类别（如家电）和管理这些类别的具体实例（如每个电视、冰箱、洗衣机），从而让管理和使用变得更清晰和高效。

三大特征

1. 封装（Encapsulation）

简述：
封装是将数据和操作数据的方法绑定在一起，并隐藏内部的实现细节，只对外部提供必要的接口。这保护了数据的完整性和安全性。

生活中的例子：
想象一个遥控器。遥控器内部有复杂的电路和组件，但你只需要使用几个按钮（如开关、音量、频道）来操作。你不需要知道内部的工作原理，只需使用这些按钮（接口）即可。遥控器的内部细节被封装在外壳中，用户只接触到外部的操作界面。

好处：

数据保护：通过封装，数据和操作数据的方法被绑定在一起，并隐藏内部实现细节。这样，外部代码无法直接修改数据，从而保护数据的完整性和一致性。
代码维护：封装使得类的内部实现与外部接口分离。修改内部实现不会影响到使用这个类的代码，使得维护和更新变得更加容易。
提高模块化：封装将相关的属性和方法组织在一起，使得代码更加模块化和清晰。这有助于代码的重用和理解。

比如使用手机应用时，用户通过简洁的界面操作应用功能，而不需要了解应用的复杂内部逻辑。

2. 继承（Inheritance）

简述：
继承允许一个对象从另一个对象继承属性和行为。通过继承，可以创建一个新类型，并在现有类型的基础上增加或修改功能。

生活中的例子：
想象一个家族的遗传特征。父母可能有一些共同的特征（如眼睛颜色、头发颜色），这些特征会遗传给孩子。孩子继承了父母的特征，但也可能有自己的特点（如不同的眼睛颜色）。在这个例子中，孩子继承了父母的特征，但也增加了自己的新特征。

好处：

代码重用：通过继承，子类可以复用父类已经实现的代码，减少了重复的代码编写，提高了开发效率。
扩展性：继承使得可以在现有的类基础上创建新的类，并添加新的功能或修改现有功能，从而灵活地扩展系统。
层次结构：继承创建了类之间的层次结构，使得系统的设计更具组织性和逻辑性。

我们可以想象，在一个电动车生产线中，所有电动车共享基本的电动机和车轮设计。生产特定类型的电动车（如跑车、城市车）时，只需要在基本设计的基础上进行定制，而不是从头开始设计每一辆车。

3. 多态（Polymorphism）

简述：
多态允许对象以不同的方式执行相同的操作。即使操作的形式相同，不同对象可以展现不同的行为。

生活中的例子：
想象你在家里有一个多功能设备，比如一个智能家居系统。你可以通过语音命令来控制这个系统，比如“播放音乐”。无论你说的是“播放流行音乐”还是“播放古典音乐”，系统会根据不同的命令（对象）展示不同的行为（播放不同的音乐类型）。这就是多态的体现：相同的操作（播放音乐），不同的设备（命令）可以有不同的执行结果。

好处：

灵活性：多态允许同一操作在不同对象上有不同的表现，使得代码更加灵活和可扩展。可以编写通用的代码来处理不同类型的对象。
简化代码：通过多态，可以使用相同的方法调用不同对象的不同实现，简化了代码逻辑，并减少了条件判断的复杂性。
增强可维护性：多态使得系统更容易适应新的需求或变化，只需在子类中实现特定行为即可，无需修改使用这些对象的代码。

示例：
在音乐播放器中，用户可以播放各种类型的媒体文件（如音乐、播客、音频书）。播放器使用相同的“播放”命令来处理不同的媒体类型，而具体的播放方式由每种媒体类型的实现来决定。

面向对象JAVA

Java本质上就是一个面向对象编程的语言，其中有个最重要的概念，类，抽象和对象。何为类，何为抽象呢，我们可以理解为，万物有类，万物皆有抽象，万物皆为对象。
首先拿抽象来说，抽象其实就是一个概念，只不过我们使用编程语言将他表示了出来，在JAVA编程中，我们首先接触的都是管理系统，比如在图书馆系统中，不同类型的媒体资源（如书籍、杂志、DVD）尽管各自有不同的形式和特点，但它们都共享一些核心特征，如标题、作者、出版日期等，并且都可以被借出和归还。通过抽象，我们可以定义一个通用的Media类或接口，来表示这些共同的特征和行为，而具体的媒体类型（如Book、Magazine、DVD）则各自实现这些特征，并在需要时扩展或定制具体行为。这样，抽象使得系统在处理各种媒体资源时更为简单和一致，同时也易于扩展和维护。

面向对象编程在Java中的实现

面向对象编程（OOP）在Java中通过类和对象的创建与使用来实现。OOP的核心原则是封装、继承和多态，这些原则帮助构建结构化、模块化、可扩展的代码。以下是如何在Java中进行面向对象编程的基本步骤。

1. 定义类（Class）

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

步骤：

声明一个类，并定义其属性和方法。
属性通常是类的成员变量，方法是类的行为。

public class Car {
    // 属性
    private String color;
    private String model;

    // 构造函数
    public Car(String color, String model) {
        this.color = color;
        this.model = model;
    }

    // 方法
    public void drive() {
        System.out.println("The car is driving.");
    }
}

2. 创建对象（Object）

对象是类的实例。通过类的构造函数创建对象，赋予其独立的状态，并调用类中的方法来执行操作。

步骤：

使用new关键字创建对象。
调用对象的方法来执行操作。

public class Main {
    public static void main(String[] args) {
        // 创建对象
        Car myCar = new Car("Red", "Toyota");

        // 调用对象的方法
        myCar.drive();
    }
}

3. 使用封装（Encapsulation）

封装是将类的属性私有化（使用private关键字），并通过公共方法（getter和setter）来访问和修改这些属性。

步骤：

将类的属性声明为private。
提供public的getter和setter方法来访问和修改这些属性。

public class Car {
    private String color;

    // Getter方法
    public String getColor() {
        return color;
    }

    // Setter方法
    public void setColor(String color) {
        this.color = color;
    }
}

4. 实现继承（Inheritance）

继承允许一个类（子类）继承另一个类（父类）的属性和方法，子类可以重用父类的代码并添加新的功能。

步骤：

使用extends关键字让子类继承父类。
子类可以直接使用父类的属性和方法，或者重写父类的方法。

public class ElectricCar extends Car {
    private int batteryLevel;

    public ElectricCar(String color, String model, int batteryLevel) {
        super(color, model);
        this.batteryLevel = batteryLevel;
    }

    public void charge() {
        System.out.println("The car is charging.");
    }
}

5. 实现多态（Polymorphism）

多态允许同一方法在不同对象上表现出不同的行为。多态通过方法重写（overriding）和方法重载（overloading）来实现。

步骤：

使用父类的引用来调用子类的重写方法，实现多态。
方法重载允许同一个类中存在多个同名方法，但参数不同。

public class Main {
    public static void main(String[] args) {
        Car myCar = new ElectricCar("Blue", "Tesla", 100);

        // 调用重写的方法
        myCar.drive(); // 输出: The car is driving. (ElectricCar类的实现)
    }
}

6. 使用抽象类和接口

抽象类和接口定义了类应该具备的核心功能，而具体实现由子类或实现类提供。

步骤：

使用abstract关键字定义抽象类，并在其中声明抽象方法。
使用implements关键字让类实现接口。

abstract class Animal {
    abstract void makeSound();
}

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

interface Drawable {
    void draw();
}

class Circle implements Drawable {
    public void draw() {
        System.out.println("Drawing a circle");
    }
}