抽象类与接口

抽象类与抽象方法

抽象类使用 abstract 修饰，不能被实例化，可包含抽象方法和具体方法。抽象方法没有方法体，必须在派生类中重写。

示例

CSHARP

abstract class Shape
{
    public string Name { get; set; }

    public abstract double Area();

    public void Print()
    {
        Console.WriteLine($"{Name} 面积: {Area():F2}");
    }
}

class Circle : Shape
{
    public double Radius { get; set; }

    public Circle(double radius)
    {
        Name = "圆形";
        Radius = radius;
    }

    public override double Area()
    {
        return Math.PI * Radius * Radius;
    }
}

class Rectangle : Shape
{
    public double Width { get; set; }
    public double Height { get; set; }

    public Rectangle(double w, double h)
    {
        Name = "矩形";
        Width = w;
        Height = h;
    }

    public override double Area()
    {
        return Width * Height;
    }
}

Circle c = new Circle(3);
Rectangle r = new Rectangle(4, 5);
c.Print();
r.Print();

▶ 试一试

TEXT

圆形 面积: 28.27
矩形 面积: 20.00

💡 抽象类就像一个"半成品模板"，规定了子类必须完成的部分（抽象方法），也提供了可以直接使用的部分（具体方法）。

抽象类与普通类的区别

特性	普通类	抽象类
实例化	可以	不可以
抽象方法	不可以包含	可以包含
具体方法	可以	可以
构造函数	有	有
字段	有	有
被继承	可选重写virtual	必须重写abstract
sealed修饰	可以	不可以（矛盾）

示例

CSHARP

abstract class Logger
{
    protected string prefix;

    public Logger(string prefix)
    {
        this.prefix = prefix;
    }

    public abstract void Log(string message);

    public void LogWithTimestamp(string message)
    {
        string ts = DateTime.Now.ToString("HH:mm:ss");
        Log($"[{ts}] {message}");
    }
}

class FileLogger : Logger
{
    public FileLogger() : base("FILE") { }

    public override void Log(string message)
    {
        Console.WriteLine($"{prefix}: {message}");
    }
}

FileLogger fl = new FileLogger();
fl.Log("启动服务");
fl.LogWithTimestamp("连接数据库");

▶ 试一试

TEXT

FILE: 启动服务
FILE: [14:30:00] 连接数据库

⚠️ 抽象类可以有构造函数，但构造函数不能是 abstract 的。构造函数在子类实例化时通过 base() 调用。

接口定义与实现

接口使用 interface 关键字定义，是一组成员的契约。实现接口的类必须提供所有成员的实现。接口成员默认为 public，不能有访问修饰符。

示例

CSHARP

interface IMovable
{
    void Move(double dx, double dy);
    double Speed { get; set; }
}

interface IDrawable
{
    void Draw();
}

class Player : IMovable, IDrawable
{
    public double X { get; set; }
    public double Y { get; set; }
    public double Speed { get; set; }

    public Player(double x, double y, double speed)
    {
        X = x;
        Y = y;
        Speed = speed;
    }

    public void Move(double dx, double dy)
    {
        X += dx * Speed;
        Y += dy * Speed;
        Console.WriteLine($"移动到 ({X:F1}, {Y:F1})");
    }

    public void Draw()
    {
        Console.WriteLine($"绘制玩家 @ ({X:F1}, {Y:F1})");
    }
}

Player p = new Player(0, 0, 2.0);
p.Draw();
p.Move(3, 4);
p.Draw();

▶ 试一试

TEXT

绘制玩家 @ (0.0, 0.0)
移动到 (6.0, 8.0)
绘制玩家 @ (6.0, 8.0)

📌 接口名称推荐以大写字母 I 开头，如 IComparable、IDisposable，这是 C# 的命名约定。

多接口实现

一个类可以实现多个接口，用逗号分隔。这是 C# 实现多态的方式之一，弥补了单继承的限制。

示例

CSHARP

interface IWalkable
{
    void Walk();
}

interface ISwimmable
{
    void Swim();
}

interface IFlyable
{
    void Fly();
}

class Duck : IWalkable, ISwimmable, IFlyable
{
    public string Name { get; set; }

    public Duck(string name)
    {
        Name = name;
    }

    public void Walk()
    {
        Console.WriteLine($"{Name} 摇摇摆摆地走");
    }

    public void Swim()
    {
        Console.WriteLine($"{Name} 在水里游");
    }

    public void Fly()
    {
        Console.WriteLine($"{Name} 扑腾翅膀飞起来");
    }
}

Duck d = new Duck("唐老鸭");
d.Walk();
d.Swim();
d.Fly();

IWalkable walker = d;
walker.Walk();

ISwimmable swimmer = d;
swimmer.Swim();

▶ 试一试

TEXT

唐老鸭 摇摇摆摆地走
唐老鸭 在水里游
唐老鸭 扑腾翅膀飞起来
唐老鸭 摇摇摆摆地走
唐老鸭 在水里游

💡 不同接口类型的变量只能调用该接口定义的成员，这是接口隔离原则的体现。

接口默认方法（C# 8）

从 C# 8 开始，接口可以包含默认实现的方法。这允许在不破坏现有实现类的情况下向接口添加新成员。

示例

CSHARP

interface ILogger
{
    void Log(string message);

    void LogWarning(string message)
    {
        Log($"[WARN] {message}");
    }

    void LogError(string message)
    {
        Log($"[ERROR] {message}");
    }
}

class ConsoleLogger : ILogger
{
    public void Log(string message)
    {
        Console.WriteLine(message);
    }
}

class SimpleLogger : ILogger
{
    public void Log(string message)
    {
        Console.WriteLine($">> {message}");
    }
}

ConsoleLogger cl = new ConsoleLogger();
cl.Log("系统启动");
cl.LogWarning("内存不足");
cl.LogError("连接失败");

SimpleLogger sl = new SimpleLogger();
sl.Log("系统启动");
sl.LogWarning("内存不足");

▶ 试一试

TEXT

系统启动
[WARN] 内存不足
[ERROR] 连接失败
>> 系统启动
>> [WARN] 内存不足

⚠️ 默认方法仅在通过接口类型调用时可用，通过实现类类型的变量无法调用默认方法（除非实现类也重新实现该方法）。