java - Java 中的抽象？

Question

今天听 friend 说，封装不仅实现了信息隐藏，还实现了抽象。它是如何实现的？

public class employee {

     private String name;
     private int id;

     public void setName(String name){
         this.name = name;
     }

     public String getName(){
         return name;
     }
}

上面的例子实现了封装，我允许类访问我的公共(public)方法而不是私有(private)成员，但是这里的抽象在哪里出现？谁能以一种清晰的方式向我解释抽象。

Answer 1

有两种不同的东西，信息隐藏和抽象。

信息隐藏使抽象成为可能，但这是不同的东西。例如，使用您的代码

public class employee {

     private String name;
     private int id;

     public void setName(String name) {
         this.name = name;
     }

     public String getName(){
         return name;
     }
}

id 字段实际上是隐藏的。这允许以一种与程序的其余部分分离的方式处理 id。您的名称字段实际上也是隐藏的，因为您不直接访问名称字段，但 getName 和 setName 中的代码可以。

一旦您对其余代码隐藏了数据结构，强制通过方法进行访问，就可以创建一个项目的多个可替换实现。例如，employee 是一种概念上的 person，因此您可以像这样重写上面的内容:

public interface Person {
     public abstract String getName();
}

public class Employee implements Person {

     private String name;
     private int id;

     public void setName(String name){
         this.name = name;
     }

     public String getName(){
         return name;
     }
}

现在您的代码可以将 Employee 作为 Person 处理。重写未明确处理 Employee 以处理 Person 的其余代码后，您可以实现其他类型的 Person s 并利用现在属于 Person 任务的非员工特定任务。

public Customer implements Person {
     private String name;
     private integer moneySpent;

     public String getName() {
          return name;
     }
}

因此，一个人搜索例程，只要它只索引 Person 对象，现在就可以包括对 Employee 和 Customer 的搜索。这是因为处理 Person 对象的代码实际上是在处理 Employee 和 Customer 对象共享的更高级别的抽象。

在抽象层次上处理对象时，方法的名称在整个抽象层中共享；但是，实际执行的代码取决于未提及的对象的基础类型。换句话说，如果你问一个人(碰巧是雇员)getName() 那么它会用 Employee.getName() 函数响应，而 code>Customer 将使用 Customer.getName() 函数进行响应。由于调用 getName() 的代码是在 Person 上运行的，因此它不知道它将处理哪种类型的人，但行为的明显变化(选择基于每个对象的正确代码块)仍然会发生。这种现象称为 Polymorphisim，如果您是第一次接触这些概念，您会听到 Polymorphisim 作为一个经常使用的词。

多态行为的一个例子:

 public interface Animal {
     public abstract String makeSound();
 }

 public class Cow implements Animal {
     public String makeSound() {
         return "Moo Moo!";
     }
 }

 public class Dog implements Animal {
     public String makeSound() {
         return "Ruff Ruff!";
     }
 }

 public class Sheep implements Animal {
    public String makeSound() {
         return "Baa Baa!";
    }
 }

 // this class demonstrates the polymorphic behavior

 public class Farm {
    public static void main(String[] args) {
       ArrayList<Animal> animals = new ArrayList<Animal>();
       animals.add(new Cow());
       animals.add(new Sheep());
       animals.add(new Dog());

       for (Animal animal : animals) {
          // this is where the polymorphisim occurs
          // each animal will make a different sound
          // because the makeSound method is getting
          // bound to different blocks of code based
          // on the exact type of animal class hiding
          // under the Animal abstraction.
          System.out.println(animal.makeSound());
       }
    }
 }

预期输出:

 Moo Moo!
 Baa Baa!
 Ruff Ruff!

即使我们从未显式更改类，也从未显式更改方法。正在发生变化的是抽象方法与显式子类的绑定(bind)，这只发生在支持多态性的系统中。