C#(抽象类、密封类、委托、接口、静态类)知识点总结(结合Unity)

一、抽象类（abstract）

1.抽象方法只能存在于抽象类中，抽象类中可以包含抽象成员和非抽象成员。

2.任何继承于抽象类的子类都必须使用override关键字实现抽象类的所有抽象方法，类只能单继承。

3.抽象父类中的抽象成员都必须被非抽象子类实现，所以父类抽象成员必须用public修饰符来修饰。

4.抽象类不能实例化。

5.抽象类不能是密封的或者静态的（即不能用sealed或者static来修饰）。

二、密封类（sealed）

1.sealed修饰的类为密封类，类声明时可防止其他类继承此类，在方法中声明则可防止派生类重写此方法。

2.密封类可以被实例，抽象类和接口均不能被实例。

3.密封方法必须是对基类的虚方法的重写。所以在方法声明中，sealed修饰符总是和override修饰符联用。

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;

public class Test : MonoBehaviour
{
   
    // Start is called before the first frame update
    void Start()
    {
        Test2 test2 = new Test2();
        test2.A();//打印结果为"111"
        test2.B();//打印结果为"444"
    }

    public virtual void A()
    {
        Debug.Log("111");
    }

    public virtual void B()
    {
        Debug.Log("222");
    }

}

sealed class Test2:Test
{
    private new void A() //new 关键字可以隐藏从基类继承的成员，从而可以修改访问修饰符(public-->private)
    {
        Debug.Log("333");
    }
    sealed override public void B()//当重写"public"继承成员"Test.B()"时，无法更改访问修饰符public.
    {
        Debug.Log("444");
    }
}

三、委托（参考   https://www.cnblogs.com/hushzhang/p/5901052.html)

1.委托是一个类，它定义了方法的类型，使得可以将方法当作另一个方法的参数来进行传递，这种将方法动态地赋给参数的做法，可以避免在程序中大量使用If … Else(Switch)语句，同时使得程序具有更好的可扩展性。

2.可以将多个方法赋给同一个委托，或者叫将多个方法绑定到同一个委托，当调用这个委托的时候，将依次调用其所绑定的方法。

3.使用委托可以将多个方法绑定到同一个委托变量，当调用此变量时(这里用“调用”这个词，是因为此变量代表一个方法)，可以依次调用所有绑定的方法。

using System.Collections;
using System.Collections.Generic;
using UnityEngine;


public enum Language
{
    English,
    Chinese
}
public class TestDelegate : MonoBehaviour
{

	// Use this for initialization
	void Start ()
    {
        //方式一
         GreetPeople("miao", EnglishGreeting);//早上好！miaomiao
        GreetPeople("kui", ChineseGreeting);//早上好！kui

        //方式二 
        //GreetingDelegate delegate1;
        //GreetingDelegate delegate2;

        //delegate1 = EnglishGreeting;
        //delegate2 = ChineseGreeting;

        //GreetPeople("miao", delegate1);
        //GreetPeople("kui", delegate2);


        //方式三  第一次用的“=”，是赋值的语法；第二次，用的是“+=”，是绑定的语法。如果第一次就使用“+=”，将出现“使用了未赋值的局部变量”的编译错误。

        //通过委托来直接调用EnglishGreeting 和ChineseGreeting


        //GreetingDelegate delegate1;
        //delegate1 = EnglishGreeting;
        //delegate1 += ChineseGreeting;
        //delegate1("miaomiao");//Good Morning! miaomiao  早上好！miaomiao

        //方式四  
        GreetingDelegate delegate1 = new GreetingDelegate(EnglishGreeting);
        delegate1 += ChineseGreeting;
        GreetPeople("kui", delegate1);//Good Morning! kui   早上好！kui

        delegate1 -= EnglishGreeting;
        GreetPeople("kui", delegate1);//早上好！kui

    }
	
	public void GreetProple(string name)
    {
        EnglishGreeting(name);
    }

    public void EnglishGreeting(string name)
    {
        Debug.Log("Good Morning! " + name);
    }
    public void ChineseGreeting(string name)
    {
        Debug.Log("早上好！" + name);
    }

    public void GreetPeople(string name,Language lang)
    {
        switch (lang)
        {
            case Language.English:
                EnglishGreeting(name);
                break;
            case Language.Chinese:
                ChineseGreeting(name);
                break;
        }

    }

