使用抽象方法有什么意义？

Question

使用“抽象方法”有什么意义？抽象类不能被实例化，但是抽象方法呢？它们只是在这里说“你必须实现我”，如果我们忘记它们，编译器会抛出错误吗？

难道还有别的意思吗？我还读过一些关于“我们不必重写相同的代码”的内容，但是在抽象类中，我们只“声明”抽象方法，因此我们必须重写子类中的代码。

你能帮我多理解一点吗？我检查了有关“抽象类/方法”的其他主题，但没有找到答案。

Answer 1

假设您有三台打印机，需要为其编写驱动程序：Lexmark、Canon 和 HP。

所有三台打印机都具有 print() 和 getSystemResource() 方法。

但是，每台打印机的 print() 都会有所不同，并且 getSystemResource() 对于所有三台打印机保持相同。您还有另一个顾虑，您想应用多态性。

由于 getSystemResource() 对于所有三种打印机来说都是相同的，因此您可以将其推送到要实现的超类，并让子类实现 print()。在 Java 中，这是通过在超类中使 print() 抽象来完成的。注意：当在类中将方法抽象化时，类本身也需要是抽象的。

public abstract class Printer{
  public void getSystemResource(){
     // real implementation of getting system resources
  }
  
  public abstract void print();
}

public class Canon extends Printer{
  public void print(){
    // here you will provide the implementation of print pertaining to Canon
  }
}

public class HP extends Printer{
  public void print(){
    // here you will provide the implementation of print pertaining to HP
  }
}

public class Lexmark extends Printer{
  public void print(){
    // here you will provide the implementation of print pertaining to Lexmark
  }
}

请注意，HP、Canon 和 Lexmark 类不提供 getSystemResource() 的实现。

最后，在主类中，您可以执行以下操作：

public static void main(String args[]){
  Printer printer = new HP();
  printer.getSystemResource();
  printer.print();
}

Answer 2

除了提醒您必须实现它之外，最大的优点是任何通过抽象类类型（包括抽象类本身中的 this）引用该对象的人都可以使用该方法。

例如，假设我们有一个类负责获取状态并以某种方式操作它。抽象类将负责获取输入，将其转换为long（例如），并以某种方式将该值与先前的值组合起来——“某种方式”就是抽象方法。抽象类可能看起来像：

public abstract class StateAccumulator {
    protected abstract long accumulate(long oldState, long newState);

    public handleInput(SomeInputObject input) {
        long inputLong = input.getLong();
        state = accumulate(state, inputLong);
    }

    private long state = SOME_INITIAL_STATE;
}

现在您可以定义一个加法累加器：

public class AdditionAccumulator extends StateAccumulator {
    @Override
    protected long accumulate(long oldState, long newState) {
        return oldState + newState;
    }
}

如果没有该抽象方法，基类将无法说“以某种方式处理此状态”。不过，我们不想在基类中提供默认实现，因为这没有多大意义——如何为“其他人将实现这个”定义默认实现？

请注意，剥猫皮的方法不止一种。 策略模式将涉及声明一个声明accumulate模式的接口，并将该接口的实例传递给不再抽象的基类。用行话来说，这是使用组合而不是继承（您已经用两个对象（一个聚合器和一个加法器）组合了一个加法聚合器）。

Answer 3

抽象类是包含一个或多个抽象方法的类。抽象方法是已声明但不包含实现的方法。抽象类不能被实例化，并且需要子类提供抽象方法的实现。让我们看一个抽象类和抽象方法的示例。

假设我们通过创建一个以名为 Animal 的基类开始的类层次结构来建模动物的行为。动物能够做不同的事情，比如飞行、挖掘和行走，但也有一些常见的操作，比如吃饭、睡觉和发出声音。所有动物都会执行一些常见的操作，但方式也不同。当以不同方式执行操作时，它是抽象方法的良好候选者（强制子类提供自定义实现）。让我们看一个非常原始的 Animal 基类，它定义了一个用于发出声音（例如狗叫、牛叫或猪叫）的抽象方法。

public abstract Animal {

public void sleep{
// sleeping time
}
public void eat(food)
{
//eat something
}
public abstract void makeNoise();
}
public Dog extends Animal {
 public void makeNoise() {
 System.out.println("Bark! Bark!");
 }
}
public Cow extends Animal {
 public void makeNoise() {
 System.out.println("Moo! Moo!");
 }
}

请注意，abstract 关键字用于表示抽象方法和抽象类。现在，任何想要实例化的动物（如狗或牛）都必须实现 makeNoise 方法 - 否则无法创建该类的实例。让我们看一下扩展 Animal 类的 Dog 和 Cow 子类。

现在您可能想知道为什么不将抽象类声明为接口，并让 Dog 和 Cow 实现该接口。当然可以 - 但您还需要实现 eat 和 sleep 方法。通过使用抽象类，您可以继承其他（非抽象）方法的实现。您不能使用接口来做到这一点 - 接口不能提供任何方法实现。

简而言之，接口应该包含所有抽象方法，但不包含方法的实现，或者我们不能在接口中定义非抽象方法，在接口中所有方法都应该是抽象的，但在抽象类中我们可以同时定义抽象方法和非抽象方法，所以为了定义非抽象方法，我们不必定义另一个类来实现同一对象的行为，这是抽象类相对于接口的优势。

Answer 4

抽象方法仅仅定义派生类必须实现的契约。这是您确保他们实际上始终会这样做的方式。

让我们以抽象类 Shape 为例。它将有一个应该绘制它的抽象方法draw()。 （Shape 是抽象的，因为我们不知道如何绘制一般形状）通过在 Shape 中使用抽象方法 draw，我们保证所有派生的类，实际上可以绘制，例如Circle就实现了draw。稍后，如果我们忘记在从 Shape 派生的某个类中实现 draw，编译器实际上会提供帮助并给出错误。

Answer 5

简单地说，将一个类声明为“抽象”类，就是为继承它的子类强制执行“契约”，因此它提供了维护“契约”的好方法。

Answer 6

如果抽象所做的只是声明抽象方法，那么您是对的，这有点愚蠢，并且接口可能会更好。

但抽象类通常会实现一些（甚至可能是全部）方法，只留下少数方法是抽象的。例如，抽象表模型。这节省了重写大量代码。

相对于接口的另一个“优点”是抽象类可以声明供子类使用的字段。因此，如果您非常确定任何合理的实现都会有一个名为 uniqueID 的字符串，您可以在抽象类中声明它以及相关的 getter/setter，从而节省稍后的一些输入。

Answer 7

抽象方法必须由任何非抽象的子类重写。

因此，例如，您定义一个抽象类 Log 并强制子类重写该方法：

public abstract class Log{
  public void logError(String msg){
    this.log(msg,1)
  }
  public void logSuccess(String msg){
    this.log(msg,2)
  }
  public abstract void log(String msg,int level){}
}

public class ConsoleLog{
  public void log(String msg,int level){
    if(level=1){
       System.err.println(msg)
    }else{
       System.out.println(msg)
    }
  }
}