简单的方法来了解封装和抽象(Simple way to understand Encapsulati

学习面向对象的概念特别感兴趣深入了解抽象和封装。

检查了已经低于

抽象VS信息隐藏VS封装

抽象和封装之间的区别？

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

我的一位同事说，抽象是什么，但创建抽象类和正常类保护范围与它的成员变量称为封装。

有一个简单的方法可以让我理解和帮助别人理解他们到底是什么，而不是重复下面？

抽象和封装是相辅相成的概念：抽象的重点对象的观察行为...封装侧重于，使人们产生这种行为的实现...封装最经常通过信息隐藏，这是隐藏所有的进程中取得对象的秘密，不利于它的本质特征。

Answer 1:

抽象是你只显示“相关”数据，并从用户对象的“隐藏”不必要的细节的过程。 考虑你的手机，你只需要知道什么按钮被按下发送信息或拨打电话，当你按下一个按钮，你的信息是如何发送会发生什么事，你的电话是如何连接的是从所有抽象出来用户。

封装是数据和功能组合成所谓的类的单个单元的过程。 在封装中，数据不直接访问; 它是通过存在于类内的功能进行访问。 在简单的话，类属性保持私有和公共getter和提供setter方法来处理这些属性。 因此，封装使得数据隐藏可能的概念。

Answer 2:

抽象是隐藏信息或只提供必要的信息给客户端。

例如，汽车Brakes-你只知道按踏板将车辆停止但你并不需要知道它是如何工作的内部。

抽象明天的优势 ，如果从鼓式制动器到盘式制动器的制动实施的变化，作为一个客户，你不需要改变（即你的代码不会改变）

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

对于例如具有类 （即对这些数据进行操作，即方法）属性（即数据）和行为

Answer 3:

使用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“功能”。 有一组火制造商（名单）这意味着，穴居人与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等），这些都是从该视图，因为它们是一个类的内部关注隐藏。 穴居人具有可以被外界称为许多其他的公共行为。 但有些细节会总是隐藏，因为都涉及到内部工作。 他们是私有的，只能存在为对象，他们不会暴露。 这是封装

Answer 4:

抽象是广义的术语。 即封装是抽象的子集。

抽象是一种强大的方法来管理复杂的系统。 抽象是通过定义明确的对象和他们的分级分类管理。

例如 ，在本身汽车是一个明确的目标，这是由像齿轮传动系统其他几个更小的物体，转向机构，引擎，这是一次有自己的子系统。 但是，对于人类的车是一个单一的对象，它可以通过其子系统的帮助下进行管理，即使他们的内部细节是未知的。 礼貌

---

封装：结束语数据成员和方法一起成单个单元（即，类）被称为封装。

封装是像在胶囊包封。 即封闭相关业务，以及相关的对象到该对象的数据。

封装是喜欢你的包装袋，其中你可以保持您的笔，本子等，这意味着这是封装部件及功能的财产。

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

封装是指隐藏物体的内部细节，即对象如何做一些事情。

封装可以防止客户端看到其内部来看，在抽象的行为来实现。

封装是用于保护来自其它对象的对象的信息的技术。

隐藏如使变量作为私人安全数据，并揭露访问这将是公众对私有数据的属性。

所以，当你访问的属性，您可以对数据进行验证，并设置它。 礼貌

Answer 5:

抽象是你“被扔掉”从实体不必要的细节，你打算捕捉/在你的设计代表，并保持这是有关您的域的实体的唯一特征的过程。
例如：代表的汽车，你会保持如型号和价格，当前位置和当前速度而忽略了座位等颜色和数字

封装在所述的属性和操纵它们在抽象的单个单元（即一类）的操作中的“结合”。
因此该车将有accelarate stop操纵的位置和当前速度等。

Answer 6:

好吧，我将解释与现实世界的例子抽象。 假设你的房子你有一个电插头，许多设备可以连接到相同的插头，而插头将永远不会有哪个设备被连接，换句话说，设备的详细信息被抽象（隐藏）插头的想法。

想想看，如果我们直接连接设备电线没有插头？ 说直接连接的灯泡的电线，然后导线知道它被连接到设备，并且当曾经我们需要更换灯泡那么我们必须除去从灯泡，这意味着灯泡紧密耦合与导线电线连接。 换句话说灯泡和电线知道它被连接到的详细信息，意味着不抽象。

在面向对象的抽象世界的作品完全一样。 它消耗其他类功能/属性的类并不需要知道哪些类功能/特性被消耗，一切都应该有一个接口/抽象类抽象。

让我的代码相同的例子。 在这里，我有一个类“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");
    }
}

Answer 7:

封装是这听起来像，把周围的东西框，以保护其内容的一种方式。 抽象提取的东西，这样你可以使用你没有内部运作的知识已经提取只执行什么操作的功能特性。

当我们说这两种物质是液体，我们使用的是“液体”在我们选择讨论这些物质的性质的抽象。 这抽象告诉我们，我们可以做的物质给予我们以前的经验液体的东西。

抽象也确实没有什么关系heirarchies。 你可以有另一个抽象这样的提取方式不同的物质属性“金属”。

抽象忘记的细节，因此，如果您使用的是特定的抽象，你不应该问的是不是由抽象授予的标的物的性质。 如果你把牛奶和水混合在一起一样，你也很难再问你有多少牛奶有。

函子是在一些抽象有地图的一些概念，那就是，你可以运行转换内部位到别的在其内内容的功能。 外的东西保持不变类的话。

如果这得到有用的是，如果你有一个清单上工作的功能，你意识到你只是根据地图界面上，可以改为依靠函子，然后你的函数可以用流，承诺，maybes，元组工作，其他任何同意这样的抽象。

象Haskell函数式语言具有使极度代码重用实际的抽象一些真正伟大的力量。

Answer 8:

就像使用一台电脑。

你完全不知道发生了什么事情就随它超越你用GUI（图形用户界面）和外部硬件（如屏幕）看到的。 所有这些漂亮的颜色等。 你只是提出有关你作为一个普通消费者的细节。

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

您可以使用您的计算机，但你看不出什么的CPU（中央处理单元）的样子（除非你试图闯了进去）。 它隐藏（或封装）的后面所有的铬和塑料。

在OOP（面向对象编程）语言的情况下，你平时有这种设置：

CLASS {
  METHOD { 
    *the actual code*
  }
}

的“封装”的一个例子是有方法的普通用户看不到（专用）。 “抽象”是普通用户使用该方法，他们可以（公开），以利用私人之一。

Answer 9:

抽象是为了简化的接口隐藏细节的手段。

因此，使用汽车为例，所有汽车中的控件是抽象的。 这可以让你不理解的转向，加速，减速系统的底层细节操作车辆。

一个良好的抽象是一个广泛的标准化接口，碰到类似问题的多个实例。 一个伟大的抽象可以改变一个行业。

现代的方向盘，刹车踏板和油门踏板是伟大的抽象的例子。 汽车转向最初看起来更需要像自行车这样的转向。 而且两者刹车和油门用手操作。 但是，我们今天使用的抽象是如此强大，他们包揽了行业。

-

封装是为了保护他们免受外界操纵隐藏细节的手段。

封装是什么阻止了驾驶员操纵汽车驱动方式 - 从转向，悬挂和制动的刚度，以油门和传输的特性。 大多数汽车不改变任何这些东西提供接口。 这种封装可以确保作为制造商所期望的车辆将运行。

有些汽车提供少量的驾驶模式 - 般的奢华，体育和经济 - 这使驾驶员能够改变一些这些属性一起一次。 通过提供驾驶模式，制造商允许驾驶员在经历了一些控制，同时防止他们选择将会使车辆不太愉快或不安全属性的组合。 这样，制造商是隐藏的细节，以防止不安全的操作。 这是封装。

Answer 10:

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

封装：结合变量和函数或1可以说数据成员或成员函数都聚集在一个单一的单元被称为数据封装....

Answer 11:

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

抽象涉及缺乏细节和使用一个简单的接口，以控制一个复杂的系统。

例如，我们可以通过点亮的按压按钮的灯泡，而无需担心底层电气工程（抽象）。

但是你无法点亮以任何其他方式的灯泡。 （封装）

Answer 12:

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用与方法，一种数据隐藏的实例变量的结合有关。

Answer 13:

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

封装 ：它是一种机制，使我们免受外界我们的数据。

Answer 14:

抽象是表示其中作为封装从用户隐藏不需要的数据（产品从用户）用户必要的信息。

封装实现了抽象。

抽象是其中的封装实际上实现它的过程。 对于EG。 添加用户逻辑 - >我们需要验证用户，创建数据库连接，并插入用户。 因此，用户不知道的拳头需要调用验证功能，创建数据库连接，然后插入数据库中的价值。 他只调用ADDUSER函数调用内部所有的逻辑在，这只是封装（分组的功能和隐藏方法）。

文章来源: Simple way to understand Encapsulation and Abstraction