抽象类(abstract class)与接口(interface)

A. 核心概念

1.抽象类- 定义：带有 abstract 修饰符的类，不能被实例化，用于定义一组方法签名和可选的部分公共实现。- 特性：

- 可以包含字段、构造函数、已实现的方法（带方法体）和抽象方法（无方法体）。

- 支持访问修饰符（public、protected、internal、private）。

- 子类使用 override 实现抽象方法，也可重写虚方法。- 作用：在父类中复用代码、维护公共状态，同时强制子类实现某些功能。

2.接口- 定义：只包含成员签名（方法、属性、事件、索引器）的契约。C# 8.0+ 支持接口默认实现（default implementation）。- 特性：

- 成员默认都是 public，不能声明字段。

- 一个类/结构体可以实现多个接口，支持多重“继承”。

- C# 8.0 之后可在接口中提供 default 方法实现，但无法包含字段。- 作用：用于解耦、定义多种类型的统一行为规范。

3.抽象类 VS 接口- 是否可实例化：抽象类不可，接口更不能；- 成员内容：抽象类可有字段和部分实现，接口仅有签名（及可选默认实现）；- 继承方式：抽象类单继承 + 多接口，接口可多实现；- 应用场景：

- 有公共状态或部分实现时选抽象类；

- 只需规范行为、需要多重实现时选接口。

B. 代码示例

// 抽象类示例
public abstract class Animal
{
    protected string Name;

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

    // 抽象方法，子类必须实现
    public abstract void Speak();

    // 虚方法，子类可选择重写
    public virtual void Eat()
    {
        Console.WriteLine(#34;{Name} is eating.");
    }
}

// 接口示例
public interface IMovable
{
    void Move(int distance);

#if NETCOREAPP3_0_OR_GREATER
    // C# 8.0 接口默认实现示例
    void Stop()
    {
        Console.WriteLine("Stopped moving.");
    }
#endif
}

// 具体类同时继承抽象类并实现接口
public class Dog : Animal, IMovable
{
    public Dog(string name) : base(name) { }

    public override void Speak()
    {
        Console.WriteLine(#34;{Name} barks!");
    }

    public override void Eat()
    {
        // 调用基类实现
        base.Eat();
        Console.WriteLine(#34;{Name} eats dog food.");
    }

    public void Move(int distance)
    {
        Console.WriteLine(#34;{Name} runs {distance} meters.");
    }

#if NETCOREAPP3_0_OR_GREATER
    // 可选择重写接口默认实现
    public void Stop()
    {
        Console.WriteLine(#34;{Name} stops abruptly.");
    }
#endif
}

void Demo()
{
    Dog dog = new Dog("Buddy");
    dog.Speak();   // Buddy barks!
    dog.Eat();     // Buddy is eating. 
                   // Buddy eats dog food.
    dog.Move(10);  // Buddy runs 10 meters.
    dog.Stop();    // C#8+ 默认：Stopped moving. 或 自定义：Buddy stops abruptly.
}

1.为什么抽象类可以包含字段，而接口直到 C#8.0 也只能包含方法签名？字段在接口中会带来哪些设计问题？

- 抽象类本质上是类，允许定义私有或受保护字段，用来保存状态或共享公共实现。

- 接口是纯粹的契约（contract），不关心实现细节，不应指定存储布局。

- 如果接口包含字段，就必须规定所有实现如何在内存中分配这些字段，破坏了接口的松耦合和实现自由度。

- 字段会导致二进制兼容性问题：一旦字段加入接口，所有实现都要更新，否则无法编译或运行。

2.什么时候你会选择用接口的默认实现（default implementation）？它与抽象类的已实现方法有何区别？

- 何时用接口默认实现：

- 当需要给现有接口新增方法以兼容旧实现时，避免所有实现都要改动。

- 只需少量逻辑，可直接在接口层面提供，不额外引入继承层次。

- 与抽象类已实现方法区别：

- 接口默认实现不能包含字段或状态，仅能基于接口签名写静态逻辑；

- 抽象类可包含字段、构造函数、受保护成员，并可维护子类状态；

- 接口默认方法不能访问私有成员，也没有构造函数，不适合有状态的公共实现。

3.设计一个支付系统：IPayment 接口和 PaymentBase 抽象类分别应包含哪些成员？请简单列出类/接口定义。

// 接口：定义支付契约
public interface IPayment
{
    // 发起支付
    bool Pay(decimal amount, string currency);
    // 发起退款
    bool Refund(string transactionId, decimal amount);
    // 支付完成事件
    event EventHandler<PaymentEventArgs> PaymentCompleted;
}

// 抽象类：提供公共字段/方法和部分默认逻辑
public abstract class PaymentBase : IPayment
{
    // 公共字段：支付网关地址
    protected string GatewayUrl;

    // 构造函数
    protected PaymentBase(string gatewayUrl)
    {
        GatewayUrl = gatewayUrl;
    }

    // 接口事件由基类触发
    public event EventHandler<PaymentEventArgs> PaymentCompleted;

    // 抽象方法：具体渠道自行实现
    public abstract bool Pay(decimal amount, string currency);
    public abstract bool Refund(string transactionId, decimal amount);

    // 模板方法：执行支付后统一触发事件
    protected void OnPaymentCompleted(PaymentEventArgs args)
    {
        PaymentCompleted?.Invoke(this, args);
    }
}

1.接口不能声明字段，但可以声明属性。请写一个接口，包含只读属性、可读写属性和事件；然后写一个类实现它。

// 接口示例
public interface IDevice
{
    // 只读属性
    string Id { get; }
    // 可读写属性
    string Name { get; set; }
    // 事件
    event EventHandler StatusChanged;
}

// 实现类
public class Device : IDevice
{
    // 私有字段存储属性值
    private readonly string _id;
    private string _name;

    public Device(string id, string name)
    {
        _id = id;
        _name = name;
    }

    public string Id => _id;                 // 只读
    public string Name                      // 可读写
    {
        get => _name;
        set
        {
            if (_name != value)
            {
                _name = value;
                StatusChanged?.Invoke(this, EventArgs.Empty);
            }
        }
    }

    public event EventHandler StatusChanged;
}