C# 抽象类：抽象方法、示例及与接口的区别

抽象类是一种只为被继承而存在的类。它不能被实例化，并且可以声明抽象成员：没有方法体的方法和属性，每个具体的派生类都必须实现它们。除此之外，它就是一个普通的类：可以有字段、构造函数，以及派生类会继承的完整实现的方法。

声明抽象类

把类标记为 abstract，再把每个必须由派生类提供的成员也标记为 abstract，并用分号代替方法体结尾：

using System;
using System.Collections.Generic;

abstract class Shape
{
    public string Label { get; }

    protected Shape(string label) { Label = label; }

    public abstract double Area();              // no body: each shape must implement it
    public abstract double Perimeter();

    public string Describe() =>                 // shared, concrete method
        $"{Label}: area {Area():F2}, perimeter {Perimeter():F2}";
}

class Circle : Shape
{
    private readonly double radius;
    public Circle(double radius) : base("Circle") { this.radius = radius; }

    public override double Area() => Math.PI * radius * radius;
    public override double Perimeter() => 2 * Math.PI * radius;
}

class Rectangle : Shape
{
    private readonly double width, height;
    public Rectangle(double w, double h) : base("Rectangle") { width = w; height = h; }

    public override double Area() => width * height;
    public override double Perimeter() => 2 * (width + height);
}

class Program
{
    static void Main()
    {
        var shapes = new List<Shape> { new Circle(1.5), new Rectangle(4, 2.5) };
        foreach (Shape s in shapes)
            Console.WriteLine(s.Describe());

        // var s2 = new Shape("blob"); // error CS0144: Cannot create an instance of the abstract type or interface 'Shape'
    }
}

输出：

Circle: area 7.07, perimeter 9.42
Rectangle: area 10.00, perimeter 13.00

Describe 只在基类中写了一次，它调用了 Area 和 Perimeter，而这两个方法在 Shape 中根本不存在实现。这正是抽象成员的意义：基类可以依赖它们，而编译器保证每个具体的形状都提供了它们。忘了实现其中一个的派生类无法通过编译：

class Triangle : Shape
{
    public Triangle() : base("Triangle") { }
    public override double Area() => 6;
}
// error CS0534: 'Triangle' does not implement inherited abstract member 'Shape.Perimeter()'

修复方法是实现 Perimeter，或者如果 Triangle 是给更多类使用的中间基类，就把它本身也标记为 abstract。

抽象成员的规则

• 抽象成员没有方法体，并且隐式地是虚的：派生类用 override 来实现它。
• 只有抽象类才能包含抽象成员。在普通类中放一个抽象成员是编译错误。
• 类中的抽象成员不能是 private（没人能重写它）或 static。
• 方法、属性、索引器和事件都可以是抽象的。字段和构造函数不行。
• 抽象类不一定要包含抽象成员。只把一个类标记为 abstract，作用就是禁止实例化，适合那些只有通过子类才有意义的基类。

抽象属性声明了派生类必须提供哪些访问器：

abstract class Plan
{
    public abstract decimal MonthlyPrice { get; }
    public abstract string Name { get; }
}

class ProPlan : Plan
{
    public override decimal MonthlyPrice => 12.99m;
    public override string Name => "Pro";
}

抽象类中的构造函数

抽象类可以有构造函数。它们不能通过 new 调用，但每个派生类的构造函数都会通过 : base(...) 执行其中一个，所以共享状态就是在这里初始化和验证的。把它们声明为 protected，这正好表达了它的含义：只有派生类能使用它。

模板方法模式

编写抽象类最常见的理由，是在基类中固定一个算法的顺序，让派生类去填充各个步骤。执行这些步骤的基类方法不是虚方法，所以任何子类都不能调换或跳过这些步骤。

using System;
using System.Collections.Generic;
using System.Text;

