封装和抽象之间的确切区别是什么？
问问题
419285 次
40 回答
283
这里的大多数答案都集中在 OOP 上，但封装要早得多：
每个函数都是一个封装；在伪代码中：
point x = { 1, 4 } point y = { 23, 42 } numeric d = distance(x, y)在这里，
distance封装了平面中两点之间（欧几里得）距离的计算：它隐藏了实现细节。这就是封装，纯粹而简单。抽象是泛化的过程：采用具体的实现并使其适用于不同的，尽管有些相关的数据类型。抽象的经典示例是 C
qsort对数据进行排序的函数：问题
qsort是它不关心它排序的数据——事实上，它不知道它对什么数据进行排序。相反，它的输入类型是一个无类型指针 (void*)，这只是 C 语言中“我不关心数据类型”的说法（这也称为类型擦除）。重要的一点是qsort，无论数据类型如何，实现始终保持不变。唯一需要改变的是比较函数，它因数据类型而异。qsort因此期望用户提供所述比较函数作为函数参数。
封装和抽象如此紧密地联系在一起，以至于你可以指出它们是真正不可分割的。出于实际目的，这可能是正确的；也就是说，这是一个不是抽象的封装：
class point {
numeric x
numeric y
}
我们封装了点的坐标，但我们并没有从本质上抽象它们，而是对它们进行逻辑分组。
这是一个不是封装的抽象示例：
T pi<T> = 3.1415926535
这是一个具有给定值 (π) 的泛型变量 pi，声明不关心变量的确切类型。诚然，我很难在实际代码中找到这样的东西：抽象几乎总是使用封装。但是，上述内容确实存在于 C++(14) 中，通过变量模板（= 变量的通用模板）；语法稍微复杂一些，例如：
template <typename T> constexpr T pi = T{3.1415926535};
于 2009-04-13T12:02:28.450 回答
162
许多答案及其示例具有误导性。
封装是将“数据”和“在该数据上运行的函数”打包到一个组件中，并限制对某些对象组件的访问。
封装意味着对象的内部表示通常隐藏在对象定义之外的视图之外。
抽象是一种表示基本特征但不包括实现细节的机制。
封装： ——信息隐藏。
抽象： -实现隐藏。
示例（在 C++ 中）：
class foo{
private:
int a, b;
public:
foo(int x=0, int y=0): a(x), b(y) {}
int add(){
return a+b;
}
}
任何类对象的内部表示foo都隐藏在类之外。--> 封装。
对象的任何可访问成员（数据/函数）foo都受到限制，并且只能由该对象访问。
foo foo_obj(3, 4);
int sum = foo_obj.add();
方法的实现add是隐藏的。--> 抽象。
于 2015-03-24T04:04:41.660 回答
140
封装隐藏了可能适用于也可能不适用于通用或特殊行为的实现细节。
抽象提供了一种概括（例如，对一组行为）。
这是一本很好的读物：Abstract, Encapsulation, and Information Hiding by the Object Agency 的 Edward V. Berard。
于 2009-04-12T20:20:16.297 回答
107
encapsulation puts some things in a box and gives you a peephole; this keeps you from mucking with the gears.
abstraction flat-out ignores the details that don't matter, like whether the things have gears, ratchets, flywheels, or nuclear cores; they just "go"
examples of encapsulation:
- underpants
- toolbox
- wallet
- handbag
- capsule
- frozen carbonite
- a box, with or without a button on it
- a burrito (technically, the tortilla around the burrito)
examples of abstraction:
- "groups of things" is an abstraction (which we call aggregation)
- "things that contains other things" is an abstraction (which we call composition)
- "container" is another kind of "things that contain other things" abstraction; note that all of the encapsulation examples are kinds of containers, but not all containers exhibit/provide encapsulation. A basket, for example, is a container that does not encapsulate its contents.
于 2009-04-12T22:10:58.713 回答
52
于 2015-07-06T10:41:06.543 回答
41
上面提供了很多很好的答案，但我将在这里介绍我的（Java）观点。
数据封装仅仅意味着包装和控制类中逻辑分组数据的访问。它通常与另一个关键字——数据隐藏相关联。这是在 Java 中使用访问修饰符实现的。
一个简单的示例是定义一个私有变量并使用 getter 和 setter 方法授予对它的访问权限，或者将方法设为私有，因为它仅用于类中。用户无需了解这些方法和变量。
注意：不应误解封装只是数据隐藏。当我们说封装时，重点应该是对相关数据和行为进行分组或打包或捆绑在一起。
另一方面，数据抽象是泛化的概念，因此底层的复杂逻辑不会暴露给用户。在 Java 中，这是通过使用接口和抽象类来实现的。
例子 -
假设我们有一个接口 Animal并且它有一个函数makeSound()。有两个具体的类Dog和Cat实现了这个接口。这些具体的类具有 makeSound() 函数的单独实现。现在假设我们有一只动物（我们从一些外部模块中得到它）。所有用户都知道它接收的对象是一些动物，用户有责任打印动物的声音。一种蛮力方法是检查接收到的对象以识别它的类型，然后将其类型转换为该 Animal 类型，然后对其调用makeSound()。但更简洁的方法是将事物抽象出来。使用动物作为多态引用并在其上调用 makeSound()。在运行时，取决于真正的 Object 类型是什么，适当的函数将被调用。
更多细节在这里。
复杂的逻辑位于封装在触摸板中的电路板中，并提供了一个很好的界面（按钮）以将其抽象给用户。
PS：以上链接是我的个人博客。
于 2014-01-04T19:13:57.117 回答
33
这些有些模糊的概念并不是计算机科学和编程所独有的。我想提供一些额外的想法，可以帮助其他人理解这些重要概念。
简答
封装- 隐藏和/或限制对系统某些部分的访问，同时公开必要的接口。
抽象- 除了具体现实、特定对象或实际实例之外，考虑去除某些特征的事物，从而降低复杂性。
主要的相似之处在于这些技术旨在提高理解力和实用性。
主要区别在于抽象是一种更简单地表示事物的方法（通常是为了使表示更广泛适用），而封装是一种改变其他事物与事物交互方式的方法。
长答案
封装
这是一个封装的例子，希望能让事情更清楚：
在这里，我们有一个Arduino Uno 和一个外壳内的 Arduino Uno。外壳很好地代表了封装的全部含义。
封装旨在保护某些组件免受外部影响和知识，以及暴露其他事物应该与之交互的组件。在编程术语中，这涉及通过访问修饰符隐藏信息，这会改变某些变量和/或属性可以读取和写入的程度。
但除此之外，封装还旨在更有效地提供这些外部接口。在我们的 Arduino 示例中，这可能包括漂亮的按钮和屏幕，使用户与设备的交互更加简单。它们为用户提供了简单的方法来影响设备的行为并获得有关其操作的有用信息，否则这些操作将变得更加困难。
在编程中，这涉及将各种组件组合成一个可分离的结构，例如 a function、class或object。它还包括提供与这些构造交互的方法，以及获取有关它们的有用信息的方法。
封装以许多其他方式帮助程序员，其中最重要的是提高了代码的可维护性和可测试性。
抽象
尽管这里的许多其他答案将抽象定义为泛化，但我个人认为该定义是错误的。我会说泛化实际上是一种特定类型的抽象，而不是相反。换句话说，所有的概括都是抽象，但所有的抽象不一定都是概括。
以下是我对抽象的看法：
你会说那里的图像有一棵树吗？你很有可能会。但它真的是一棵树吗？好吧，当然不是！它是一堆像素，看起来像我们可以称之为树的东西。我们可以说它代表了真实树的抽象。请注意，树的几个视觉细节被省略了。此外，它不会生长、消耗水或产生氧气。怎么可能？它只是屏幕上的一堆颜色，由计算机内存中的字节表示。
这就是抽象的本质。这是一种简化事物的方法，因此它们更容易理解。你脑海中闪过的每一个想法都是对现实的抽象。您对一棵树的心目中的图像不再是一棵实际的树，而不是这个 jpeg。
Tree在编程中，我们可以通过创建一个具有模拟生长、耗水和氧气生产方法的类来利用这一优势。我们的创作将代表我们对实际树木的体验，并且只包括我们真正关心的特定模拟的那些元素。我们使用抽象来表示我们对字节和数学的体验。
抽象类
编程中的抽象还允许我们考虑几个“具体”对象类型（实际存在的类型）之间的共性，并在唯一实体中定义这些共性。例如，我们的Tree类可能继承自abstract class Plant，它具有适用于我们所有类植物类的几个属性和方法，但删除了每种植物特有的属性和方法。这可以显着减少代码重复，并提高可维护性。
abstract classan和 plain的实际区别class在于，从概念上讲，没有“真实”的abstract class. 构造一个Plant对象是没有意义的，因为这不够具体。每个“真实”Plant也是一种更具体的Plant.
此外，如果我们希望我们的程序更真实，我们可能需要考虑我们的Tree类本身可能过于抽象的事实。实际上，everyTree是 的一种更具体的类型，因此我们可以为那些继承自我们（也许是现在）类的类型（例如 , 等）Tree创建Birch类。MapleabstractTree
虚拟机
另一个很好的抽象示例是Java 虚拟机 (JVM)，它为 Java 代码运行提供了一个虚拟或抽象计算机。它实质上去掉了系统的所有平台特定组件，并提供了一个抽象的“计算机”接口，而不考虑任何具体的系统。
区别
封装与抽象的不同之处在于它与某事物的“真实”或“准确”程度没有任何关系。它不会删除某些东西的组件以使其更简单或更广泛适用。相反，它可能会隐藏某些组件以实现类似的目的。
于 2015-12-26T05:16:49.460 回答
29
- 抽象让您专注于对象的作用而不是它的作用
- 封装意味着隐藏对象如何做某事的内部细节或机制。
就像你开车一样，你知道油门踏板的作用，但你可能不知道它背后的过程，因为它是封装的。
让我举一个 C# 中的例子。假设你有一个整数：
int Number = 5;
string aStrNumber = Number.ToString();
您可以使用 Number.ToString() 之类的方法，它返回数字 5 的字符表示，并将其存储在字符串对象中。该方法告诉你它做了什么，而不是它是如何做的。
于 2009-04-12T20:22:35.980 回答
22
封装：向对象的实际用户隐藏不需要的/意外的/适当的实现细节。例如
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. */
抽象：是一种提供泛化的方式，因此是处理大量多样性对象的常用方式。例如
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**
于 2009-04-13T11:16:51.663 回答
14
抽象和封装之间的区别。
于 2014-08-30T00:07:41.277 回答
12
抽象：以简化/不同的方式呈现事物的想法，这要么更容易理解和使用，要么更适合情况。
考虑一个发送电子邮件的类...它使用抽象来向您展示自己是某种信使男孩，因此您可以调用 emailSender.send(mail, recipient)。它实际上做了什么——选择 POP3 / SMTP、调用服务器、MIME 翻译等，都被抽象掉了。你只看到你的信使男孩。
封装：保护和隐藏对象私有的数据和方法的想法。它更多地涉及使某些东西独立且万无一失。
以我为例。我封装了来自世界其他地方的心率。因为我不希望任何其他人更改该变量，并且我不需要其他任何人设置它以便我运行。它对我来说至关重要，但你不需要知道它是什么，而且你可能也不在乎。
环顾四周，你会发现几乎所有你接触的东西都是抽象和封装的例子。例如，您的手机向您展示了一种抽象概念，即能够将您所说的内容传达给其他人——涵盖 GSM、处理器架构、无线电频率以及一百万个您不了解或不关心的其他事物。它还封装了您的某些数据，例如序列号、ID 号、频率等。
这一切都让世界成为一个更宜居的地方：D
于 2009-12-18T10:58:07.267 回答
10
抽象：只显示必要的信息。让我们专注于打开计算机的示例。用户不必知道系统仍在加载时发生了什么（该信息对用户隐藏）。
让我们再举一个例子，ATM。客户不需要知道机器如何读取 PIN 码并处理交易，他只需输入 PIN 码，拿走现金，然后离开。
封装：处理隐藏类的敏感数据，从而将其中的一部分私有化。这是一种通过不允许从外部访问某些信息来对其客户保密的方法。
于 2011-02-11T11:12:50.080 回答
8
另一个例子：
假设我创建了一个不可变的 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_;
}
现在很明显我已经封装了宽度和高度（访问受到某种限制），但我没有抽象任何东西（好吧，也许我忽略了矩形在坐标空间中的位置，但这是一个缺陷例子）。
好的抽象通常意味着好的封装。
一个好的抽象的例子是一个通用的数据库连接类。它的公共接口与数据库无关，非常简单，但允许我对连接做我想做的事。你看到了吗？那里也有封装，因为该类必须包含所有低级句柄和调用。
于 2009-04-13T10:27:51.970 回答
8
Abstraction并Encapsulation通过使用单个通用示例
-------------------------------------------------- -------------------------------------------------- --------------------------------
我们都使用计算器来计算复杂的问题！
于 2013-08-26T10:50:16.320 回答
8
抽象：抽象意味着展示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);
}
}
于 2015-06-08T09:25:39.257 回答
7
防止特定对象的数据被外部函数故意或意外滥用的机制称为“数据封装”
表示基本特征而不包括背景细节或解释的行为称为抽象
于 2011-10-17T15:39:07.257 回答
6
让我们以堆栈为例。它可以使用数组或链表来实现。但它支持的操作是push和pop。
现在抽象只暴露接口 push 和 pop。底层表示是隐藏的（它是一个数组还是一个链表？）并且提供了一个定义良好的接口。现在，您如何确保不会意外访问抽象数据？这就是封装的用武之地。例如，C++ 中的类使用访问说明符来确保防止意外访问和修改。而且，通过将上述接口设为公共，可以确保操作堆栈的唯一方法是通过定义明确的接口。在这个过程中，它已经耦合了数据和可以操作它的代码（我们这里不涉及友元函数）。也就是说，代码和数据被绑定在一起或捆绑或封装。
于 2011-11-03T16:33:50.477 回答
5
我将尝试以简单的方式演示封装..让我们看看..
- 将数据和函数封装成一个单元（称为类）称为封装。包含和隐藏对象信息的封装，例如内部数据结构和代码。
封装是 -
- 隐藏复杂性，
- 将数据和函数绑定在一起，
- 使复杂的方法私有化，
- 使实例变量私有，
- 向最终用户隐藏不必要的数据和功能。
封装实现了抽象。
抽象是-
- 显示什么是必要的，
- 数据需要从最终用户中抽象出来，
让我们看一个例子-
下图显示了“要添加到数据库中的客户详细信息”的 GUI。
通过查看图像，我们可以说我们需要一个客户类。
步骤 - 1：我的客户类别需要什么？
IE
- 2 个变量来存储客户代码和客户名称。
1 将客户代码和客户名称添加到数据库中的功能。
命名空间客户内容{公共类客户{公共字符串客户代码=“”；公共字符串 CustomerName = ""; public void ADD() { //我的数据库代码将放在这里 }
现在只有 ADD 方法不能单独在这里工作。
步骤-2：验证将如何工作，添加功能起作用？
我们将需要数据库连接代码和验证代码（额外方法）。
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() [复杂和额外方法]）。最终用户只需要查看并了解将添加的客户代码、客户名称和添加按钮记录..最终用户不关心它将如何将数据添加到数据库？
步骤-3：将不涉及最终用户交互的额外复杂方法私有化。
因此，将那些 Complicated 和 Extra 方法设为 Private 而不是 Public（即隐藏这些方法）并删除 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：我的客户类需要什么？是抽象。
Step -3: Step -3: Private 不涉及最终用户交互的额外复杂方法是封装。
PS - 上面的代码既难又快。
于 2014-11-18T19:45:07.283 回答
5
封装将复杂性封装在一个封装中，即类，因此封装......而抽象是一个对象区别于其他对象的特征......
抽象可以通过使具有一个或多个方法抽象的类抽象来实现。这只不过是扩展它的类应该实现的特性。例如，当您发明/设计汽车时，您定义了一个特征，例如汽车应该有 4 个门、刹车、方向盘等……所以任何使用这种设计的人都应该包含这个特征。实现不是每个抽象的头。它只会定义应该包含的特征。
封装是通过使用访问修饰符（如公共、私有、受保护以及继承、聚合或组合）将数据和行为保存在一个类封装中实现的。所以你只显示必需的东西，也只显示你想要显示的程度。ie public, protected, friendly & private ka funda…… 比如GM决定使用上面汽车的抽象设计。但他们有各种产品，具有相同的特性和几乎相同的功能。所以他们编写了一个扩展上述抽象类的类。它说明了变速箱应该如何工作，刹车应该如何工作，方向盘应该如何工作。那么所有的产品都只是使用这个通用的功能。他们不需要知道齿轮箱是如何工作的、刹车是如何工作的或转向轮是如何工作的。
两者都很强大；但是使用抽象需要比封装更多的技能，并且更大的应用程序/产品在没有抽象的情况下无法生存。
于 2011-06-01T06:39:21.920 回答
5
抽象---隐藏实现---在设计中---使用接口/抽象类
封装——隐藏数据——在开发中——使用访问修饰符（公共/私有）
于 2015-07-13T05:13:46.277 回答
4
从此_
OOPS 中封装与抽象的区别
抽象和封装是两个重要的面向对象编程 (OOPS) 概念。封装和抽象都是相互关联的术语。
封装与抽象之间的现实差异
封装意味着隐藏。封装也称为数据隐藏。您可以将封装视为将药物隐藏在其中的胶囊（药片）。封装就是包装，只是隐藏属性和方法。封装用于将代码和数据隐藏在一个单元中，以保护数据不受外界影响。类是封装的最好例子。
抽象是指仅向预期用户显示必要的细节。顾名思义，抽象是“任何事物的抽象形式”。我们在编程语言中使用抽象来制作抽象类。抽象类表示类的方法和属性的抽象视图。
封装与抽象的实现区别
抽象是使用接口和抽象类实现的，而封装是使用私有和受保护的访问修饰符实现的。
OOPS 通过防止程序员以非预期的方式访问数据，利用封装来强制类型的完整性（即确保以适当的方式使用数据）。通过封装，只有预定的一组函数才能访问数据。与访问限制（公共/私有等）捆绑在一起的数据类型和操作（方法）的统称是一个类。
于 2014-02-01T19:20:01.340 回答
4
于 2016-12-10T10:48:05.863 回答
3
抽象或封装并不严格要求信息隐藏。信息可能会被忽略，但不必隐藏。
封装 是将某物视为单一事物的能力，即使它可能由许多复杂的部分或想法组成。例如，我可以说我坐在“椅子”上，而不是指那把椅子的许多不同部分，每个部分都有特定的设计和功能，所有部分都精确地组合在一起，目的是为了让我的臀部舒适地保持几英尺远离地板。
抽象是通过封装实现的。因为我们封装了对象，所以我们可以将它们视为以某种方式相互关联的事物，而不是陷入内部对象结构的微妙细节中。抽象是考虑大局的能力，而不是对小细节的关注。这个词的词根是抽象的，就像出现在学术论文顶部的摘要中一样，而不是抽象的，因为只能实例化为派生子类。
老实说，当我把屁股倒在椅子上时，我从没想过那把椅子的结构会如何承受和支撑我的体重。这是一把足够体面的椅子，我不必担心这些细节。所以我可以把注意力转向我的电脑。再说一次，我不考虑我电脑的组成部分。我只是在查看代表我可以输入的文本区域的网页的一部分，我正在用文字进行交流，甚至几乎没有想到我的手指如何总是在键盘上如此快速地找到正确的字母，以及如何最终在点击这些键和发布到这个论坛之间建立了联系。这就是抽象的强大力量。因为可以信任系统的较低级别以一致和精确的方式工作，所以我们要注意备用以完成更大的工作。
于 2013-08-26T16:58:20.607 回答
2
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**
于 2011-04-06T10:57:44.993 回答
2
抽象和封装的过程都产生接口。
通过封装生成的接口隐藏了实现细节。
与抽象之前相比，通过抽象生成的接口适用于更多的数据类型。
于 2013-12-08T06:15:34.550 回答
2
抽象是对用户隐藏无用的数据，而封装是将数据绑定到一个胶囊（一个类）中。我认为封装是我们实现抽象的方式。
于 2011-07-06T11:55:13.103 回答
2
Abstraction是我们将要执行的合同。实施可能会随着时间的推移而改变。各种实现本身可能隐藏也可能不隐藏，但隐藏在抽象后面。
假设我们在一个类中定义了所有的类APIs，interface然后要求我们代码的用户依赖于. 我们可以自由地改进或修改实现，只有我们必须遵循设定的合同。用户与我们的实施没有耦合。APIsinterface
我们在抽象中公开所有必要的规则（方法），规则的实现留给实现者实体，实现也不是抽象的一部分。它只是抽象的签名和声明。
Encapsulation只是通过减少状态和行为的访问来隐藏内部细节。一个封装的类可能有也可能没有很好的定义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 实现。一旦我们编写了一些具体的实体，然后决定隐藏我们的内部状态就是封装
于 2017-04-20T16:03:07.747 回答
1
我认为封装是一种实现抽象的方法。看看下面的链接。
于 2013-06-23T02:50:37.483 回答
1
简而言之
抽象使用 -> 封装 & 封装使用 -> 数据隐藏
或者
数据隐藏是封装的子集， 封装是抽象的子集
于 2015-06-07T07:26:42.647 回答
1
抽象和封装都以数据隐藏着称。但是有很大的不同。
封装
封装是将数据和对数据进行操作的代码绑定或包装到称为类的单个单元中的过程。
封装解决了实现层面的问题。
在课堂上，您可以使用私有或受保护的访问修饰符来隐藏数据。
抽象
抽象是隐藏无关细节的概念。换句话说，通过向用户隐藏不必要的细节来简化复杂的系统。
抽象在设计层面解决了问题。
您可以通过在 Java 中创建接口和抽象类来实现抽象。
在 ruby 中，您可以通过创建模块来实现抽象。
例如：我们在 ruby 中使用带有 Array 和 Hash 的 Enumerable 模块的 (collect, map, reduce, sort...) 方法。
于 2018-08-04T12:20:19.797 回答
1
让我用简单的代码示例试试这个
抽象 = 数据隐藏 + 封装
// Abstraction
interface IOperation
{
int GetSumOfNumbers();
}
internal class OperationEven : IOperation
{
// data hiding
private IEnumerable<int> numbers;
public OperationEven(IEnumerable<int> numbers)
{
this.numbers = numbers;
}
// Encapsulation
public int GetSumOfNumbers()
{
return this.numbers.Where(i => i % 2 == 0).Sum();
}
}
于 2017-04-23T10:11:14.170 回答
1
我试图在抽象和封装之间划清界限，据我说，抽象更多是概念性的东西，而封装是抽象实现之一。由于可以在不封装的情况下隐藏数据，例如使用私有常量或变量；所以我们可以对数据隐藏进行封装，但数据隐藏并不总是封装。在下面的代码中，我尝试描述这些概念的最简单形式。
// 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.
于 2017-04-18T07:21:13.243 回答
1
我读得越多，我就越困惑。所以，这就是我所理解的：
封装：
我们通常从外面看到一块手表，它的组件被封装在它的体内。我们对不同的操作有某种控制。这种隐藏细节和暴露控制（例如设置时间）的方式就是封装。
抽象：
到目前为止，我们谈论的是手表。但我们没有具体说明是哪种手表。它可以是数字的或模拟的，用于手或墙壁。有很多可能性。我们所知道的是，它是一块手表，它告诉时间，这是我们唯一感兴趣的东西，时间。这种隐藏细节和暴露通用特性或用例的方式是抽象的。
于 2021-10-18T18:51:07.097 回答
0
抽象
抽象是提取所有现有和可预见的实现的公共属性和字段的过程。
例如： Car是 Sedan、Hatchback、SUV、Coupe、Convertible 的抽象。 Car将具有所有类型的汽车共有的所有属性和字段。
封装
封装是向用户隐藏不需要的细节的过程。这个术语来自胶囊。就像药物对用户隐藏在胶囊内一样。各种机器和设备的详细信息，从搅拌机、自行车、洗衣机、收音机、电视到飞机。您不希望用户可以看到机器的所有详细信息。
在编程方面：让我们考虑一个类 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();
...
}
}
于 2018-10-22T16:29:10.460 回答
0
简而言之：
抽象是一种技术，可以帮助我们识别哪些特定信息是必不可少的，哪些信息应该隐藏。
封装是一种以隐藏对象的细节和实现细节的方式封装信息的技术。
于 2018-10-18T20:25:40.577 回答
-1
封装需要模块化。它要求您创建具有数据的对象和处理数据的方法。在这种情况下，您可以将其视为一个模块。
抽象为您提供了类的通用视图。
于 2009-04-13T11:53:00.393 回答
-1
之间有区别
抽象
和
封装
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.
于 2015-04-23T10:51:12.893 回答
-1
封装是抽象的一个例子。封装的重点是抽象函数内部发生的事情，将所有复杂性降低为符号（函数的引用或名称），将函数变成黑盒子。
在编程中，“抽象”这个词是一个命令。当一个类继承一个抽象类（或接口）时，您被要求创建一个抽象。
于 2015-11-27T09:12:47.167 回答
-1
一件事，也许是其他答案忘记提及的基本事情是，封装是抽象。因此，将两者进行对比并寻找差异并不准确，而是将封装视为一种抽象形式。
于 2016-04-12T18:48:38.627 回答