数据隐藏基本上是隐藏类的内部数据成员的细节，并且只允许相关类访问它。
因此，它避免了来自应用程序中其他类或任何其他应用程序的不必要的渗透，这意味着其他类不能直接访问私有成员变量。
因此，通过这种方式可以抽象出相关类的内部细节。

我认为你对两件事感到困惑
面向对象的抽象概念及其java实现
java中的抽象类
摘要：有一个面向对象的概念叫做抽象。在这里，用户可以捕获对象的必要特征。这个抽象概念在java中实现为类和对象。所以，接下来的问题是，数据隐藏，当你以类的形式捕获一个对象的重要特性时，这些特性只能被自己类的对象访问。在这里，您对类/世界外部隐藏了类的所有特性。因此，它被称为数据隐藏
抽象类：这是java实现的特性。如果您不知道完整的实现，那么您可以选择java的抽象类。
希望这能帮助你理解一点
谢谢

您将抽象（编程模式）与java语言的抽象关键字混为一谈。尽管有相似之处，但它们在语义上的关联却很小。
抽象意味着对使用类或方法的代码隐藏实现细节。使用您的方法的代码不需要知道您正在使用数组、动态指针或文件系统中的嵌入式数据库或文件来实现列表。
abstract用于标记具有仅声明而未实现的方法的类。它是“抽象的”，因为它们不能被示例化，您不能从这些类中创建任何示例（但是您可以从它们的具体子类中创建它们）。

我不确定这是否回答了您的问题，但是如果您通常谈论抽象类，那么抽象类是为子类提供功能的，子类不必知道或处理实现的所有细节（它对子类的用户是隐藏的）。
以汽车为例：

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是一个vehicle对象的抽象示例，并且已经有了一些与之相关联的功能，比如车轮的数量。它是一个受保护的方法，因此如果我创建一个truck的新示例：

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

但是，如果我要在类中为truck编写一个函数，例如：

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

所以我可以这样称呼它：

// Inside main
truck.addSpareTire();

我仍然可以与一些变量交互，但只能彻底检查扩展抽象类的类中的函数。我可以打电话一次加一个轮胎 addSpareTire() ，但我无法直接与 _numberOfWheels 从我使用 Truck 物体，但我可以从内部 Truck 类声明。对于卡车对象的用户，该信息是隐藏的。
我不知道这是不是你想要的。希望这有帮助。

一旦实现了类/接口，就可以访问代码，并根据需要修改它。
我猜你对语言给你的概念有点困惑 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?

数据隐藏是指您无法理解如何在内部使用api（例如， ArrayList )没有阅读文档。api创建者不提供任何对底层数组的访问。
对将使用它的用户隐藏api实现。他们不应该担心它在内部是如何工作的，他们只对提供给他们的功能感兴趣。
有一篇关于这个的好文章。

也许一个例子能帮你更好。假设您要实现一个图类，它可能具有邻接列表或邻接矩阵来表示其节点。因此，抽象地说，您至少要将“addnode”“addedge”添加到这个图中：

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

通过多态性调用两个不同的函数，但得到的结果与图的客户机相同。
另一个真实的例子是汽车刹车。作为一个汽车客户，制造商给你一个踏板来推动，而不知道什么是执行制动的后端。它可以是一个鼓式制动器或盘式制动器执行在后面。你只要踩刹车就行了！

在面向对象编程中，抽象是对用户隐藏实现细节的过程，只向用户提供功能。换句话说，用户将获得关于对象做什么而不是如何做的信息。
有关详细信息，请查看以下链接：http://www.visionsdeveloper.com/tutorial/java/java-abstraction.jsp

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

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 .