理解封装和抽象的简单方法

时间：2013-04-15 11:42:44

标签： oop language-agnostic encapsulation abstraction

学习OOP概念特别有兴趣深入了解抽象和封装。

已检查以下

Abstraction VS Information Hiding VS Encapsulation

difference between abstraction and encapsulation?

我发现很难理解这些概念而没有一个真实而简单的示例类/代码片段。

  

我的一位同事说抽象只不过是创造抽象的   用范围保护其成员变量的类和普通类是   称为封装。

我是否有一种简单的方式可以理解并帮助他人了解它们到底是什么，而不是重复下面的内容？

  

抽象和封装是互补的概念：抽象   重点关注对象的可观察行为......封装   重点关注导致这种行为的实施......   封装通常是通过信息隐藏来实现的   是隐藏没有的对象的所有秘密的过程   有助于其基本特征。

16 个答案:

答案 0 :(得分：151)

抽象是一个只显示“相关”数据并“隐藏”用户不必要的对象详细信息的过程。考虑一下你的手机，你只需要知道按下哪些按钮来发送信息或拨打电话，按下按钮时会发生什么，你的消息发送方式，你的呼叫连接方式都是从用户。

封装是将数据和函数组合成一个名为class的单​​元的过程。在封装中，不直接访问数据;它是通过类中存在的函数访问的。简单来说，类的属性保持私有，并提供公共getter和setter方法来操作这些属性。因此，封装使数据隐藏的概念成为可能。

enter image description here

答案 1 :(得分：24)

抽象隐藏信息或仅向客户提供必要的详细信息。

例如汽车刹车 - 你只知道按下踏板会使车辆停下来，但你不需要知道它是如何在内部工作的。

抽象的好处明天如果制动器实施从鼓式制动器变为盘式制动器，作为客户端，您无需更改（即您的代码不会更改）

封装将数据和行为绑定在一个单元中。 它也是一种限制对某些组件的访问的语言机制（这可以通过私有，受保护等访问修饰符来实现。）

例如类具有属性（即数据）和行为（即对该数据进行操作的方法）

答案 2 :(得分：13)

使用C＃

的示例 
//abstraction - exposing only the relevant behavior
public interface IMakeFire
{
     void LightFire();
}

//encapsulation - hiding things that the rest of the world doesn't need to see
public class Caveman: IMakeFire
{
     //exposed information  
     public string Name {get;set;}

     // exposed but unchangeable information
     public byte Age {get; private set;}

     //internal i.e hidden object detail. This can be changed freely, the outside world
     // doesn't know about it
     private bool CanMakeFire()
     {  
         return Age >7;
     }

     //implementation of a relevant feature
     public void LightFire()
     {
        if (!CanMakeFire())
        {
           throw new UnableToLightFireException("Too young");
        }
        GatherWood();
        GetFireStone();
        //light the fire

     }

     private GatherWood() {};
     private GetFireStone();
}

public class PersonWithMatch:IMakeFire
{
      //implementation
 }

任何穴居人都可以生火，因为它实现了 IMakeFire '功能'。拥有一组消防员（List），这意味着Caveman和PersonWithMatch都是有效的选择。

这意味着

  //this method (and class) isn't coupled to a Caveman or a PersonWithMatch
  // it can work with ANY object implementing IMakeFire
  public void FireStarter(IMakeFire starter)
  {
        starter.LightFire();
    }

因此，您可以拥有大量具有大量细节（属性）和行为（方法）的实现者，但在这种情况下，重要的是它们能够起火。这是抽象。

由于火灾需要一些步骤（GetWood等），因此它们是视图中隐藏的，因为它们是类的内部关注点。穴居人还有许多其他可以被外界称呼的公共行为。但是一些细节将始终隐藏，因为它们与内部工作有关。它们是私有的，仅存在于物体中，它们永远不会暴露。这是封装

答案 3 :(得分：6)

  

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

抽象是管理复杂系统的强大方法。抽象由明确定义的对象及其层次分类管理。

例如汽车本身就是一个明确定义的对象，它由几个其他较小的对象组成，如齿轮系统，转向机构，引擎，它们也有自己的子系统。但对于人类而言，汽车是一个单一的物体，即使其内部细节未知，也可以通过其子系统进行管理。 Courtesy

封装：将数据成员和方法一起包装到一个单元（即Class）中称为封装。

封装就像封闭在胶囊中一样。这是将与对象相关的相关操作和数据包含在该对象中。

封装就像你的包，你可以保存你的笔，书等。这意味着这是封装成员和功能的属性。

class Bag{
    book;
    pen;
    ReadBook();
}

封装意味着隐藏对象的内部细节，即对象如何做某事。

封装可防止客户端看到其内部视图，其中实现了抽象的行为。

封装是一种用于保护对象中的信息不受其他对象影响的技术。

隐藏数据以确保安全性，例如将变量设为私有，并公开属性以访问公开的私有数据。

因此，当您访问该属性时，您可以验证数据并进行设置。 Courtesy

答案 4 :(得分：4)

抽象是指您从计划在设计中捕获/表示的实体“丢弃”不必要的详细信息并仅保留与您的域相关的实体属性的过程。
示例：代表您将保留的汽车，例如模型和价格，当前位置和当前速度，忽略颜色和座位数等。

封装是属性和在单个抽象单元（即类）中操作它们的操作的“绑定”。
因此，汽车将accelarate stop操纵位置和当前速度等。

答案 5 :(得分：4)

我会用一个真实世界的例子来解释抽象。在你的房子里说你有一个电插头，许多设备可以连接到同一个插头，但插头永远不知道它连接到哪个设备，换句话说，设备的细节被抽象（隐藏）到插头。

如果我们将设备直接连接到没有插头的电线，请考虑一下？假设将灯泡直接连接到电线，然后电线知道它连接到哪个设备，当我们需要更换灯泡时，我们必须从灯泡中取下电线连接，这意味着灯泡与电线紧密耦合。换句话说，灯泡和电线知道它所连接的细节，意味着没有抽象。

在面向对象的世界中，抽象的工作方式完全相同。使用其他类函数/属性的类不需要知道它正在消耗哪些类函数/属性，并且所有东西都应该用接口/抽象类抽象。

让我编写相同的例子。这里我有一个类“ElectricPlug”，它正在运行一个设备。但是“ElectricPlug”这个类并不知道它运行的是哪个设备。它可以是任何实现接口“IDevice”的类，这意味着“RunDevice”的实现是从“ElectricPlug”中抽象出来的。以下是完整的示例代码

class Program
{
    static void Main(string[] args)
    {
        ElectricPlug electricPlug = new ElectricPlug(new Bulb());
    }
}

public class ElectricPlug
{
    private readonly IDevice _device;
    public ElectricPlug(IDevice device)
    {
        _device = device;
    }

    public void Run()
    {
        _device.Rundevice();
    }
}


public interface IDevice
{
    void Rundevice();
}


public class Bulb : IDevice
{
    public void Rundevice()
    {
       Console.WriteLine("Switched on bulb");
    }
}

答案 6 :(得分：3)

封装就像听起来一样，是一种在盒子周围放置盒子以保护其内容的方法。抽象是提取某些东西的功能属性，这样您就可以仅使用已提取的内容执行操作，而无需了解内部工作原理。

当我们说两种物质都是液体时，我们使用“液体”作为我们选择讨论的那些物质的属性的抽象。这种抽象告诉我们，根据我们以前的液体经验，我们可以用这些物质做些什么。

抽象也与heirarchies没有任何关系。你可以有另一种抽象，如“金属”，以不同的方式提取物质的属性。

抽象会忘记细节，所以如果您使用特定的抽象，则不应该询问抽象未授予的基础物质的属性。就像你把牛奶和水混合在一起一样，你很难再问起你有多少牛奶。

Functor是对具有某种map概念的东西的抽象，也就是说，你可以在其内部内容上运行一个函数，将内部位转换为其他内容。外面的东西保持同样的东西。

这有用的地方在于，如果你有一个可以在列表中运行的函数，并且你意识到你只依赖于地图界面，那么你可以依赖于Functor，然后你的函数可以使用stream，promises，maybes，元组和其他任何共享抽象的东西。

像Haskell这样的函数语言具有一些非常强大的抽象功能，可以使极端代码重用变得实用。

答案 7 :(得分：2)

抽象就像使用计算机一样。

除了用GUI（图形用户界面）和外部硬件（例如屏幕）看到的内容之外，你完全不知道它是怎么回事。所有那些漂亮的颜色等。 您只是作为普通消费者提供了与您相关的详细信息。

封装是隐藏无关细节的实际行为。

您使用计算机，但您不知道它的CPU（中央处理单元）是什么样的（除非您试图闯入它）。它隐藏（或封装）所有铬和塑料背后。

在OOP（面向对象编程）语言的上下文中，通常有这种设置：

CLASS {
  METHOD { 
    *the actual code*
  }
}

＆＃34;封装＆＃34;将有一个常规用户无法看到的方法（私人）。 ＆＃34;抽象＆＃34;是使用METHOD的常规用户，他们可以（公开）使用私有。

答案 8 :(得分：2)

抽象是一种隐藏细节以便简化界面的方法。

因此，以汽车为例，汽车中的所有控件都是抽象的。这样一来，您无需了解转向，加速或减速系统的基本细节即可操作车辆。

良好的抽象是在相似问题的多个实例之间广泛标准化接口的一种。 伟大的抽象可以改变一个行业。

