抽象和封装之间的区别？

Question

封装和抽象之间的确切区别是什么？

Answer 1

这里的大多数答案都集中在OOP上，但封装开始的时间要早​​得多：

• 每个功能都是encapsulation ;在伪代码中：

  point x = { 1, 4 }
  point y = { 23, 42 }
  
  numeric d = distance(x, y)
  

  这里，distance封装了平面中两点之间（欧几里德）距离的计算：它隐藏了实现细节。这是封装，纯粹而简单。

• Abstraction是概括 的过程：采取具体实施并使其适用于不同的（尽管有些相关）数据类型。经典的抽象示例是C的qsort函数来排序数据：

  关于qsort的问题在于它并不关心它排序的数据 - 事实上，它不知道它排序的数据。相反，它的输入类型是无类型指针（void*），它只是C的说法“我不关心数据的类型”（这也称为类型擦除）。重要的是，无论数据类型如何，qsort的实现始终保持不变。 要改变的唯一事情是比较功能，它不同于数据类型和数据类型。因此qsort期望用户将所述比较函数作为函数参数提供。

封装和抽象齐头并进，以至于你可以说明它们是真正不可分割的。出于实际目的，这可能是真的;这就是说，这是一个不太抽象的封装：

class point {
    numeric x
    numeric y
}

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

这是一个抽象的例子，它不是封装：

T pi<T> = 3.1415926535

这是一个具有给定值（π）的泛型变量 pi，声明并不关心变量的确切类型。不可否认，我很难在实际代码中找到这样的东西：抽象几乎总是使用封装。但是，上面的 实际上存在于C ++（14）中，通过variable templates（=变量的通用模板）;语法稍微复杂一些，例如：

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

Answer 2

封装隐藏了实现细节，这些细节可能是也可能不是针对通用行为或专门行为。

抽象正在提供一种概括（例如，通过一组行为）。

这是一篇很好的读物：Abstraction, Encapsulation, and Information Hiding来自Object Agency的Edward V. Berard。

Answer 3

许多答案和他们的例子都是误导性的。

Encapsulation是将数据和函数在该数据上运行打包到单个组件中并限制对某些对象的访问组件。
封装意味着对象的内部表示通常隐藏在对象定义之外的视图中。

Abstraction是一种代表基本功能而不包含实现细节的机制。

封装： - 信息隐藏 抽象： - 实施隐藏。

示例：

class foo{
    private:
        int a, b;
    public:
        foo(int x=0, int y=0): a(x), b(y) {}

        int add(){    
            return a+b;   
        } 
}  

foo类的任何对象的内部表示都隐藏在类之外。 - ＆GT;封装。
foo对象的任何可访问成员（数据/函数）都受到限制，并且只能由该对象访问。

foo foo_obj(3, 4);
int sum = foo_obj.add();

隐藏了方法add的实现。 - ＆GT;抽象。

Answer 4

封装将一些东西放在一个盒子里，然后给你一个窥视孔;这可以防止你碰到齿轮。

抽象平局忽略了无关紧要的细节，比如是否有齿轮，棘齿，飞轮或核心;他们只是“走”

封装的例子：

• 内裤
• 工具箱
• 钱包
• 手提包
• 胶囊
• 冷冻碳酸盐
• 一个盒子，上面有或没有按钮
• 卷饼（技术上，卷饼周围的玉米饼）

抽象的例子：

• “事物组”是一种抽象（我们称之为聚合）
• “包含其他东西的东西”是一种抽象（我们称之为构图）
• “容器”是另一种“包含其他东西”的抽象概念;请注意，所有封装示例都是各种容器，但并非所有容器都展示/提供封装。例如，篮子是一种不封装其内容物的容器。

Answer 5

Encapsulation 表示隐藏数据，例如使用getter和setter等。

Abstraction 表示使用抽象类和接口等隐藏实现。

Answer 6

  

抽象是一般术语。即封装是抽象的子集。

例2：
解决方案架构师是为整个解决方案创建高级抽象技术设计的人员，然后将此设计移交给开发团队< / strong>用于实施。

在这里，解决方案架构师充当抽象，开发团队充当封装。

Courtesy

Answer 7

上面提供了很多好的答案，但我将在这里提出我的（Java）观点。

数据封装只是意味着包装和控制对类中逻辑分组数据的访问。它通常与另一个关键字相关联 - 数据隐藏。这是使用access modifiers在Java中实现的。

一个简单的例子是定义一个私有变量，并使用getter和setter方法提供对它的访问，或者将一个方法设为私有，因为它只使用该类。用户无需了解这些方法和变量。

注意：不应该误解封装只是关于数据隐藏。当我们说封装时，重点应放在分组或打包或捆绑相关数据和行为上。

另一方面，

数据抽象是概括的概念，因此下面的复杂逻辑不会暴露给用户。在Java中，这是通过使用interfaces和abstract类来实现的。

示例 -

假设我们有一个界面动物，它有一个函数 makeSound（）。实现此接口有两个具体的类 Dog 和 Cat 。这些具体类具有makeSound（）函数的单独实现。现在让我们说我们有一只动物（我们从一些外部模块得到这个）。所有用户都知道它接收的对象是动物，用户有责任打印动物声音。一种强力方式是检查收到的对象识别它的类型，然后类型转换它到那个Animal类型，然后调用 makeSound（）它。但更简洁的方法是抽象出来。使用Animal作为多态参考并在其上调用makeSound（）。在运行时，取决于真正的对象类型是什么，将调用适当的函数。

更多详情here。

复杂逻辑位于电路板中，封装在触摸板中，并提供了一个漂亮的界面（按钮）来将其抽象给用户。

PS：以上链接是我个人的博客。

Answer 8

• 抽象让您专注于对象的作用而不是它的作用
• 封装意味着隐藏对象如何做某事的内部细节或机制。

就像你开车时一样，你知道油门踏板的作用但你可能不知道它背后的过程，因为它是封装的。

让我举一个C＃的例子。假设你有一个整数：

int Number = 5;
string aStrNumber = Number.ToString();

您可以使用Number.ToString（）之类的方法返回数字5的字符表示形式，并将其存储在字符串对象中。该方法会告诉您它的作用而不是它是如何做的。

Answer 9

这些有些模糊的概念并非计算机科学和编程所独有。我想提供一些额外的想法，可以帮助其他人理解这些重要的概念。

简答

封装 - 隐藏和/或限制对系统某些部分的访问，同时公开必要的接口。

抽象 - 除了具体的现实，特定的对象或实际的实例之外，考虑删除某些特征的东西，从而降低复杂性。

主要的相似性是这些技术旨在提高理解力和实用性。

主要差异是抽象是一种更简单地表示事物的方法（通常是为了使表示更广泛适用），而封装是一种改变其他事物互动方式的方法与某事。

长答案

封装

这是一个封装的例子，希望能让事情变得更加清晰：

这里我们有一个Arduino Uno，以及一个机箱内的Arduino Uno。封装是封装的全部代表。

封装旨在保护某些组件免受外部影响和知识的影响，以及暴露其他东西应该与之交互的组件。在编程术语中，这涉及information hiding虽然access modifiers，它改变了可以读取和写入某些变量和/或属性的程度。

但除此之外，封装还旨在更有效地提供这些外部接口。通过我们的Arduino示例，这可以包括漂亮的按钮和屏幕，这使得用户与设备的交互更加简单。它们为用户提供了影响设备行为的简单方法，并获得了有关其操作的有用信息，否则这些信息会更加困难。

在编程中，这涉及将各种组件分组为可分离的构造，例如function，class或object。它还包括提供与这些结构交互的方法，以及获取有关它们的有用信息的方法。

