Question

在阅读不同来源的封装和抽象定义时，我越来越困惑。很难确定哪个是正确的定义。

封装定义1

封装：封装是制作字段的技术私有类，通过公共方法提供对字段的访问

封装定义2

封装是掩盖数据和功能的过程到一个单元（称为类）。

抽象定义1

抽象是一种用最少的方式建模现实世界对象的方法信息。

抽象定义2

仅公开必要的方法。

请帮助我理解与OOP相关的这些单词的正确定义。解释正确定义的书的来源也是首选。

Answer 1

谈论代码，抽象只是描述现实世界的一段代码＆＃34;事情＆＃34;。大多数情况下，您无法描述整个事物＆＃34;，但您可以描述它的主要特征，在您的代码中，它们将被称为属性。

抽象的一个例子是餐馆：你去，你要菜单并选择你想吃的东西......但你不吃纸：你选择你想看的它的抽象（菜单）...抽象可能只是说＆＃34;鸡蛋＆amp;培根＆＃34;，但当服务员带来你的订单时，它有一对鸡蛋（炒蛋），两片脆皮培根和其他一些东西......菜单只是真实的一个简单抽象>事情。

拿Bicycle example in the Java Tutorials：自行车有属性：

速度
齿轮
的Cadence

你对自行车的任何其他特征都不感兴趣（在这个例子中）......所以这是一个抽象。

现在，关于封装：在编写代码时，您希望仅在＆＃34; propper＆＃34;中修改对象的属性。方式：如果你改变速度（再次是自行车示例），你可能还需要改变节奏和/或改变档位。因此，您声明属性private并仅通过public方法更新它们，并且在这些方法中，您确保所有属性都具有相干值：

public class Bicycle {
    private int speed, gear, cadence;
    /**
     * Default constructor
     */
    public Bicycle() {
        speed = 0;
        gear = 1;
        cadence = 0;
    }
    /**
     * An example 
     */
    public void setSpeed(int speed) {
        this.speed = speed;
        /*
           You can set the value of the other attributes here if you want to
         */
    }
    /**
     * Another example
     */
    public void gearUp() {
        if(gear < 5)
            gear++;
        /*
           Here you are preventing other methods to set the gear to
           a value higher than 5.
         */
    }
    /**
     * Another one
     */
    public void gearDown() {
        if(gear > 1)
            gear--;
        /*
           Here you are preventing other methods to set the gear to
           a value lower than 1.
         */

    }
}

Answer 2

抽象
抽象与将方法设为私有或公开无关。它与识别某类类通用的功能有关。

在java中，抽象类比接口更进一步。在界面中，类型X的类必须做X，Y，Z。无论如何，X，Y，Z都可以实现。

抽象类说X类的类必须做X，Y，Z，但标记为abstract的方法必须以特定方式完成，因此它在抽象类（抽象）中实现。

封装
它只是将一件或多件事包装在另一件事中。简化或隐藏代码。您希望这样做的一个示例是简化流程。如果您希望用户能够关闭计算机，例如，您可以使用一堆方法让某人明确调用：

Util.shutdownApps();
Util.shutdownServices();
Util.shutdownScreenAndKeyboard();
Util.poweroff();

如果您想以某种特定方式关闭，或者只是让某人更容易关闭，您可以封装它：

Util
    public void shutdown(){
    Util.shutdownApps();
    Util.shutdownServices();
    Util.shutdownScreenAndKeyboard();
    Util.poweroff();
    }

  private shutdownApps(){...}
  private shutdownServices(){...}
  private shutdownScreenAndKeyboard(){...}
  private poweroff(){...}

Answer 3

以下面的两个代码片段为例：

// Snippet #1
public static void Main(){
    int sum = 0;
    for (int i = 0; i <= 1000; i++) {
        sum += i;
    }
    System.out.println(sum);
}

在上面的代码片段中，程序正在计算从0到1000的所有整数的总和。您可以看到计算是如何完成的，并且您可以控制存储和的值的变量。 / p>

// Snippet #2

public class Adder {
    private int sum;

    public Counter(){
        this.sum = 0;
    }

    public void add(int value){
        this.sum += value;
    }

    public int getSum(){
        this.sum;
    }
}

public static void Main(){
    Adder adder = new Adder();
    for (int i = 0; int <= 1000; i++) {
        adder.add(i);
    }
    System.out.println(adder.getSum());
}

上面的代码段执行相同的任务，但不同。有一个类提供了您正在质疑的两个特征。它提供了一个抽象来系统地添加数字，还提供了封装计算方法的细节。换句话说，它将添加数字及其工作方式与将数字从0迭代到1000（在主函数中）的任务分开。

在这个例子中：

抽象是添加数字的概念，因此每种不同类型的创意都会有不同的抽象
enccapulation 是实现细节与主程序的分离。也就是说，您可以为相同类型的抽象创建一个新类，但使用不同的实现（例如 long 而不是un int ）。

OOP抽象与封装多个定义

3 个答案: