C# 抽象类和方法

抽象类

在 C# 中，我们无法创建抽象类的对象。我们使用 abstract 关键字来创建抽象类。例如：

// create an abstract class
abstract class Language {
  // fields and methods
}
...

// try to create an object Language
// throws an error
Language obj = new Language();

抽象类可以同时包含抽象方法（没有方法体的）和 非抽象方法（有方法体的）。例如：

abstract class Language {

  // abstract method
  public abstract void display1();

  // non-abstract method
  public void display2() {
    Console.WriteLine("Non abstract method");
  }
}

在继续之前，请确保了解 C# 继承。

继承抽象类

由于我们无法创建抽象类的对象，因此我们必须从此类派生一个子类。这样，我们就可以使用子类的对象来访问抽象类的成员。例如：

using System;
namespace AbstractClass {

  abstract class Language {

    // non-abstract method
    public void display() {
      Console.WriteLine("Non abstract method");
    }
  }

  // inheriting from abstract class
  class Program : Language {

    static void Main (string [] args) {
      
      // object of Program class
      Program obj = new Program();

      // access method of an abstract class
      obj.display();

      Console.ReadLine();
    }
  }
}

输出

Non abstract method

在上面的示例中，我们创建了一个名为 Language 的抽象类。该类包含一个非抽象方法 display()。

我们创建了继承抽象类的 Program 类。请注意此语句：

obj.display();

在此，obj 是派生类 Program 的对象。我们正在使用对象 obj 调用抽象类的方法。

注意：我们只能将抽象类用作基类。因此，抽象类不能是密封的。要了解更多信息，请访问 C# 密封类和方法。

C# 抽象方法

没有方法体的方法称为抽象方法。我们使用 abstract 关键字来创建抽象方法。例如：

public abstract void display();

此处，display() 是一个抽象方法。抽象方法只能存在于抽象类中。

当一个非抽象类继承一个抽象类时，它应该为抽象方法提供实现。

示例：抽象方法的实现

using System;
namespace AbstractClass {

  abstract class Animal {

    // abstract method
    public abstract void makeSound();
  }

  // inheriting from abstract class
  class Dog : Animal {

    // provide implementation of abstract method
    public override void makeSound() {

      Console.WriteLine("Bark Bark");

    }
  }
  class Program  {
    static void Main (string [] args) {
      // create an object of Dog class
      Dog obj = new Dog();
      obj.makeSound();    

      Console.ReadLine(); 
    }
  }
}

输出

Bark Bark 

在上面的示例中，我们创建了一个名为 Animal 的抽象类。该类内部有一个抽象方法 makeSound()。

我们有一个 Dog 类，它继承自 Animal 类。Dog 类提供了抽象方法 makeSound() 的实现。

// provide implementation of abstract method
public override void makeSound() {

  Console.WriteLine("Bark Bark");

}

请注意，我们在 makeSound() 方法中使用了 override。这表明该方法正在重写基类中的方法。

然后，我们使用 Dog 类的对象来访问 makeSound()。

如果 Dog 类没有提供抽象方法 makeSound() 的实现，那么 Dog 类也应该被标记为抽象。

注意：与 C# 继承不同，我们不能在基类的抽象方法中使用 virtual。这是因为抽象类是隐式虚拟的。

带有 get 和 set 访问器的抽象类

我们可以将 get 和 set 访问器标记为抽象。例如：

using System;
namespace AbstractClass {
  abstract class Animal {
    
    protected string name;
    // abstract method
    public abstract string Name {
      get;
      set;
    }
  }

  // inheriting from abstract class
  class Dog : Animal {

    // provide implementation of abstract method
    public override string Name {
      get {
        return name;
      }
      set {
        name = value; 
      }
    }
   
  }
  class Program  {
    static void Main (string [] args) {
      // create an object of Dog class
      Dog obj = new Dog();  
      obj.Name = "Tom";
      Console.WriteLine("Name: " + obj.Name); 

      Console.ReadLine();
    }
  }
}

输出

Name: Tom

在上面的示例中，我们将 get 和 set 访问器标记为抽象。

obj.Name = "Tom";
Console.WriteLine("Name: " + obj.Name);

我们使用派生类 Dog 的对象来设置和获取抽象类 Animal 的 name 字段的值。

访问抽象类的构造函数

抽象类也可以有构造函数。例如：

using System;
namespace AbstractClass {
  abstract class Animal {
    
    public Animal() {
      Console.WriteLine("Animal Constructor");
    }
  }

  class Dog : Animal {
    public Dog() {
      Console.WriteLine("Dog Constructor");
    }   
  }

  class Program  {
    static void Main (string [] args) {
      // create an object of Dog class
      Dog d1 = new Dog();  

      Console.ReadLine();
    }
  }
}

输出

Animal Constructor
Dog Constructor

在上面的示例中，我们在抽象类 Animal 中创建了一个构造函数。

Dog d1 = new Dog();

在这里，当我们创建派生类 Dog 的对象时，抽象类 Animal 的构造函数也会被调用。

注意：我们也可以在抽象类中使用析构函数。

C# 抽象化

抽象类用于在 C# 中实现抽象化。

抽象化是面向对象编程的重要概念之一。它允许我们隐藏不必要的细节，只显示需要的信息。

这有助于我们通过隐藏细节来简化更高级别的概念，从而管理复杂性。

抽象化的一般性例子是摩托车刹车。我们知道刹车的作用。当我们踩下刹车时，摩托车就会停下来。但是，刹车的工作原理对我们来说是隐藏的。

隐藏刹车工作原理的主要优点是，现在制造商可以为不同的摩托车实现不同的刹车。但是，刹车的动作将保持不变。

示例：C# 抽象化

using System;
namespace AbstractClass {
  abstract class MotorBike {
    
    public abstract void brake();
  }

  class SportsBike : MotorBike {

    // provide implementation of abstract method
    public override void brake() {
      Console.WriteLine("Sports Bike Brake");
    }
   
  }

  class MountainBike : MotorBike {

    // provide implementation of abstract method
    public override void brake() {      
      Console.WriteLine("Mountain Bike Brake");
    }
   
  }
  class Program  {
    static void Main (string [] args) {
      // create an object of SportsBike class
      SportsBike s1 = new SportsBike();  
      s1.brake();

      // create an object of MountainBike class
      MountainBike m1 = new MountainBike();
      m1.brake();

      Console.ReadLine();
    }
  }
}

输出

Sports Bike Brake
Mountain Bike Brake

在上面的示例中，我们创建了一个名为 MotorBike 的抽象类。它有一个抽象方法 brake()。

由于 brake() 是一个抽象方法，因此 MotorBike 中 brake() 的实现被隐藏了。

每辆摩托车都有不同的刹车实现。这就是为什么 SportsBike 自己实现 brake()，而 MountainBike 自己实现 brake() 的原因。

注意：我们使用接口在 C# 中实现完全抽象化。要了解更多信息，请访问 C# 接口。