語言表達要清晰，結構明確。

繼承：一個類多用，減少程式碼量，且將框架層次化。（和JAVA幾乎一樣，比較簡單）

class 基類
{
    建構函式(a,b){}
    property1;
    methode()
    {}
}

class 派生類:基類
{
    建構函式(c,d):base(a,b){} //建構函式需遵循這樣的寫法
    //在這裡可以寫新的方法，也直接呼叫父類方法和屬性，還可以複寫父類方法。
    overide methode(){}
}

多型：
靜態多型：編譯時響應。（也和JAVA一樣）

class a{
    method_a(int
 
 a){}
    method_a(String a){}
    method_a(int a,int b){}
    .......
}

動態多型：1.使用關鍵字 abstract 建立抽象類

下面是有關抽象類的一些規則：
* 您不能建立一個抽象類的例項。
* 您必須在子類中完全複寫父類的方法，一模一樣，不能多不能少。
* 抽象類的方法與類必須全部被abstract修飾，且不能包含任何具體邏輯。
* 通過在類定義前面放置關鍵字 sealed，可以將類宣告為密封類。當一個類被宣告為 sealed 時，它不能被繼承。抽象類不能被宣告為 sealed。

通過上面三點特性，我們可以想到：抽象類就是用來規範子類的行為的，就相當於類的模具，不具備例項化的操作的功能，這也就決定了其必須被繼承，所以sealed 不能被放在抽象類上。

using System;
namespace PolymorphismApplication{
   abstract class Shape //抽象類
   {
      public abstract int area();
   }
   class Rectangle:  Shape
   {
      private int length;
      private int width;
      public
 
 Rectangle( int a=0, int b=0)
      {
         length = a;
         width = b;
      }
      public override int area () //必須複寫，不復寫即報錯
      { 
         Console.WriteLine("Rectangle 類的面積：");
         return (width * length); 
      }
      /*public int test(){}*/  //新增父類沒有的方法亦報錯
   }

   class RectangleTester
   {
      static void Main(string[] args)
      {
         Rectangle r = new Rectangle(10, 7);
         double a = r.area();
         Console.WriteLine("面積： {0}",a);
         Console.ReadKey();
      }
   }
}

2.當有一個定義在類中的函式需要在繼承類中實現時，可以使用虛方法
虛方法是使用關鍵字 virtual 宣告的。虛方法可以在不同的繼承類中有不同的實現。對虛方法的呼叫是在執行時發生的。

動態多型性是通過 抽象類 和 虛方法 實現的。

虛方法可以在父類中用virtual定義，若子類未複寫該方法，則會自動採用父類的。

using System;
namespace PolymorphismApplication{
   class Shape 
   {
      protected int width, height;
      public Shape( int a=0, int b=0)
      {
         width = a;
         height = b;
      }
      //虛方法
      public virtual int area() 
      {
         Console.WriteLine("父類的面積：");
         return 0;
      }
   }
   class Rectangle: Shape
   {
      public Rectangle( int a=0, int b=0): base(a, b)
      {

      }
      //複寫父類方法
      public override int area ()  
      {
         Console.WriteLine("Rectangle 類的面積：");
         return (width * height); 
      }
   }
   class Triangle: Shape
   {
      public Triangle(int a = 0, int b = 0): base(a, b)
      {

      }
      //複寫父類方法
      public override int area()
      {
         Console.WriteLine("Triangle 類的面積：");
         return (width * height / 2); 
      }
   }
   class Caller
   {
      public void CallArea(Shape sh)
      {
         int a;
         a = sh.area();
         Console.WriteLine("面積： {0}", a);
      }
   } 
   class Tester
   {

      static void Main(string[] args)
      {
         Caller c = new Caller();
         Rectangle r = new Rectangle(10, 7);
         Triangle t = new Triangle(10, 5);
         c.CallArea(r);
         c.CallArea(t);
         Console.ReadKey();
      }
   }}

總結：

• 繼承，當你的父類方法不足以滿足開發需求，新方法不能歸屬父類，需要建立新類時，使用繼承將再合適不過。
• 函式過載，當需要在一個類中使用多個方法滿足開發，且多個方法性質相同，僅僅引數不同，可以使用過載，規範命名。
• abstract抽象類，當你需要建立多個結構要求嚴格的子類時，使用抽象類能夠避免子類寫出不必要的方法規範其結構。
• virtual虛方法，與常規繼承中一樣，不復寫時使用父類方法，複寫時使用子類方法，但是，若使用 father obj=new child();若父類中是虛方法，編譯器會強制檢查例項類的方法呼叫，不會直接呼叫父類方法。一般繼承就會直接呼叫父類方法。