封装可以通过许多其他方式帮助程序员，尤其是改进的代码可维护性和可测试性。

抽象

虽然这里的许多其他答案都将抽象定义为概括，但我个人认为该定义是错误的。我会说泛化实际上是一种特定的类型的抽象，而不是相反。换句话说，所有的推广都是抽象，但所有的抽象都不是而不是必然的概括。

以下是我喜欢抽象的方法：

你会说有一棵树的图像吗？你有可能。但它真的一棵树吗？好吧，当然不是！它是一堆看起来像我们称之为树的像素。我们可以说它代表了一棵真树的抽象。请注意，省略了树的几个可视细节。此外，它不会生长，消耗水或产生氧气。怎么可能呢？它只是屏幕上的一堆颜色，由计算机内存中的字节表示。

这是抽象的本质。它是一种简化事物的方式，因此更容易理解。贯穿始终的每一个想法都是对现实的抽象。你的树的心理形象不再是这个jpeg的实际树。

在编程中，我们可以通过使用模拟生长，耗水和氧气生成的方法创建Tree类来利用它。我们的创作将代表我们对实际树木的体验，并且仅包括我们真正关心的特定模拟元素。我们使用抽象作为表示我们对字节和数学的经验的一种方式。

抽象类

编程中的抽象也允许我们考虑几个＆＃34;具体＆＃34;之间的共性。对象类型（实际存在的类型）并在唯一实体中定义这些共性。例如，我们的Tree类可以从abstract class Plant继承，它有几个属性和方法适用于我们所有类似工厂的类，但删除那些特定于每种植物类型。这可以显着减少代码重复，并提高可维护性。

abstract class和普通class的实际差异在于概念上没有＆＃34;真实＆＃34; abstract class的实例。构造Plant对象是没有意义的，因为它不够具体。每一个真实的＆＃34; Plant也是一种更具体的Plant类型。

另外，如果我们希望我们的程序更加真实，我们可能会考虑这样一个事实：我们的Tree类本身可能过于抽象。实际上，每个Tree都是Tree的一种更具体的类型，因此我们可以为那些继承自我们的Birch，Maple等类型创建类，也许现在abstract，Tree上课。

JVM

抽象的另一个好例子是Java Virtual Machine (JVM)，它为运行的Java代码提供虚拟或抽象计算机。它基本上剥夺了系统的所有平台特定组件，并提供了一个抽象的“计算机”界面。不考虑任何系统。

差异

封装与抽象的不同之处在于，它与“真实”和“真实”之间没有任何关系。或者＆＃39;准​​确＆＃39;事情是。它没有删除某些内容的组件，以使其更简单或更广泛适用。相反，它可以隐藏某些组件以实现类似的目的。

Answer 10

封装：从对象的实际用户隐藏不需要/不期望/正当的实现细节。 e.g。

List<string> list = new List<string>();
list.Sort(); /* Here, which sorting algorithm is used and hows its 
implemented is not useful to the user who wants to perform sort, that's 
why its hidden from the user of list. */

抽象：是一种提供泛化的方式，因此是一种处理各种各样对象的常用方法。 e.g。

class Aeroplane : IFlyable, IFuelable, IMachine
{ // Aeroplane's Design says:
  // Aeroplane is a flying object
  // Aeroplane can be fueled
  // Aeroplane is a Machine
}
// But the code related to Pilot, or Driver of Aeroplane is not bothered 
// about Machine or Fuel. Hence,
// pilot code:
IFlyable flyingObj = new Aeroplane();
flyingObj.Fly();
// fighter Pilot related code
IFlyable flyingObj2 = new FighterAeroplane();
flyingObj2.Fly();
// UFO related code 
IFlyable ufoObj = new UFO();
ufoObj.Fly();
// **All the 3 Above codes are genaralized using IFlyable,
// Interface Abstraction**
// Fly related code knows how to fly, irrespective of the type of 
// flying object they are.

