Question

我对java中的抽象感到困惑。

我检查了许多页面，说明抽象是数据隐藏（隐藏实现）。

我对抽象的理解是'部分实现'。只需在抽象类/接口中定义您需要的内容，然后扩展/实现它们并添加您自己的功能。

我不明白这是一个数据隐藏的方式？实现类/接口后，您将可以访问代码，并根据需要对其进行修改。

我已经检查了许多问题，关于此的文章但仍然对此感到困惑。

感谢任何帮助。感谢。

Answer 1

您将抽象（编程模式）与Java语言的 abstract 关键字混淆。尽管有相似之处，但它们在语义上只是非常轻微相关。

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

Answer 2

也许一个例子可以帮助你更好。假设您要实现一个Graph类，该类可能具有邻接列表或邻接矩阵来表示其节点。所以在摘要中你想要＆＃34; addNode＆＃34; ＆＃34; addEdge＆＃34;到这个图表至少：

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

现在你可以扩展两个类：

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
    }
}

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

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

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

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

另一个现实生活中的例子是汽车刹车。作为汽车客户，制造商会给你一个推动踏板，而不知道后端制动器的实施情况。它可以是后鼓式制动器或盘式制动器。你需要的只是推动刹车！

Answer 3

数据隐藏是指您无法在不阅读文档的情况下了解如何在内部使用API（例如，ArrayList）。 API创建者不提供对那里的数组的任何访问权。

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

关于此问题a good article。

Answer 4

我不确定这是否能回答你的问题，但是如果你正在讨论一般的抽象类，那么它们就是为子类提供功能而扩展它而没有子类必须知道或处理所有的实现的细节（它隐藏在子类的用户之外）。

让我们以汽车为例：

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
    }
}

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

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

我不能改变车轮的数量，但是，如果我要在班级内为卡车写一个功能，如：

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

所以我可以这样称呼它：

// Inside main
truck.addSpareTire();

我仍然可以与一些变量进行交互，但只能通过扩展抽象类的类中的函数。我可以通过调用addSpareTire()一次添加一个轮胎，但我永远无法直接与主要功能_numberOfWheels进行交互，我在使用 Truck对象，但我可以从Truck类声明中找到。从卡车对象的用户中，该信息隐藏。

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

Answer 5

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

查看以下链接以获取更多详细信息： http://www.visionsdeveloper.com/tutorial/java/java-abstraction.jsp

Answer 6

实现类/接口后，您将可以访问代码，并根据需要对其进行修改。

我想你对于语言在这里给你的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 7

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

OOP中的抽象概念及其在Java中的实现
java中的抽象类
摘要：有一个名为Abstract的OOP概念。在这里，用户可以捕获对象的必要特征。这个抽象概念在java中作为类和对象实现。因此，当您以类的形式捕获对象的重要特征时，向您提出问题，数据隐藏，这些特征只能由其自己的类对象访问。在这里，您将隐藏类/世界之外的所有类的功能。因此，它被称为数据隐藏
抽象类：这是Java实现的功能。如果您不了解完整的实现，那么您可以使用java的抽象类。

希望这有助于您理解一点

由于

Answer 8

它不会隐藏您的信息，而是隐藏在您的抽象客户端中。看一下这个例子。

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;
    }
}

类Client不知道Abstraction的实现，这意味着Demo类可以提供Abstraction的不同实现而不会弄乱Client }。

Answer 9

数据隐藏基本上隐藏了有关类的内部数据成员的详细信息，只有完全为相关类提供访问权限。

因此，它避免了应用程序中的其他类或任何其他应用程序的不必要的渗透，这意味着其他类不能直接访问私有成员变量。

因此，通过这种方式，你可以抽象相关类的内部细节。

JAVA - 抽象

9 个答案: