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

将数据和函数包装成一个单元(称为 类)被称为封装。封装、包含和隐藏 关于对象的信息，如内部数据结构和 代码。

封装是-

隐藏的复杂性, 将数据和函数绑定在一起， 使复杂方法私有， 使实例变量为私有， 对最终用户隐藏不必要的数据和函数。

封装实现了抽象。

抽象就是——

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

让我们看一个例子

下图显示了“将客户详细信息添加到数据库”的图形用户界面。

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

步骤- 1:我的客户类需要什么?

i.e.

2个变量来存储客户代码和客户名称。 1添加客户代码和客户名称到数据库功能。 名称空间CustomerContent ｛ 公共类客户 ｛ CustomerCode = ""; CustomerName = ""; 公共无效ADD() ｛ //我的DB代码会在这里 ｝

现在只有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:私有不涉及最终用户交互的额外和复杂的方法。

所以使那些复杂的和额外的方法为私有而不是公共(i。e隐藏这些方法)，并删除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:封装不涉及最终用户交互的额外和复杂的方法。

附注:上面的代码是硬而快速的。

抽象:只显示必要的信息。让我们关注一下在计算机上进行开关的例子。当系统仍在加载时，用户不必知道发生了什么(该信息对用户隐藏)。

让我们再举一个例子，ATM机。客户不需要知道机器如何读取密码并处理交易，他所需要做的就是输入密码，拿现金然后离开。

封装:处理隐藏类的敏感数据，从而私有化类的一部分。这是一种通过不允许外部访问来保持某些信息对其客户端的私密性的方法。

抽象

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

例如: 轿车是轿车、掀背车、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();
        ...
    }
}

两者之间存在差异

ABSTRAACTION

and

封装

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.

我试图在抽象和封装之间画一条线，根据我的观点，抽象更多的是概念性的东西，而封装是抽象实现的一种。因为一个人可以隐藏数据而不封装，例如使用私有常数或变量;所以我们可以用数据隐藏进行封装，但数据隐藏并不总是封装。在下面这段代码中，我试图描述这些概念的最简单形式。

    // 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.

下面这段话帮助我理解了它们之间的区别:

数据封装是一种捆绑数据的机制 使用它们的函数和数据抽象是一种机制 只暴露接口，隐藏实现细节 来自用户。

你可以在这里阅读更多。