C#抽象类和方法

在本教程中，我们将通过示例了解 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() 在课堂内。

我们有一只狗 继承自 Animal 的类班级。 狗 类提供抽象方法 makeSound() 的实现 .

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

  Console.WriteLine("Bark Bark");

}

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

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

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

注意 :与 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);

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

抽象类的访问构造函数

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

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() 是 brake() 实现的抽象方法在 摩托车 一直隐藏。

每辆摩托车都有不同的刹车装置。这就是为什么 SportsBike 自己实现 brake() 和 MountainBike 自己实现 brake() .

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

C# 继承 C# 嵌套类

C语言