// Similarly, Fuel related code:
// Fueling an Aeroplane
IFuelable fuelableObj = new Aeroplane();
fuelableObj.FillFuel();
// Fueling a Car
IFuelable fuelableObj2 = new Car(); // class Car : IFuelable { }
fuelableObj2.FillFuel();

// ** Fueling code does not need know what kind of vehicle it is, so far 
// as it can Fill Fuel**

Answer 11

抽象和封装之间的差异。

Answer 12

抽象：以简化/不同方式呈现内容的想法，这种方式更容易理解和使用，或者与情况更相关。

考虑一个发送电子邮件的类......它使用抽象向你展示自己作为某种信使的男孩，所以你可以调用emailSender.send（邮件，收件人）。它实际上做了什么 - 选择POP3 / SMTP，调用服务器，MIME翻译等，被抽象掉了。你只看到你的使者男孩。

封装：保护和隐藏对象私有的数据和方法的想法。它更多地涉及制作独立且万无一失的东西。

以我为例。我把自己的心率从世界其他地方封装起来。因为我不希望任何其他人改变该变量，我不需要任何其他人来设置它以便我运行。它对我来说至关重要，但你不需要知道它是什么，你可能也不在乎。

环顾四周，你会发现你触摸的几乎所有内容都是抽象和封装的一个例子。例如，您的手机向您展示了能够接受您所说的话并向其他人说出的抽象 - 覆盖GSM，处理器架构，无线电频率以及您不理解或不关心的其他一百万件事。它还封装了您的某些数据，如序列号，ID号，频率等。

这一切都让世界变得更加美好：D

Answer 13

抽象：仅显示必要的信息。让我们关注打开计算机的例子。用户不必知道系统仍在加载时发生了什么（该信息对用户是隐藏的）。

让我们举一个例子，ATM的例子。客户不需要知道机器如何读取PIN并处理交易，他只需输入PIN码，拿走现金并离开。

封装：隐藏clas的敏感数据，从而私有化其中的一部分。这是一种通过不允许从外部访问它来将某些信息保密给客户的方法。

Answer 14

另一个例子：

假设我创建了一个不可变的Rectangle类，如下所示：

class Rectangle {
 public:
  Rectangle(int width, int height) : width_(width), height_(height) {}
  int width() const { return width_; }
  int height() const { return height_; }

 private:
  int width_;
  int height_;
}

现在很明显我已经封装宽度和高度（访问受到某种程度的限制），但我没有抽象任何东西（好吧，也许我已经忽略了）矩形位于坐标空间中，但这是示例的缺陷。

良好的抽象通常意味着良好的封装。

良好抽象的一个例子是通用数据库连接类。它的公共接口是数据库无关的，非常简单，但允许我通过连接做我想做的事情。而你看到了吗？那里还有封装，因为类必须具有所有低级句柄和内部调用。

Answer 15

使用单个通用示例

Abstraction 和 Encapsulation

<强> -------------------------------------------- -------------------------------------------------- --------------------------------------

我们都使用计算器计算复杂问题！

Answer 16

抽象：抽象意味着展示What部分功能。

封装：封装意味着隐藏功能的How部分。

让我们举一个非常简单的例子

/// <summary>
/// We have an Employee class having two properties EmployeeName and EmployeeCode
/// </summary>
public class Employee
{
    public string EmplpyeeName { get; set; }
    public string EmployeeCode { get; set; }

    // Add new employee to DB is the main functionality, so are making it public so that we can expose it to external environment
    // This is ABSTRACTION
    public void AddEmployee(Employee obj)
    {
        // "Creation of DB connection" and "To check if employee exists" are internal details which we have hide from external environment
        // You can see that these methods are private, external environment just need "What" part only
        CreateDBConnection();
        CheckIfEmployeeExists();
    }


    // ENCAPLUSATION using private keyword
    private bool CheckIfEmployeeExists()
    {
        // Here we can validate if the employee already exists
        return true;
    }

    // ENCAPLUSATION using private keyword
    private void CreateDBConnection()
    {
        // Create DB connection code
    }
}

控制台应用程序的程序类

class Program
{
    static void Main(string[] args)
    {
        Employee obj = new Employee();
        obj.EmplpyeeName = "001";
        obj.EmployeeCode = "Raj";

        // We have exposed only what part of the functionality
        obj.AddEmployee(obj);
    }
}

Answer 17

防止特定对象的数据无法被外部函数故意或意外滥用的机制称为“数据封装”

在不包含背景细节或解释的情况下表示基本要素的行为称为抽象

Answer 18

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

现在抽象只暴露接口push和pop。底层表示是隐藏的（它是一个数组还是一个链表？），并提供了一个定义良好的接口。现在，您如何确保不会对抽象数据进行意外访问？这就是封装的用武之地。例如，C ++中的类使用访问说明符来确保防止意外访问和修改。而且，通过将上述接口公之于众，它确保了操纵堆栈的唯一方法是通过定义良好的接口。在这个过程中，它已经耦合了数据和可以操作它的代码（让我们不在这里涉及友元函数）。也就是说，代码和数据被绑定在一起或绑定或封装。

Answer 19

抽象---隐藏实现 - 设计 - 使用接口/抽象calsses

封装 - 隐藏数据 - 开发---使用访问修饰符（公共/私有）

Answer 20

封装正在将一个胶囊中的复杂性包含在一个类和一个胶囊中。因此封装...... 虽然抽象是一个与其他对象不同的对象的特征......

抽象可以通过使具有一个或多个方法抽象的类抽象来实现。这只不过是扩展它的类应该实现的特性。 例如当你发明/设计汽车时，你定义了一个特征，比如汽车应该有4个门，断裂，方向盘等......所以任何使用这种设计的人都应该包括这个特性。实现不是每个抽象的头。它只会定义应该包含的特征。

实现封装，将数据和行为保持在一个类别＆amp;通过使用访问修饰符，如public，private，protected以及继承，聚合或组合。因此，您只展示所需的东西，也只展示您想要展示的范围。即公共，受保护，友好和私人基础...... 例如GM决定使用上面提到的汽车设计。但它们具有各种具有相同特性的产品。做几乎相同的功能。所以他们写了一个扩展上面抽象类的类。它说明了齿轮箱应该如何工作，应该如何工作，方向盘应该如何工作。然后所有产品都使用这种通用功能。他们不需要知道齿轮箱是如何工作的，也不知道工程或转向风的工作原理。 Indivisual产品肯定会有更多功能，如a / c或自动锁等...... ..

两者都很强大;但是使用抽象需要比封装更多的技能，更大的应用程序/产品无法在不抽象的情况下生存。

Answer 21

以下段落帮助我了解它们之间的差异：

  

数据封装是一种捆绑数据的机制，而且   使用它们和数据抽象的函数是一种机制   仅公开接口并隐藏实现细节   来自用户。

您可以阅读更多here。

Answer 22

来自this

OOPS中封装和抽象之间的差异

抽象和封装是两个重要的面向对象编程（OOPS）概念。封装和抽象都是相互关联的术语。

封装和抽象之间的真实生活差异

封装意味着隐藏。封装也称为数据隐藏。你可以认为封装就像一个胶囊（药片），它将药物藏在里面。封装是包装，只是隐藏属性和方法。封装用于在单个单元中隐藏代码和数据，以保护数据免受外界影响。类是封装的最佳示例。

抽象是指仅向目标用户显示必要的详细信息。顾名思义，抽象是“任何事物的抽象形式”。我们在编程语言中使用抽象来创建抽象类。抽象类表示类的方法和属性的抽象视图。

封装和抽象之间的实施差异