abstract class OrderExporter
{
    // The template: the steps and their order are fixed here.
    public string Export(IEnumerable<(string Item, int Qty, decimal Price)> rows)
    {
        var sb = new StringBuilder();
        sb.Append(Header());
        decimal total = 0;
        foreach (var r in rows)
        {
            sb.Append(Row(r.Item, r.Qty, r.Price));
            total += r.Qty * r.Price;
        }
        sb.Append(Footer(total));
        return sb.ToString();
    }

    protected abstract string Header();
    protected abstract string Row(string item, int qty, decimal price);
    protected virtual string Footer(decimal total) => "";   // optional step with a default
}

class CsvExporter : OrderExporter
{
    protected override string Header() => "item,qty,price\n";
    protected override string Row(string item, int qty, decimal price) => $"{item},{qty},{price}\n";
}

class MarkdownExporter : OrderExporter
{
    protected override string Header() => "| Item | Qty | Price |\n| --- | --- | --- |\n";
    protected override string Row(string item, int qty, decimal price) => $"| {item} | {qty} | {price} |\n";
    protected override string Footer(decimal total) => $"\nTotal: {total}\n";
}

class Program
{
    static void Main()
    {
        var rows = new List<(string, int, decimal)> { ("Coffee beans", 2, 11.50m), ("Filter papers", 1, 3.20m) };

        OrderExporter[] exporters = { new CsvExporter(), new MarkdownExporter() };
        foreach (var e in exporters)
            Console.Write(e.Export(rows) + "\n");
    }
}

输出：

item,qty,price
Coffee beans,2,11.50
Filter papers,1,3.20

| Item | Qty | Price |
| --- | --- | --- |
| Coffee beans | 2 | 11.50 |
| Filter papers | 1 | 3.20 |

Total: 26.20

每一行是一个命名元组，输出是用 StringBuilder 构建的。注意这里的搭配：Header 和 Row 是 abstract，因为每种格式都必须决定它们；Footer 是带空默认实现的 virtual，因为大多数格式在那里什么都不需要。这些步骤都是 protected，所以外部代码只能调用 Export。框架中的类也采用同样的思路：Stream 和 TextWriter 都是抽象基类，它们众多的便利方法都建立在派生类提供的少数几个成员之上（流是 Read 和 Write，文本写入器是 Write(char)）。

抽象类与接口

两者都能让你针对一个类型编写代码，而不需要知道具体的类。它们的区别在于能包含什么，以及一个类能拥有几个：

默认接口方法（C# 8）缩小了两者的差距，但核心区别依然存在：

public interface ILogger
{
    void Write(string message);
    void Error(string message) => Write("ERROR: " + message);   // default implementation: C# 8, .NET Core 3.0+
}

默认方法仍然无法访问实例字段，因为接口根本没有实例字段；它只能调用接口的其他成员。

一个实用的选择方法：

• 接口：当你描述的是互不相关的类型都可以具备的一种能力（IComparable<T>、IDisposable、IShippingProvider），当结构体也应该能参与进来，或者当一个类需要同时扮演好几个这样的角色时。正因如此，大多数依赖注入代码都是针对接口编写的。
• 抽象类：当派生类型确实是同一种东西的不同变体，并共享状态或一个固定的算法时，比如上面的导出器。
• 两者兼用也很常见：一个接口供调用者依赖，再加一个实现该接口的抽象基类，让实现者不必重写共享的部分。接口那一页会详细讲解接口这一侧。

常见错误

• 试图实例化基类。 new Shape(...) 会报 CS0144。请实例化派生类。
• 实现时忘了写 override。 在派生类中写 public double Area() 并不会实现抽象成员；编译器会因为缺少实现而报 CS0534，同时还会警告这个新方法隐藏了继承来的方法。
• 抽象类上的 public 构造函数。 无害，但有误导性。请用 protected。
• 没有共享代码的抽象类。 如果基类只有抽象成员而没有状态，用接口就能表达同样的意思，而且不会占用唯一的基类名额。
• 在基类构造函数中调用抽象成员。 派生类的实现会在派生类构造函数的方法体之前执行，所以那个方法体负责赋值的字段此时仍然是 0 或 null。