现代方向盘，制动踏板和油门踏板都是很好的抽象示例。汽车转向最初看起来更像是自行车转向。制动器和油门都是手动操作的。但是我们今天使用的抽象是如此强大，席卷了整个行业。

-

封装是隐藏详细信息的一种方法，以保护它们免受外部操纵。

封装是防止驾驶员操纵汽车行驶方式的因素-从转向，悬架和制动的刚度到油门和变速箱的特性。大多数汽车不提供用于更改任何这些东西的接口。这种封装确保车辆将按照制造商的预期运行。

某些汽车提供少量的驾驶模式，例如豪华，运动和经济驾驶，这些驾驶模式使驾驶员可以同时更改其中一些属性。通过提供驾驶模式，制造商允许驾驶员对体验进行某种控制，同时阻止他们选择会使车辆变得不那么令人愉悦或不安全的属性组合。这样，制造商隐藏了细节以防止不安全的操作。这就是封装。

答案 9 :(得分：1)

数据抽象：         访问任何类的数据成员和成员函数简称为数据抽象.....

封装：         绑定变量和函数或1可以说数据成员或成员函数在一个单元中一起被称为数据封装....

答案 10 :(得分：1)

封装可以被认为是用于绑定数据的包装纸，并作为单个单元一起工作，保护它免受各种外部污垢（我的意思是外部功能）。

抽象涉及缺少细节和使用简单的界面来控制复杂的系统。

例如，我们可以通过按下按钮点亮灯泡，而不必担心潜在的电气工程（抽象）。

然而，你不能以任何其他方式点亮灯泡。 （封装）

答案 11 :(得分：0)

public abstract class Draw {
    public abstract void drawShape(); // this is abstraction.  Implementation detail need not to be known.
    // so we are providing only necessary detail by giving drawShape(); No implementation. Subclass will give detail.


    private int type;    // this variable cannot be set outside of the class. Because it is private.
    // Binding private instance variable with public setter/getter method is encapsulation 

    public int getType() { 
        return type;
    }

    public void setType(int type) {  // this is encapsulation. Protecting any value to be set.
        if (type >= 0 && type <= 3) {
            this.type = type;
        } else {
            System.out.println("We have four types only. Enter value between 0 to 4");
            try {
                throw new MyInvalidValueSetException();
            } catch (MyInvalidValueSetException e) {
                e.printStackTrace();
            }

        }
    }
}

Abstraction与实现细节未知的方法有关，这是一种实现隐藏 Encapsulation与实例变量绑定方法有关，这是一种数据隐藏。

答案 12 :(得分：0)

数据抽象：DA只是过滤具体项目。通过类，我们可以实现纯抽象，因为在创建类之前，我们只能考虑关于类的有关信息。

封装：这是一种机制，我们通过这种机制保护我们的数据免受外部攻击。

答案 13 :(得分：0)

抽象正在向用户显示必要的信息，其中“封装”向用户隐藏不需要的数据（用户的产品）。

封装实现抽象。

抽象是封装实际实现它的过程。 例如。添加用户逻辑->我们需要验证用户，创建数据库连接并插入用户。因此，用户不知道首先需要调用validate函数，创建数据库连接，然后在数据库中插入值。他只调用AddUser函数，该函数使用in调用内部的所有逻辑，这只是封装（将功能分组并隐藏方法）。

答案 14 :(得分：0)

封装：我认为这与将事物绑定到一个实体而不是隐藏起来有很大关系。如果您选择隐藏某物，则可以。

抽象：抽象与隐藏的东西有很大关系，并且抽象的级别可能不同。例如，在功能抽象中，我们可能会说能够将项目添加到列表很重要，但是如何实现的细节并不重要，应该隐藏。使用数据抽象，我们可以说列表是我们可以存储信息的地方，但是列表的实际实现方式（例如，作为数组或一系列链接的位置）并不重要，应该隐藏。

Reference

答案 15 :(得分：0)

抽象- 简单的抽象可以说是一种让用户远离某些系统的复杂细节或详细工作的方法。您也可以将其视为在设计和界面级别解决任何问题的简单方法。

您可以说抽象的唯一目的是隐藏可能使用户感到困惑的细节。所以为了简单起见，我们可以使用抽象。抽象也是面向对象编程的一个概念。它隐藏了实际数据，只显示必要的信息。例如，在 ATM 机中，您不知道它内部是如何工作的。只有您关心使用 ATM 接口。因此可以将其视为一种抽象过程。

封装- 封装也是面向对象编程的一部分。在这里，您所要做的就是将数据和代码包装在一起，以便它们可以作为一个单元工作。它在实施层面发挥作用。它还提高了应用程序的维护性。

封装侧重于保存信息的过程。在这里，您必须保护您的数据不被外部使用。

相关问题
最新问题