抽象基类与作为超类型的具体类

Question

读完最优秀的书《Head First Design Patterns》后，我开始向同事宣传模式和设计原则的好处。在赞扬我最喜欢的模式（策略模式）的优点时，我被问了一个问题，这让我停了下来。当然，策略使用继承和组合，当一位同事问“为什么使用抽象基类而不是具体类？”时，我正在长篇大论地谈论“针对接口（或超类型）而不是实现进行编程”。 .
我只能想出“好吧，你强迫你的子类实现抽象方法并阻止它们实例化 ABC”。但说实话，这个问题让我措手不及。这些是在层次结构顶部使用抽象基类相对于具体类的唯一好处吗？

Answer 1

如果您需要实现特定方法，请使用接口。如果存在可以抽出的共享逻辑，请使用抽象基类。如果基本功能集本身是完整的，那么您可以使用 concreate 类作为基础。抽象基类和接口不能直接实例化，这是优点之一。如果您可以使用具体类型，那么您需要重写方法，这有一种“代码味道”。

Answer 2

针对接口编程，而不是针对实现与抽象类和具体类关系不大。还记得模板方法模式吗？类，无论是抽象的还是具体的，都是实现细节。

使用抽象类而不是具体类的原因是，您可以调用方法而不实现它们，而是将它们留给子类来实现。

对接口进行编程是另一回事 - 它定义 API 的作用，而不是定义 API 的作用方式。这是通过接口来表示的。

请注意一个关键区别 - 您可以拥有受保护的抽象方法，这意味着这是实现细节。但所有接口方法都是公共的——API 的一部分。

Answer 3

是的，尽管您也可以使用接口来强制类实现特定方法。

使用抽象类而不是具体类的另一个原因是抽象类显然无法实例化。有时您也不希望这种情况发生，因此抽象类是最佳选择。

Answer 4

首先，策略模式几乎不应该在现代 C# 中使用。它主要适用于 Java 等不支持函数指针、委托或一等函数的语言。您将在旧版本的 C# 中的 IComparer 等接口中看到它。

至于抽象基类与具体类，Java 中的答案始终是“在这种情况下什么效果更好？”如果您的策略可以共享代码，那么请务必让他们这样做。

设计模式并不是关于如何做某事的说明。它们是对我们已经做过的事情进行分类的方法。

Answer 5

抽象基类通常用于设计者想要强制采用一种架构模式的场景，其中某些任务由所有类以相同的方式执行，而其他行为依赖于子类。
例如：

public abstract class Animal{

public void digest(){

}

public abstract void sound(){

}
}

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

策略模式要求设计者在行为存在一系列算法的情况下使用组合行为。

Answer 6

如果客户端依赖于“隐含行为契约”，​​则它是针对实现和不受保证的行为进行编程的。在遵循契约的同时重写该方法只会暴露客户端中的错误，而不是导致错误。

OTOH，如果所讨论的方法是非虚拟的，那么假设不存在的合同的错误不太可能导致问题——也就是说，覆盖它不会导致问题，因为它不能被覆盖。只有改变原始方法的实现（同时仍然遵守契约）才能破坏客户端。

Answer 7

基类应该是抽象的还是具体的问题很大程度上取决于仅实现类中所有对象共有的行为的基类对象是否有用。考虑一个 WaitHandle。对其调用“wait”将导致代码阻塞，直到满足某些条件为止，但没有通用的方法来告诉 WaitHandle 对象其条件已满足。如果可以实例化“WaitHandle”，而不是只能实例化派生类型的实例，那么这样的对象将必须要么从不等待，要么永远等待。后一种行为是毫无用处的。前者可能很有用，但几乎可以通过静态分配的 ManualResetEvent 来实现（我认为后者浪费了一些资源，但如果它是静态分配的，总资源损失应该是微不足道的）。

在许多情况下，我认为我的偏好是使用对接口的引用而不是对抽象基类的引用，但为接口提供一个提供“模型实现”的基类。因此，任何地方只要使用对 MyThing 的引用，就会提供对“iMyThing”的引用。很可能 99%（甚至 100%）的 iMyThing 对象实际上是 MyThing，但如果有人需要拥有一个继承自其他对象的 iMyThing 对象，则可以这样做。