    public delegate void GreetingDelegate(string name);
    public void GreetPeople(string name,GreetingDelegate MakeGreeting)
    {
        MakeGreeting(name);
    }



}

四、接口（参考： https://www.runoob.com/csharp/csharp-interface.html）

1.接口使用 interface 关键字声明，它与类的声明类似，但是接口无法声明为private、protected、protected internal、private protected。接口声明默认是 public 的，C# 接口中的成员默认是 public 的。

附：解决方案就是一个容器，在这个容器里，分成好多层，好多格，用来存放不同的项目。程序集就是一个项目，多个项目构成一个解决方案。一个项目就是一个程序集。一个程序集可以体现为一个dll文件，或者exe文件。internal（内部）：限定的是只有在同一程序集中可访问，可以跨类。protected（受保护）：限定的是只有在继承的子类中可访问，可以跨程序集。protected internal：受保护“或”内部修饰符修饰成员，当父类与子类在同一个程序集中，internal成员可见。当父类与子类不在同一个程序集中，子类不能访问父类internal成员，而子类可以访问父类的ptotected internal成员，即，从当前程序集或从包含类派生的类型，可以访问具有访问修饰符protected internal的类型或成员。(参考：https://www.jb51.net/article/112789.htm)

2.接口方法不能用public abstract等修饰。接口内不能有字段变量，构造函数。

3.继承接口的类必须实现接口的所有方法。

4.接口成员不能有 new、static、abstract、override、virtual 修饰符。有一点要注意，当一个接口实现一个接口，这2个接口中有相同的方法时，可用 new 关键字隐藏父接口中的方法。

5.接口没有构造函数，所有不能直接使用 new 对接口进行实例化。接口中只能包含方法、属性、事件和索引的组合。接口一旦被实现，实现类必须实现接口中的所有成员。

附：接口实例：（参考： http://bbs.bccn.net/thread-297685-1-1.html）

public class MainLogic : MonoBehaviour
{

    public delegate void TestDelegate();  

    public interface ITestInterface
    {
        event TestDelegate TestEvent;
        void FireAway();
    }

    public class TestClass : ITestInterface
    {
        public event TestDelegate TestEvent;

        public void FireAway()
        {
            if (TestEvent != null)
            {
                TestEvent();
            }
        }
    }

    static private void F()
    {
        Debug.Log("This is called when the event fires.");
    }
     
    private void Start()
    {
        ITestInterface i = new TestClass();

        i.TestEvent += new TestDelegate(F);
        i.FireAway();//最终运行输出：This is called when the event fires.

    }
}

方法、属性、索引、事件实例

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.EventSystems;

public delegate void TestDelete();

interface ISubjectCourseStateSwitch
{
    event TestDelete TestEvent;//事件
    int this[int index] { get;set; }//索引
    int Name { get; set; }//属性
    bool OnRegisterCourseStateSwitchHandler(IObserverCourseStateSwitch observerCourseStateSwitch);//方法   
}

6.C# 是单继承，接口可以多继承。

7.接口不能包含字段、构造函数、析构函数、静态成员或常量。

五、静态类（Static）

1.在静态类中，所有成员都必须是静态的。

2.静态类不能被实例化，不能包含实例构造函数，不能有任何实例成员。

3.静态类默认继承自System.Object根类，不能为其指定其他父类。

4.静态类不能使用abstract或者sealed修饰符。

5.静态类成员不能有protected或者protected internal访问保护修饰符。

6.静态成员不能标记为 abstract、virtual、override。

（注：命名空间内定义的元素无法显式声明为private、protected、protected internal、private protected）

六、抽象类与接口的相似和不同之处

（一）相似之处:

1.不能实例化。

2.包含未实现的方法声明。

3.派生类必须实现父类未实现的方法，抽象类实现抽象方法，接口则是实现所有成员。

（二）不同之处：

1.类可以实现无限个接口，但仅能从一个抽象（或其他任何类型）类继承，从抽象类派生的类仍可实现接口，从而得出接口是用来解决多重继承的问题的。

2.抽象类中可以存在非抽象的方法，可接口不能，且它里面的方法只是一个没有具体实现的方法。