C# abstract override 修饰符

定义：

abstract 修饰符指示被修改内容的实现已丢失或不完整。 abstract 修饰符可用于类、方法、属性、索引和事件。 在类声明中使用 abstract 修饰符以指示某个类仅旨在作为其他类的基类。 标记为 abstract 的成员，或包含在抽象类中的成员，都必须由派生自抽象类的类来实现。

 

功能：

抽象类具有以下功能：

• 抽象类不能实例化。

• 抽象类可能包含抽象方法和访问器。

• 无法使用 sealed 修饰符来修改抽象类，因为两个修饰符具有相反的含义。 sealed 修饰符阻止类被继承，而 abstract 修饰符要求类被继承。

• 派生自抽象类的非抽象类，必须包含全部已继承的抽象方法和访问器的实际实现。

在方法或属性声明中使用 abstract 修饰符，以指示该方法或属性不包含实现。

 

抽象方法具有以下功能：

• 抽象方法是隐式的虚拟方法。

• 只有抽象类中才允许抽象方法声明。

• 由于抽象方法声明不提供实际的实现，因此没有方法主体；方法声明仅以分号结尾，且签名后没有大括号 ({ })

• 通过包含使用 override 修饰符的属性声明，可在派生类中重写抽象继承属性 

附：1.在静态属性，方法上使用 abstract 修饰符是错误的

       2.在抽象方法声明中使用 static 或 virtual 修饰符是错误的

 

例子

在游戏中特效一般是很常见的，一般特效也会分很多种，比如不同的子弹打击需要呈现不同的效果

1.创建特效基类

public abstract class Effect : MonoBehaviour {

    private int id;
    public static int Id = 0;
    public abstract int X { get; } //抽象属性 
    public abstract string IdxString { get; set; } //抽象属性 
    public abstract char this[int i] { get; } //抽象索引器 

    public abstract void Init(params object[] args);// 抽象方法 

    /// <summary>
    /// 创建特效
    /// </summary>
    /// <param name="efxName"></param>
    /// <param name="args"></param>
    /// <returns></returns>
    public static Effect Create(string eftName, params object[] args) {
        GameObject go = Spawn(eftName);
        Effect eft = go?.GetComponent<Effect>();
        eft?.Init(args);
        return eft;
    }

    public static GameObject Spawn(string efxName) {
        //TODO 获取特效对象
        //return ObjectPool.instance.GetObjectFromPool(efxName);
        return null;
    }

    public static void UnSpawn(GameObject go) {
        //TODO 回收特效
        //ObjectPool.instance.ReturnObjectToPool(go);
    }
}

2.创建加农炮弹特效子类

public sealed class CannonEft : Effect {

    private string skillId;
    private bool otherTurretHit;
    private int bulletId;
    private float range;
    private int userId;

    private string idxString;
    private int id;
    private int x;

    public override char this[int i] => IdxString[i];

    public override int X {
        get {
            return x;
        }
    }

    public override string IdxString {
        get 
            { return idxString; }
        set 
            { idxString = value; }
    }

    /// <summary>
    /// 初始化
    /// </summary>
    /// <param name="args">参数数组</param>
    public override void Init(params object[] args) {
        this.skillId = (string)args[1];
        this.otherTurretHit = (bool)args[2];
        this.bulletId = (int)args[3];
        this.range = (float)args[4];
        this.userId = (int)args[5];

        //TODO 调用其他的一些操作
        Debug.Log("Effect Init");

        //回收
        this.Invoke("Recycle", 1f);
    }

    public void DebugLog() {
        print("CannonEft func");
    }

    private void Recycle() {
        Effect.UnSpawn(this.gameObject);
    }
}

3.测试脚本

    private string skillId="skill_Cannon";
    private bool otherTurretHit = false;
    private int bulletId=0;
    private float range=5;
    private int userId=1001;
   
    void Start () {
        CannonEft eft= (CannonEft)Effect.Create("特效名称", skillId, otherTurretHit, bulletId, range, userId);
        eft.DebugLog();
	}

解析：

在基类Effect中定义

    public abstract int X { get; } //抽象属性 
    public abstract string IdxString { get; set; } //抽象属性 
    public abstract char this[int i] { get; } //抽象索引器 

    public abstract void Init(params object[] args);// 抽象方法 

必须在子类CannonEft中override重写，不然报错

 

调用时很简单：Effect.Create("特效名称", skillId, otherTurretHit, bulletId, range, userId)

参数传递是object[]