JAVA

Question

我对 java 中的抽象有点困惑。

我查了很多页面说抽象就是数据隐藏（隐藏实现）。

我对抽象的理解是'partial implementation'。只需在摘要 class/interface 中定义您需要的内容，然后 extend/implement 然后添加您自己的功能。

我不明白这是怎么隐藏数据的？实施 class/interface 后，您将可以访问代码，并根据需要对其进行修改。

我查了很多问题，关于这方面的文章，但仍然对此感到困惑。

感谢任何帮助。谢谢

Answer 1

数据隐藏是指您在不阅读文档的情况下无法理解API内部如何工作（例如，ArrayList）。 API 创建者不提供任何访问底层数组的权限。

您向将要使用它的用户隐藏 API 实现。他们不应该担心它在内部是如何工作的，他们只对提供给他们的功能感兴趣。

关于那个 a good article。

Answer 2

您将 abstraction（编程模式）与 Java 语言的 abstract 关键字混淆了。尽管相似，但它们在语义上的相关性很小。

抽象意味着您从使用 class 或方法的代码中隐藏实现细节。使用您的方法的代码不需要知道您正在实现一个列表，使用数组或动态指针或嵌入式数据库或文件系统中的文件。
abstract 用于标记 class 具有仅声明但未实现的方法。它是 "abstract"，因为它们不能被实例化，你不能从这些 classes 中创建任何实例（但你可以从它们的具体子 classes 中创建它们）。

Answer 3

它不是对你隐藏信息，而是对你抽象的客户端。看看这个例子。

public class Demo {
    Client client = new Client(new Implementation());
}

public interface Abtraction {
    void doWork();
}

public class Implementation implements Abtraction{
    @Override
    public void doWork() {
        //doingTheWork
    }
}

public class Client{
    private Abtraction theAbstraction;

    public Client(Abstraction theAbstraction){
        this.theAbstraction = theAbstraction;
    }
}

class Client 不知道 Abstraction 的实现，这意味着 Demo class 可以提供 [=12] 的不同实现=] 而不会弄乱 Client.

Answer 4

数据隐藏 基本上是隐藏有关 class 的内部数据成员的详细信息，并且仅 排他性地 提供有关 class 访问它。

从而避免了来自应用程序中的其他classes或来自任何其他应用程序的不必要的渗透，这意味着其他classes无法直接访问私有成员变量。

因此，您可以通过这种方式抽象有关class的内部细节。

Answer 5

我不确定这是否回答了你的问题，但如果你谈论的是一般的抽象 classes，它们在那里为 child class 提供功能扩展它而 child class 不必知道或处理实现的所有细节（它对 child class 的用户隐藏）。

我们以汽车为例：

public abstract class Vehicle {
    protected int _numberOfWheels;
    public Vehicle() {
        this._numberOfWheels = 4;
    }
}

public class Truck extends Vehicle {
    public int carryingLoad;
    public Truck() {
        this.carryingLoad = 4000; // kg or something
    }
}

所以 vehicle 是车辆的一个抽象实例 object 并且已经具有一些与之关联的功能，例如车轮的数量。这是一个受保护的方法，所以如果我创建一个新的卡车实例：

// Inside main
Truck truck = new Truck();

我无法更改轮子的数量，但是，如果我要在 class 中为卡车编写函数，例如：

// Inside the Truck class
public void addSpareTire() {
    this._numberOfWheels++;
}

这样我就可以这样称呼它：

// Inside main
truck.addSpareTire();

我仍然可以与一些变量进行交互，但只能遍历扩展抽象 class 的 class 中的函数。我可以通过调用 addSpareTire() 一次添加一个轮胎，但我永远无法从我正在使用 [=16] 的主函数直接与 _numberOfWheels 交互=]object，但我可以从Truckclass声明里面。来自卡车object的用户，该信息是隐藏。

我不知道这是不是你要的。希望这有帮助。

Answer 6

在面向对象编程中抽象是对用户隐藏实现细节的过程，只有功能会提供给用户。换句话说，用户将获得有关对象做什么的信息，而不是它如何做的信息。

查看以下内容 link 了解更多详情： http://www.visionsdeveloper.com/tutorial/java/java-abstraction.jsp

Answer 7

也许一个例子能更好地帮助你。假设你想实现一个图 class，它可能有邻接表或邻接矩阵来表示它的节点。所以抽象地说，你至少要 "addNode" "addEdge" 这个图：

public abstract class Graph
{
    public abstract int addNode();
    public abstract void addEdge(int from, int to);
}

现在您可以扩展两个 classes:

public class GraphAdjList extends Graph
{
    private Map<Integer,ArrayList<Integer>> adjListsMap;
    public int addNode()
    {
        //list based implementation 
    }
    public void addEdge(int from, int to)
    {
        //list based implementation
    }
}

public class GraphAdjMatrix extends Graph
{
    private int[][] adjMatrix;
    public int addNode()
    {
        //matrix based implementation 
    }
    public void addEdge(int from, int to)
    {
        //matrix based implementation
    }
}

当你从这两个 classes 调用 addEdge 中的任何一个时，你不必担心它背后的数据结构，你只知道你得到了你需要的结果，例如：

Graph g1,g2;
g1 = new GraphAdjList();
g2 = new GraphAdjMatrix();

g1.addEdge(1,2);
g2.addEdge(1,2);

通过多态性，您可以调用两个不同的函数，但得到的结果与 Graph 的客户端相同。

另一个现实生活中的例子是汽车刹车。作为汽车客户，厂家给你一个踏板让你踩，不知道后端的刹车是怎么实现的。它可以是后部的鼓式制动器或盘式制动器。你只需要踩下刹车！

Answer 8

You are going to get access to the code once you implement the class/interface and you will modify it according to your need.

我想您对这里的语言给您的概念有点困惑 Abstraction。您始终可以访问自己的代码，但 Abstraction 或 Polymorphism 之类的内容为您提供了理想的方式。所以在 Abstraction 中你只是说我知道会有一个名为 someThing 的行为作为抽象方法，但现在你不知道它会如何表现，实施者会告诉我们这将是怎样的。请参阅以下代码。

abstract class Game{
 public abstract void play();
}

class Football extends Game{
  @Override
  public abstract void play(){
      // write how football play
  }
}

class Cricket extends Game{
  @Override
  public abstract void play(){
      // write how Cricket play
  }
}

我在这里给你留个问题。

Why you are making class level attributes public/protected/private although you have access to the code when you implement?

Answer 9

我认为你对两件事感到困惑

OOP 中的抽象概念及其在 Java
在java
Abstract : OOPs 的概念叫做 Abstract。在这里，用户可以捕获对象的必要特征。这个抽象概念实现为 class 和 java 中的对象。因此，当您以 class 的形式捕获对象的重要特征时，数据隐藏就会出现问题，这些特征只能由它们自己的 class 的对象访问。在这里，您从 class/world 外部隐藏了 class 的所有功能。所以，它被称为数据隐藏
abstract class : 这是 Java 实现的特征。如果你不知道完整的实现，那么你可以去抽象 class of java.

希望这能帮助你理解一点

谢谢

JAVA - 抽象

JAVA - Abstraction

interface

abstract-class

abstraction

data-hiding