关于抽象类的一切。

引言

抽象类是 .NET 提供的基本行为之一。 通常，您希望创建仅代表基类的类，并且不希望任何人创建这些类类型的对象。 您可以使用抽象类来实现此功能，在 C# 中使用修饰符 'abstract'。

抽象类意味着不能实例化该类的对象，但可以派生该类。

抽象类声明的一个例子是

abstract class absClass
{
}

抽象类可以包含抽象方法或非抽象方法。 抽象成员在抽象类中没有任何实现，但必须在其派生类中提供相同的实现。

抽象方法的一个例子

abstract class absClass
{
  public abstract void abstractMethod();
}

此外，请注意，抽象类并不意味着它应该包含抽象成员。 即使我们可以拥有一个仅具有非抽象成员的抽象类。 例如

abstract class absClass
{
    public void NonAbstractMethod()
    {
        Console.WriteLine("NonAbstract Method");
    }
}

一个解释抽象类的示例程序

using System;

namespace abstractSample
{
      //Creating an Abstract Class
      abstract class absClass
      {
            //A Non abstract method
            public int AddTwoNumbers(int Num1, int Num2)
            {
                return Num1 + Num2;
            }

            //An abstract method, to be
            //overridden in derived class
            public abstract int MultiplyTwoNumbers(int Num1, int Num2);
      }

      //A Child Class of absClass
      class absDerived:absClass
      {
            [STAThread]
            static void Main(string[] args)
            {
               //You can create an
               //instance of the derived class

               absDerived calculate = new absDerived();
               int added = calculate.AddTwoNumbers(10,20);
               int multiplied = calculate.MultiplyTwoNumbers(10,20);
               Console.WriteLine("Added : {0}, 
                       Multiplied : {1}", added, multiplied);
            }

            //using override keyword,
            //implementing the abstract method
            //MultiplyTwoNumbers
            public override int MultiplyTwoNumbers(int Num1, int Num2)
            {
                return Num1 * Num2;
            }
      }
}

在上面的示例中，您可以看到抽象类 absClass 包含两个方法 AddTwoNumbers 和 MultiplyTwoNumbers。 AddTwoNumbers 是一个非抽象方法，它包含实现，而 MultiplyTwoNumbers 是一个不包含实现的抽象方法。

类 absDerived 派生自 absClass，并且在 absDerived 上实现了 MultiplyTwoNumbers。 在 Main 中，创建了 absDerived 的一个实例 (calculate)，并调用了 AddTwoNumbers 和 MultiplyTwoNumbers。 您可以从另一个抽象类派生一个抽象类。 在这种情况下，在子类中，选择是否实现父类的抽象方法。

示例

//Abstract Class1
abstract class absClass1
{
    public abstract int AddTwoNumbers(int Num1, int Num2);
    public abstract int MultiplyTwoNumbers(int Num1, int Num2);
}

//Abstract Class2
abstract class absClass2:absClass1
{
    //Implementing AddTwoNumbers
    public override int AddTwoNumbers(int Num1, int Num2)
    {
        return Num1+Num2;
    }
}

//Derived class from absClass2
class absDerived:absClass2
{
    //Implementing MultiplyTwoNumbers
    public override int MultiplyTwoNumbers(int Num1, int Num2)
    {
        return Num1*Num2;
    }
}

在上面的例子中，absClass1 包含两个抽象方法 AddTwoNumbers 和 MultiplyTwoNumbers。 在派生类 absClass2 中实现了 AddTwoNumbers。 类 absDerived 派生自 absClass2，并且在那里实现了 MultiplyTwoNumbers。

抽象属性

以下是在类中实现抽象属性的示例。

//Abstract Class with abstract properties
abstract class absClass
{
    protected int myNumber;
    public abstract int numbers
    {
        get;
        set;
    }
}

class absDerived:absClass
{
    //Implementing abstract properties
    public override int numbers
    {
        get
        {
            return myNumber;
        }
        set
        {
            myNumber = value;
        }
    }
}

在上面的示例中，在抽象类中声明了一个 protected 成员。 成员变量 myNumber 的 get/set 属性在派生类 absDerived 中定义。

应用于抽象类的重要规则

抽象类不能是 sealed 类。 即以下声明是不正确的。

//Incorrect
abstract sealed class absClass
{
}

抽象方法的声明只允许在抽象类中。

抽象方法不能是 private。

//Incorrect
private abstract int MultiplyTwoNumbers();

抽象方法的访问修饰符在其抽象类及其派生类中应相同。 如果将抽象方法声明为 protected，则它在其派生类中应为 protected。 否则，编译器将引发错误。

抽象方法不能具有修饰符 virtual。 因为抽象方法是隐式虚拟的。

//Incorrect
public abstract virtual int MultiplyTwoNumbers();

抽象成员不能是 static。

//Incorrect
publpublic abstract static int MultiplyTwoNumbers();

抽象类 vs 接口

抽象类可以有抽象成员以及非抽象成员。 但是在接口中，所有成员都是隐式抽象的，并且接口的所有成员都必须在其派生类中重写。

接口的一个例子

interface iSampleInterface
{
  //All methods are automaticall abstract
  int AddNumbers(int Num1, int Num2);
  int MultiplyNumbers(int Num1, int Num2);
}

定义具有抽象成员的抽象类与定义接口具有相同的效果。

接口的成员是公共的，没有实现。 抽象类可以有受保护的部分、静态方法等。

一个类可以继承一个或多个接口，但只能继承一个抽象类。

抽象类可以添加更多功能，而不会破坏使用旧版本的子类。 在接口中，由于需要实现接口方法到类，创建附加功能会对子类产生影响。

接口或抽象类的选择取决于您的项目需求和设计。 您可以根据您的需求创建抽象类、接口或两者的组合。