java 中的抽象和数据隐藏

Question

我试图理解 java 中的抽象概念。当我阅读一些教程时，他们说 抽象是一个过程，您只显示“相关”数据并向用户“隐藏”对象的不必要细节。

这是抽象类如何工作的简单示例。

public class Demo {

    public static void main(String[] args) {
       Animal a = new Dog();
        a.sound();
    }
}

abstract class Animal {
    abstract void sound();
}

class Dog extends Animal {
    @Override
    public void sound() {
        System.out.println("woof");
    }
}

我明白，虽然抽象类我们可以在子类中实现通用方法，如 sound() 方法。

我不明白的是这如何帮助隐藏数据和仅查看必要的数据。

请给我解释一下这个概念。

如果你有很好的例子，请也包括在内。

Answer 1

Java 中的

Abstraction 与我们在软件工程术语中使用的内容没有什么不同。

抽象通常回答问题陈述的 WHAT 部分。

系统将支持哪些操作？
系统的用途是什么？

想想抽象数据类型：示例 Stack

你关心的只是

pop() --> return 你顶元素
push() --> 添加元素

你根本不关心实现细节。所以你的 java 类是以同样的方式抽象出来的。

Answer 2

抽象意味着 - 而不是 providing/having 实现细节。想象一下，您有权决定汽车必须具有哪些零件。您将把这些功能列为抽象方法。

稍后您将把这个（合同）抽象模板分享给现代、福特等，让他们有自己的实现来制作完整的汽车。

Answer 3

抽象不仅仅是向用户显示“相关”数据和“隐藏” 对象的不必要细节。

数据抽象是属性，通过它只有基本的细节显示给 user.The 琐碎的或不显示给用户的非基本单元。 例如：汽车被视为一辆汽车，而不是它的各个部件。

In java, abstraction is achieved by interfaces and abstract classes. We can achieve 100% abstraction using interfaces.

您在示例中解释的只是一种形式。

在您的 Animal 示例中 class，如果 sound() 方法不是抽象方法并且您在其中有一些随机抽象方法 class，想象一下有人写了 Animal class 并且你在 Dog class 中扩展它。无论在 Actual Animal class 中的实现如何，您都可以在当前 class.

中编写代码

假设您还没有覆盖 Dog class 中的 sound() 方法，如果您调用 `

Dog d= new Dog(); d.sound();

` 将为您提供 Animal sound() 的代码。[鉴于：sound() 方法不是抽象的]。 Animal class 的代码将被执行。 Dog 对象甚至不知道 sound() 方法中有什么……但它仍然可以使用它。这种不知而能用的过程才是真正的抽象

正如 Yati Sawhney 所提到的，pop() 和 push() 方法是很好的例子。

否则，

you can have hascode() and equals() method from Object class, where no one knows how the calculation is done but you end up with a number and comparing the references respectively.

数据Hiding/Encapsulation:

数据隐藏与抽象不同。不要将一个与另一个混淆。

Abstraction is hiding the code implementation from other Object/user whereas Data hiding is achieved by Encapsulation via POJO classes.

Data hiding has to do with the instance variables which decides the state of the Object. Hiding its content using the setter() and Getter() methods is Data Hiding/ Encapsulation.

您可能想知道，getter() 方法如何隐藏数据，而它只是 returns 我们请求的数据，但关于 getter/setter 方法有一个不为人知的故事。

例子： 参考下面代码中的getName()方法

public class Person  {


    private  int age;
    private  String name;



    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
       // can restrict the code without displaying data to user
         if(condition)//restricted user check
            return null;//returning null because the user is not supposed to view the data

        return name;
    }

}

Answer 4

在您的示例中，您创建了一个 Dog，然后将其用作动物。在这种情况下，抽象不是很有用，因为您知道变量 a 总是指狗。现在假设在其他 class 中你有一个方法 soundTwice:

class OutsideWorld {
    static void soundTwice(Animal a) {
        a.sound();
        a.sound();
    }
}

这里不知道Animala指的是什么，但还是可以发两声

更新

我添加这个 class 因为 class Demo 没有隐藏太多：它需要知道 class Dog 因为它创建它的一个实例。 class OutsideWorld 另一方面却不知道：它只知道 class Animal 和 class Animal 公开的内容。它甚至不知道 class Dog 存在。

我们现在可以写一个 class Cat 方法 sound ("meow") 的不同实现，我们仍然可以使用相同的 soundTwice 方法与 Cat.

然后我们可以重写 Demo class:

public class Demo {
    public static void main(String[] args) {
        Animal a = new Dog();
        OutsideWorld.soundTwice(a);
        a = new Cat();
        OutsideWorld.soundTwice(a);
    }
}

这当然会产生输出：

woof
woof
meow
meow

Answer 5

抽象

实现抽象的方法 java

中有两种实现抽象的方法

摘要class（0 到 100%）
界面 (100%)

基本知识： 抽象方法和类

一个抽象class是一个被声明为抽象的class——它可能包括也可能不包括抽象方法。抽象classes不能被实例化，但可以被子classed。

    public abstract class ClassName{
       // declare fields
      // declare nonabstract methods
      abstract void methodName();
    }

当抽象 class 被子class 时，子class 通常为其父class 中的所有抽象方法提供实现。但是，如果不是，则 subclass 也必须声明为抽象的。

一个抽象方法是一个没有实现声明的方法（没有大括号，后面跟一个分号），像这样：

abstract void methodName(Parameter List);

抽象是隐藏实现细节并仅向用户显示功能的过程。

理解抽象的真实场景class:

考虑制作一个函数来获取任何学校的学生强度的情况。

现在我们将创建一个抽象 class 和抽象函数 getStrength()。

然后每个学校（政府或私立）都可以使用这个抽象方法并提供实现。

//Consider this Code


package Whosebug;

abstract class StudentStrength {

    abstract int getStrength();
}

class GovtSchool extends StudentStrength {

    @Override
    int getStrength() {
        return 100;

    }
}

class PrivateSchool extends StudentStrength {

    @Override
    int getStrength() {
        return 200;

    }
}

public class GetInfo {
    public static void main(String args[]) {

        StudentStrength ss;

        // referring abstract class and creating object of child class
        ss = new GovtSchool();
        System.out.println("Student strength in Govt School : "+ ss.getStrength());
        // output of above : 100
        ss = new PrivateSchool();
        System.out.println("Student strength in Private School : "+ ss.getStrength());
        // output of above : 200
    }
}

解释：

在这个例子中，StudentStrength 是抽象的 class，它的实现由政府学校和私立学校提供 classes.

大多数情况下，我们不知道实现 class（即对最终用户隐藏），实现的对象 class 由工厂方法提供。

在此示例中，如果您创建 GovtSchool class 的实例，将调用 GovtSchool class 的 getStrength() 方法。

文件：GetInfo.java

Student strength in Govt School : 100 Student strength in Private School : 200

回答： 我不明白的是这如何帮助隐藏数据和仅查看必要的数据。

如上面的代码所示，我们引用了抽象 class 并使用子 class 的功能向最终用户隐藏了子 class 的工作。

希望对您有所帮助:)

java 中的抽象和数据隐藏

Abstraction and Data Hiding in java

java

oop

abstraction

data-hiding

抽象