Answer 8

在以下场景中首选抽象基类：

1. 基类不能没有子类而存在=>基类只是抽象的，无法实例化。
2. 基类不能具有方法的完整或具体实现 =>基类方法的实现是不完整的，只有子类可以提供完整的实现。
3. 基类提供了方法实现的模板，但仍然依赖具体类来完成方法实现 -Template_method_pattern

一个简单的例子来说明以上几点

Shape 是抽象的，如果没有像 Rectangle 这样的具体形状，它就不可能存在。绘制 Shape 无法在 Shape 类中实现，因为不同的形状有不同的公式。处理场景的最佳选择：将 draw() 实现留给子类

abstract class Shape{
    int x;
    int y;
    public Shape(int x,int y){
        this.x = x;
        this.y = y;
    }
    public abstract void draw();
}
class Rectangle extends Shape{
    public Rectangle(int x,int y){
        super(x,y);
    }
    public void draw(){
        //Draw Rectangle using x and y : length * width
        System.out.println("draw Rectangle with area:"+ (x * y));
    }
}
class Triangle extends Shape{
    public Triangle(int x,int y){
        super(x,y);
    }
    public void draw(){
        //Draw Triangle using x and y : base * height /2
        System.out.println("draw Triangle with area:"+ (x * y) / 2);
    }
}
class Circle extends Shape{
    public Circle(int x,int y){
        super(x,y);
    }
    public void draw(){
        //Draw Circle using x as radius ( PI * radius * radius
        System.out.println("draw Circle with area:"+ ( 3.14 * x * x ));
    }
}

public class AbstractBaseClass{
    public static void main(String args[]){
        Shape s = new Rectangle(5,10);
        s.draw();
        s = new Circle(5,10);
        s.draw();
        s = new Triangle(5,10);
        s.draw();
    }
}

输出：

draw Rectangle with area:50
draw Circle with area:78.5
draw Triangle with area:25

上面的代码涵盖了第 1 点和第 2 点。您可以将 draw() 方法更改为模板方法如果基类有一些实现并调用子类方法来完成draw()功能。

现在使用模板方法模式的相同示例：

abstract class Shape{
    int x;
    int y;
    public Shape(int x,int y){
        this.x = x;
        this.y = y;
    }
    public abstract void draw();

    // drawShape is template method
    public void drawShape(){
        System.out.println("Drawing shape from Base class begins");
        draw();
        System.out.println("Drawing shape from Base class ends");       
    }
}
class Rectangle extends Shape{
    public Rectangle(int x,int y){
        super(x,y);
    }
    public void draw(){
        //Draw Rectangle using x and y : length * width
        System.out.println("draw Rectangle with area:"+ (x * y));
    }
}
class Triangle extends Shape{
    public Triangle(int x,int y){
        super(x,y);
    }
    public void draw(){
        //Draw Triangle using x and y : base * height /2
        System.out.println("draw Triangle with area:"+ (x * y) / 2);
    }
}
class Circle extends Shape{
    public Circle(int x,int y){
        super(x,y);
    }
    public void draw(){
        //Draw Circle using x as radius ( PI * radius * radius
        System.out.println("draw Circle with area:"+ ( 3.14 * x * x ));
    }
}

public class AbstractBaseClass{
    public static void main(String args[]){
        Shape s = new Rectangle(5,10);
        s.drawShape();
        s = new Circle(5,10);
        s.drawShape();
        s = new Triangle(5,10);
        s.drawShape();
    }
}

输出：

Drawing shape from Base class begins
draw Rectangle with area:50
Drawing shape from Base class ends
Drawing shape from Base class begins
draw Circle with area:78.5
Drawing shape from Base class ends
Drawing shape from Base class begins
draw Triangle with area:25
Drawing shape from Base class ends

一旦您决定必须将其作为方法abstract，您有两个选择：用户interface或abstract类。您可以在接口中声明方法，并将抽象类定义为实现接口的类。