抽象

抽象是提取所有现有和可预见实现的公共属性和字段的过程。

例如: 轿车是轿车、掀背车、SUV、双门跑车、敞篷车的抽象概念。 Car将具有所有类型的汽车所共有的所有属性和字段。

封装

封装是对用户隐藏不需要的细节的过程。这个术语来自于胶囊。就像药物隐藏在胶囊里一样。各种机器和设备和设备的细节，从搅拌机，自行车，洗衣机，收音机，电视到飞机。您不希望用户可以看到机器的所有细节。

在编程方面: 让我们考虑一个等级汽车。 在下面的例子中，所有用户需要知道的是转动键(turnKey()方法)，他不知道内部函数。用户不需要了解任何内部功能或内部组件。

在这种情况下，所有的私有方法都是内部函数，像“活塞p1”这样的私有字段是用户不需要知道的内部数据。

public class Car{

    private void startMotor(){ //do something }
    private void generateVoltage(){ //do something }
    private void sparkPlugIgnition(){ //do something }
    private void fuelFlowFromTankToInjector(){ //do something }
    private void pushPistonsDown() { 
               p1.doAction();
               p2.doAction();
               //do something    }
    private void moveCrankShaft(){ //do something }

    private Piston p1;
    private Piston p2;

    public void turnKey(){
        startMotor();
        generateVoltage();
        sparkPlugIgnition();
        fuelFlowFromTankToInjector();
        pushPistonsDown();
        moveCrankShat();
        ...
    }
}

这里的大多数答案都关注于OOP，但封装开始得更早:

Every function is an encapsulation; in pseudocode: point x = { 1, 4 } point y = { 23, 42 } numeric d = distance(x, y) Here, distance encapsulates the calculation of the (Euclidean) distance between two points in a plane: it hides implementation details. This is encapsulation, pure and simple. Abstraction is the process of generalisation: taking a concrete implementation and making it applicable to different, albeit somewhat related, types of data. The classical example of abstraction is C’s qsort function to sort data: The thing about qsort is that it doesn't care about the data it sorts — in fact, it doesn’t know what data it sorts. Rather, its input type is a typeless pointer (void*) which is just C’s way of saying “I don't care about the type of data” (this is also called type erasure). The important point is that the implementation of qsort always stays the same, regardless of data type. The only thing that has to change is the compare function, which differs from data type to data type. qsort therefore expects the user to provide said compare function as a function argument.

封装和抽象是密切相关的，因此您可以认为它们确实是不可分割的。就实际而言，这可能是对的;也就是说，这里有一个不太抽象的封装:

class point {
    numeric x
    numeric y
}

我们封装了点的坐标，但是我们没有实质性地将它们抽象出来，只是在逻辑上对它们进行分组。

这里有一个抽象的例子，它不是封装:

T pi<T> = 3.1415926535

这是一个具有给定值(π)的泛型变量pi，声明并不关心变量的确切类型。诚然，我很难在真实的代码中找到这样的东西:抽象实际上总是使用封装。然而，上面的内容在c++(14)中确实存在，通过变量模板(=变量的通用模板);使用稍微复杂一点的语法，例如:

template <typename T> constexpr T pi = T{3.1415926535};

封装要求模块化。它要求您创建具有数据和处理数据的方法的对象。在这种情况下，您可以将其视为一个模块。

抽象为您提供了类的一般视图。

抽象是对用户隐藏无用的数据 封装是将数据绑定到一个胶囊(类)中。 我认为封装是我们实现抽象的方式。

通过使用单个通用示例进行抽象和封装

------------------------------------------------------------------------------------------------------------------------------------

我们都用计算器来计算复杂的问题!

让我们以堆栈为例。它可以使用数组或链表来实现。但它支持的操作是推送和弹出。

Now abstraction is exposing only the interfaces push and pop. The underlying representation is hidden (is it an array or a linked list?) and a well-defined interface is provided. Now how do you ensure that no accidental access is made to the abstracted data? That is where encapsulation comes in. For example, classes in C++ use the access specifiers which ensure that accidental access and modification is prevented. And also, by making the above-mentioned interfaces as public, it ensures that the only way to manipulate the stack is through the well-defined interface. In the process, it has coupled the data and the code that can manipulate it (let's not get the friend functions involved here). That is, the code and data are bonded together or tied or encapsulated.