繼前篇的存取類的修飾詞之後，還有一些功能型的描述修飾詞，包含之前也已經看到過的 new 以及很常看到的 static 在內，還有十來個字詞，分成兩篇來整理。

• abstract、override
  表示某一類別只是要作為其他類別的基底類別，由衍生自抽象類別的類別去實作。實作方式：繼承 abstract class 後，使用override 覆寫重新定義方法； 覆寫基底方法必須是 virtual、abstract 或 override。
  override 宣告不能變更 virtual 方法的存取範圍。 override 方法和 virtual 方法都必須具有相同的存取層級
  以下例子就是一個帶有基本傷害數值的抽象類別的實作。

  using UnityEngine;
  using System.Collections;
  public class Test : AttackClass
  {
      void Start()
      {
          Attack(Damage());
      }
      public override int Damage()
      {
          return 100;
      }
  }
  abstract public class AttackClass : MonoBehaviour
  {
      protected int base_damage = 10;
      public abstract int Damage();
      public void Attack(int damage) {
          base_damage += damage;
          Debug.Log(base_damage);
      }
  }

  抽象類別無法具現化(無法使用new將其實體)。
  抽象類別可能包含抽象方法和抽象存取子。

• const
  常數可以是數值、布林值、字串或 null，是一個不會被改變的值。

  public const double PI = Math.PI;

  例如：數學式中的 PI

• virtual
  用來修改方法、屬性、索引子或事件宣告，並可在衍生類別中受到覆寫。

  using UnityEngine;
  using System.Collections;
  using System;
  public class Test2 : MonoBehaviour {
  	// Use this for initialization
  	void Start () {
          double r = 3.0, h = 5.0;
          Shape c = new Circle(r);
          Shape s = new Sphere(r);
          Shape l = new Cylinder(r, h);
          // Display results:
          Debug.Log("Area of Circle   = "+ c.Area());
          Debug.Log("Area of Sphere   = "+ s.Area());
          Debug.Log("Area of Cylinder = "+ l.Area());
      }
  	// Update is called once per frame
  	void Update () {
  	}
      public class Shape
      {
          public const double PI = Math.PI;
          protected double x, y;
          public Shape()
          {
          }
          public Shape(double x, double y)
          {
              this.x = x;
              this.y = y;
          }
          public virtual double Area()
          {
              return x * y;
          }
      }
      public class Circle : Shape
      {
          public Circle(double r) : base(r, 0)
          {
          }
          public override double Area()
          {
              return PI * x * x;
          }
      }
      class Sphere : Shape
      {
          public Sphere(double r) : base(r, 0)
          {
          }
          public override double Area()
          {
              return 4/3 * PI * x * x * x;
          }
      }
      class Cylinder : Shape
      {
          public Cylinder(double r, double h) : base(r, h)
          {
          }
          public override double Area()
          {
              return 2 * PI * x * x + 2 * PI * x * y;
          }
      }
  }

   

• sealed
  用於類別時可以防止其他類別繼承。或防止方法透過繼承被覆寫。

  class A {}
  sealed class B : A {}
  //B 類別繼承自 A類別，但類別無法繼承自 B 類別
  class X
  {
      protected virtual void F() {  }
      protected virtual void F2() {  }
  }
  class Y : X
  {
      sealed protected override void F() {  }
      protected override void F2() {  }
  }
  class Z : Y
  {
      protected override void F() {  } //不成立
      protected override void F2() {  }
  }
  //Z 繼承自 Y，但 Z 無法覆寫宣告於 X 並密封於 Y 的虛擬函式 F

   

• static
  可用於類別、方法、屬性、運算子、事件和建構函式，但不能與索引子、解構函式或類別以外的類型搭配。

  public class ClassA
  {
      public struct Cat
      {
          public static int life = 9;
      }
  }

  要取得 life 靜態成員必須使用 ClassA.Cat.life 才能訪問。

  static int x = y;
  static int y = 5;
  Console.WriteLine(Test.x); //0
  Console.WriteLine(Test.y); //5
  Test.x = 99;
  Console.WriteLine(Test.x); //99

  若不將值明確指派給靜態欄位，不會定義結果

• new
  new 做為宣告修飾詞時，會隱藏繼承自基底類別的成員。
  雖然可以在不使用 new 修飾詞的情況下隱藏成員，但是編譯器會發出警告。 如果您使用 new 明確隱藏成員，它會隱藏這個警告。

  public class Base
  {
      public int x;
      public void Test() { }
  }
  public class ClassA : Base
  {
      new public void Test() { }
  }