1. 使用接口和抽象类实现抽象，而使用私有和受保护的访问修饰符实现Encapsulation。

2. OOPS通过阻止程序员以非预期的方式访问数据，利用封装来强制执行类型的完整性（即，以确保以适当的方式使用数据）。通过封装，只有预定的一组功能可以访问数据。与访问限制（公共/私人等）捆绑在一起的数据类型和操作（方法）的集合术语是一个类。

Answer 23

我将尝试以简单的方式演示封装。让我们看看..

• 将数据和功能整合到一个单元中（称为 class）被称为封装。包含和隐藏的封装 有关对象的信息，例如内部数据结构和 代码。

封装是 -

• 隐藏复杂性，
• 将数据和功能绑定在一起，
• 使复杂方法变得私密，
• 将实例变量设为私有，
• 隐藏最终用户不必要的数据和功能。

封装实现抽象。

抽象是 -

• 显示什么是必要的，
• 数据需要从最终用户抽象，

让我们看一个例子 -

下图显示了“要添加到数据库中的客户详细信息”的GUI。

通过查看图片，我们可以说我们需要一个客户类。

步骤1：我的客户类需要什么？

即

• 存储客户代码和客户名称的2个变量。

• 1将客户代码和客户名称添加到数据库中的功能。

  命名空间CustomerContent { 公共级客户 { public string CustomerCode =“”; public string CustomerName =“”; public void ADD（） { //我的数据库代码会在这里 }

现在只有ADD方法不能单独使用。

步骤-2：验证如何工作，ADD功能如何？

我们需要数据库连接代码和验证码（额外方法）。

public bool Validate()
{
    //Granular Customer Code and Name
    return true;
}

public bool CreateDBObject()
{
    //DB Connection Code
    return true;
}


class Program
{
static void main(String[] args)
{
CustomerComponent.Customer obj = new CustomerComponent.Customer;

obj.CustomerCode = "s001";
obj.CustomerName = "Mac";

obj.Validate();
obj.CreateDBObject();

obj.ADD();
}
}

现在不需要向最终用户显示额外方法（Validate（）; CreateDBObject（）[复杂和额外方法]）。用户只需要查看并了解客户代码，客户名称和ADD按钮这将添加记录..最终用户不关心如何将数据添加到数据库？。

步骤-3：隐藏不涉及最终用户交互的额外且复杂的方法。

因此将那些复杂和额外的方法变为私有而不是公共（即隐藏这些方法）并删除obj.Validate（）; obj.CreateDBObject（）;从主类课程中我们实现了封装。

换句话说，简化最终用户界面就是封装。

所以现在代码如下所示 -

namespace CustomerContent
{
public class Customer
{
public string CustomerCode = "";
public string CustomerName = "";
public void ADD()
{
   //my DB code will go here
}

private bool Validate()
{
    //Granular Customer Code and Name
    return true;
}

private bool CreateDBObject()
{
    //DB Connection Code
    return true;
}


class Program
{
static void main(String[] args)
{
CustomerComponent.Customer obj = new CustomerComponent.Customer;

obj.CustomerCode = "s001";

obj.CustomerName = "Mac";

obj.ADD();
}
}

摘要：

步骤-1：我的客户类需要什么？是抽象。

步骤-3：步骤-3：隐藏不涉及最终用户交互的额外且复杂的方法是封装。

P.S。 - 上面的代码很难，很快。

Answer 24

抽象或封装不严格要求信息隐藏。信息可能会被忽略，但不必隐藏。

封装 是将某事物视为单一事物的能力，即使它可能由许多复杂的部分或想法组成。例如，我可以说我我坐在一把“椅子”里，而不是指那把椅子的各个部分，每个部分都有一个特定的设计和功能，所有部分都精确地配合在一起，以便舒适地将我的屁股从地板上移开几英尺。

通过封装启用

抽象。因为我们封装了对象，所以我们可以将它们视为以某种方式相互关联的事物，而不是陷入内部对象结构的微妙细节中。 抽象是能够考虑更大的图景，从关注细节中删除。这个词的根是抽象的，如在学术论文顶部出现的摘要中，而不是像只能实例化为派生子类的类。

我可以诚实地说，当我把我的屁股放在椅子上时，我从未想过那把椅子的结构会如何抓住并保持我的体重。这是一个不错的椅子，我不必担心这些细节。所以我可以将注意力转向我的电脑。而且，我不会考虑计算机的组成部分。我只是看一个代表我可以输入的文本区域的网页的一部分，我正在用语言进行交流，几乎没有考虑我的手指如何在键盘上如此快速地找到正确的字母，以及如何最终在点击这些键并发布到此论坛之间建立连接。这是抽象的强大力量。由于可以信任系统的较低级别以保持一致性和精确性，因此我们需要注意更多的工作。

Answer 25

Abstraction是我们要执行的实施的合同。实施可能会在一段时间内发生变化。各种实现本身可能隐藏也可能不隐藏，但在抽象背后隐藏 Masked 。

假设我们在APIs中定义了一个类的所有interface，然后要求我们代码的用户依赖于APIs的已定义interface。我们可以自由地改进或修改实施，只有我们必须遵守设定的合同。用户与我们的实施不是耦合。

我们在抽象中展示所有必需规则（方法），规则的实现留给实现者实体，实现也不是抽象的一部分。只是签名和声明是抽象的原因。

Encapsulation只是通过减少状态和行为的访问来 HIDING 内部细节。封装的类可能有也可能没有明确定义Abstraction。

java.util.List是java.util.ArrayList的抽象。 java.util.ArrayList标有non public访问修饰符的内部状态是封装。

修改 假设类Container.nava implements IContainer，IContainer可以声明类似addElement，removeElements，contains等方法。此处IContainer表示其实现的抽象类。抽象是将类的API或模块或系统声明为外部世界。这些API成为contract。 该系统可能已经或可能尚未开发。系统的用户现在可以依赖于声明的API，并确保实现此类合同的任何系统始终遵循声明的API，它们将始终为这些API提供tge实现。一旦我们编写了一些具体的实体，那么决定隐藏我们的内部状态就是封装

Answer 26

class Aeroplane : IFlyable, IFuelable, IMachine
{ // Aeroplane's Design says:
  // Aeroplane is a flying object
  // Aeroplane can be fueled
  // Aeroplane is a Machine
}
// But the code related to Pilot, or Driver of Aeroplane is not bothered 
// about Machine or Fuel. Hence,
// pilot code:
IFlyable flyingObj = new Aeroplane();
flyingObj.Fly();
// fighter Pilot related code
IFlyable flyingObj2 = new FighterAeroplane();
flyingObj2.Fly();
// UFO related code 
IFlyable ufoObj = new UFO();
ufoObj.Fly();
// **All the 3 Above codes are genaralized using IFlyable,
// Interface Abstraction**
// Fly related code knows how to fly, irrespective of the type of 
// flying object they are.

// Similarly, Fuel related code:
// Fueling an Aeroplane
IFuelable fuelableObj = new Aeroplane();
fuelableObj.FillFuel();
// Fueling a Car
IFuelable fuelableObj2 = new Car(); // class Car : IFuelable { }
fuelableObj2.FillFuel();

// ** Fueling code does not need know what kind of vehicle it is, so far 
// as it can Fill Fuel**

Answer 27

抽象和封装过程都会生成接口。

通过封装生成的接口隐藏了实现细节。

与抽象之前相比，通过抽象生成的接口适用于更多数据类型。

Answer 28

抽象是隐藏用户的非有用数据 和封装将数据绑定到一个胶囊（一个类）。 我认为封装是我们实现抽象的方式。

Answer 29

在短

抽象使用 - ＆gt;封装  ＆安培;  封装使用 - ＆gt;数据隐藏

OR

数据隐藏是Encapsulation的子集和 封装是抽象的一个子集

参考：http://www.tonymarston.co.uk/php-mysql/abstraction.txt

Answer 30

我认为封装是一种实现抽象的方法。看看以下链接。

Abstraction and Encapsulation

Answer 31

我试图在抽象和封装之间画一条线，根据我的说法，Abstraction更像是概念性的东西，因为封装是抽象实现之一。因为可以在没有封装的情况下隐藏数据，例如使用私有常量或变量;所以我们可以使用封装数据隐藏，但数据隐藏并不总是封装。在下面的代码中，我试图描述这些概念的最简单形式。

    // Abstraction
    interface IOperation
    {
        int SquareNumber();
    }

    public class Operation
    {
        // Data hiding
        private int number;

        public Operation(int _number)
        {
            this.number = _number;
        }

        // Encapsulation
        public int SquareNumber()
        {
            return number * number;
        }
    }

在行动中，

IOperation obj = new Operation(2); 
// obj.number  <--- can't access because hidden from world using private access modifier but not encapsulated. 
obj.SquareNumber(); // cannot access internal logic to calculate square because logic is hidden using encapsulation.

Answer 32

让我用简单的代码示例

来试试这个

抽象=数据隐藏+封装

FileReader

Answer 33

抽象和封装都可以隐藏数据。但是有很大的不同。

封装

封装是将数据和对数据进行操作的代码绑定或包装到称为Class的单​​个单元中的过程。

封装在实现级别解决了这个问题。

在课堂上，您可以使用私有或受保护的访问修饰符隐藏数据。

抽象

抽象是隐藏无关细节的概念。换句话说，通过向用户隐藏不必要的细节，可以简化复杂的系统。

抽象解决了设计方面的问题。

您可以通过在Java中创建接口和抽象类来实现抽象。

在ruby中，您可以通过创建模块来实现抽象。

Ex：我们将Enumerable模块的方法（收集，映射，缩小，排序...）与Ruby中的Array和Hash一起使用。

Answer 34

简而言之：

抽象是一种技术，可以帮助我们确定哪些特定信息是必不可少的，哪些信息应该隐藏。

然后，

封装是一种用于封装信息的技术，它可以隐藏对象的详细信息和实现详细信息。

Answer 35

抽象

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

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

封装

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

在编程方面： 让我们考虑一个Class Car。 在下面的示例中，用户只需要知道旋转钥匙（turnKey（）方法），他就不了解内部功能。用户不需要了解任何内部功能或内部组件。

在这种情况下，所有私有方法都是内部函数，私有字段（例如“ Piston 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();
        ...
    }
}

Answer 36

之间存在差异

  

ABSTRAACTION

和

  

ENCAPSULATION

1.    First difference between Abstraction and Encapsulation is that, Abstraction is implemented in Java using interface and abstract class while Encapsulation is implemented using private, package-private and protected access modifier.

2.    Data abstraction simply means generalizing something to hide the complex logic that goes underneath where Encapsulation is DATA HIDING.


3.    Encapsulation is combining related logic data (variables and methods) where as Abstraction is hiding internal implementation details and expose only relevant details to the user. In a way you can Abstraction is achieved by Encapsulation.

Answer 37

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

抽象为您提供了类的通用视图。

Answer 38

封装是抽象的一个例子。封装的全部内容是抽象函数内部的内容，减少符号的所有复杂性（函数的引用或名称），将函数转换为黑盒子。

在编程中，单词＆＃34; abstract＆＃34;是一个命令。当一个类继承一个抽象类（或接口）时，你被命令创建一个抽象。

Answer 39

有一件事，或许其他答案忘记提及的一个基本问题是，封装是抽象。因此，将两者进行对比并寻找差异并不准确，而是将封装视为一种抽象形式。