C#中abstract的用法详解

简介

abstract 是C#中一个重要的关键字，表示抽象，它用于定义抽象类或抽象方法，是实现面向对象中重要的机制。一个抽象类不能被直接实例化，而只能作为基类被其他类继承。从抽象类继承的子类，必须实现该抽象类中的abstract方法，才能被实例化。在C#中，抽象类和抽象方法通常用于建立基础类和组件，使代码具有更强的可重用性。

抽象类

抽象类是不能被实例化的类，它被用于定义一个通用的、不具体的对象类型，而且这个类型与具体的实现无关。它定义了一组规范，规定了具体子类必须实现的方法。抽象类使用abstract关键字进行声明，必须包含至少一个抽象方法或属性。

以下是一个抽象类的例子：

public abstract class Shape
{
    public abstract double GetArea();
}

这个类声明了一个抽象方法 GetArea()，因为这个方法没有任何具体实现，所以它不能被直接实例化。

抽象方法

抽象方法是一种没有任何实现的方法，它只是对子类的一种约束，让子类必须根据自身的特定业务实现它。抽象方法不能有任何实现，因为抽象方法是只有签名，完全没有实现方法体。要定义一个抽象方法，只需要声明一个不带方法体的方法，并使用 abstract 关键字进行修饰，如下所示：

public abstract double GetArea();

下面是一个抽象类中的抽象方法的例子：

public abstract class Shape
{
    public abstract double GetArea();
}

public class Circle : Shape
{
    int radius;
    public Circle(int r)
    {
        radius = r;
    }
    public override double GetArea()
    {
        return 3.14 * radius * radius;
    }
}

上面的代码定义了一个 Shape 抽象类，它只有一个抽象方法 GetArea()，没有任何实现。然后，定义了一个 Circle 子类，它实现 GetArea() 方法，并计算圆的面积。因为 Circle 继承自 Shape，所以必须实现 GetArea() 方法，否则编译器会报错。

抽象类与接口的区别

抽象类和接口都是定义规范，规范了子类所需要实现的方法。但是它们之间还是有一些不同的：

1. 抽象类是一个类，而接口只是接口，没有定义字段、属性或方法的实现。
2. 一个类只能继承一个抽象类，但可以实现多个接口。
3. 抽象类可以定义非抽象方法，但接口不能。
4. 抽象类可以具有访问修饰符，但接口不能。

下面是一个抽象类和接口的对比示例：

public abstract class Animal
{
    public abstract void Eat();
    public void Sleep()
    {
        Console.WriteLine("I'm sleeping");
    }
}

public interface IAnimal
{
    void Eat();
    // void Sleep(); // 接口中不能定义非抽象方法
}

上面代码定义了一个抽象类 Animal 和一个接口 IAnimal，它们都定义了一个方法 Eat()。但是，抽象类中还定义了一个非抽象方法 Sleep()，而接口中因为不能定义非抽象方法，所以注释掉了。

总结

抽象类是一种有助于编写高效可扩展性应用程序的重要机制。通过定义抽象方法和抽象类，可以确保应用程序的可靠性，维护性，以及更容易地实现和扩展。抽象类由抽象方法和具体实现的内容构成，它提供了一组半成品，让继承它的子类实现完整的功能。在实际编程时，开发人员需要根据应用程序的需求判断是否选择抽象类或接口。

示例一

public abstract class AbstractClass
{
    public abstract void MethodA();
    public void MethodB()
    {
        Console.WriteLine("MethodB");
    }
}

public class MyClass : AbstractClass
{
    public override void MethodA()
    {
        Console.WriteLine("MethodA");
    }
}

MyClass cls = new MyClass();
cls.MethodA();
cls.MethodB();

输出结果：

MethodA
MethodB

上面的代码定义了一个抽象类 AbstractClass，其中抽象方法 MethodA() 必须由子类实现，同时提供了一个非抽象的方法 MethodB()。然后定义了一个 MyClass 子类，继承了 AbstractClass，并实现了 MethodA() 方法。最后实例化了 MyClass 类的对象 cls，并调用了 MethodA() 和 MethodB() 方法。

示例二

public interface IPrint
{
    void Print();
}

public abstract class AbstractClass : IPrint
{
    public abstract void MethodA();
    public void MethodB()
    {
        Console.WriteLine("MethodB");
    }
    public void Print()
    {
        Console.WriteLine("Print");
    }
}

public class MyClass : AbstractClass
{
    public override void MethodA()
    {
        Console.WriteLine("MethodA");
    }
}

MyClass cls = new MyClass();
cls.MethodA();
cls.MethodB();
cls.Print();

输出结果：

MethodA
MethodB
Print

上面的代码定义了一个接口 IPrint，一个抽象类 AbstractClass，其中 AbstractClass 实现了 IPrint 接口，并定义了抽象方法 MethodA()，非抽象方法 MethodB() 和 Print() 方法。然后定义了一个 MyClass 类，继承了 AbstractClass，实现了 MethodA() 方法。最后实例化了 MyClass 类的对象 cls，并调用了 MethodA()，MethodB() 和 Print() 方法。