多态

1 认识多态

1.1 基本概念

多态是同一个行为具有多个不同表现形式或形态的能力，意味着有多重形式。在面向对象编程范式中，多态性往往表现为"一个接口，多个功能"。

在 C# 中，每个类型都是多态的，因为包括用户定义类型在内的所有类型都继承自 Object。

多态性分为静态的和动态多态。在静态多态性中，函数的响应是在编译时发生的。在动态多态性中，函数的响应是在运行时发生的。

• 静态多态：函数重载、运算符重载
• 动态多态：vob（virtual 虚函数，override 重写，base 父类）、抽象函数、接口

1.2 使用

class GameObject
{
    public string name;
    public GameObject(string name)
    {
        this.name = name;
    }
    //虚函数 可以被子类重写
    public virtual void Atk()
    {
        Console.WriteLine("游戏对象进行攻击");
    }
}
class Player : GameObject
{
    public Player(string name) : base(name)//调用父类的构造函数
    {

    }
    //重写虚函数
    public override void Atk()
    {
        Console.WriteLine("玩家对象进行攻击");
    }
}
class Monster : GameObject
{
    public Monster(string name) : base(name)
    {

    }
    public override void Atk()
    {
        base.Atk();//base代表父类，可以通过它来保留父类的行为，会调用一次父类的方法
        Console.WriteLine("怪物对象进行攻击");
    }
}

class Father
{
    public void SpeakName()
    {
        Console.WriteLine("Father的方法");
    }
}
class Son : Father
{
    public new void SpeakName()
    {
        Console.WriteLine("Son的方法");
    }
}

//Main
//用父类取装载子类的对象时，有两个同名的方法，会优先调用父类的 多态就用来解决这类问题
Father f = new Son();
f.SpeakName();
(f as Son).SpeakName();

GameObject p = new Player("abc");//虚函数和重写解决了问题
p.Atk();

GameObject m = new Monster("def");
m.Atk();
/*
输出：
Father的方法
Son的方法

玩家对象进行攻击

游戏对象进行攻击
怪物对象进行攻击
*/

2 abstract 抽象类和抽象方法

2.1 抽象类

用 abstract 关键字修饰的类。

特点：

• 不能被实例化
• 可以包含抽象方法
• 继承抽象类必须重写其抽象方法

abstract class Thing//抽象一类物品
{
    public string name;
    
    //可以在抽象类中写抽象函数
}
class Water : Thing
{

}

2.2 抽象方法

用 abstract 修饰的方法，又叫 纯虚方法

特点：

• 只能在抽象类中声明
• 没有方法体
• 不能是私有的
• 继承后必须实现，用override重写

abstract class Fruits
{
    public string name;

    public virtual void Test()
    {
        //虚方法可以写逻辑
    }
    public abstract void Bad();//抽象方法
}
class Apple : Fruits
{
    //虚方法在子类中可以选择是否重写
    //抽象方法一定要重写
    public override void Bad()
    {

    }
}

3 接口

3.1 基本概念

关键字：interface，接口是行为的抽象规范，是抽象行为的“基类”，各种类通过继承它来实现对应的行为。

接口声明规范：

1. 不包含成员变量
2. 只包含方法、属性、索引器、事件
3. 成员不能被实现
4. 成员可以不写访问修饰符，而且不能是私有的
5. 接口不能继承类，但是接口可以继承另一个接口

接口使用规范：

1. 类可以继承多个接口
2. 类继承接口后，必须实现接口中所有成员

特点：

1. 它和类的声明类似
2. 接口是用来继承的
3. 接口不能被实例化，但可以作为容器来存储对象

3.2 声明

/*
interface 接口名
{

}
接口名：I+帕斯卡命名法
*/
interface IFly
{
    void Fly();//方法

    string Name//属性
    {
        get;
        set;
    }

    int this[int index]//索引
    {
        get;
        set;
    }

    event Action doSomething;//事件
}

3.3 使用

接口用来继承：

1. 类可以继承1个类，n个接口
2. 继承了接口后，必须实现其中的内容，而且必须为 public 的
3. 实现的接口函数，可以加 visual 再在子类中 override
4. 接口遵循里氏替换原则

class Animal
{

}
class Tiger : Animal, IFly//继承类和接口
{
    //实现接口内容
    public void Fly()
    {

    }
    public string Name
    {
        get;
        set;
    }
    public int this[int index]
    {
        get
        {
            return 0;
        }
        set
        {

        }
    }
    public event Action doSomething;
}

3.4 接口继承接口

• 接口继承接口时，不需要实现
• 类继承接口后，去实现接口的所有内容

interface IWalk
{
    void Walk();
}

interface IMove : IFly, IWalk
{

}

class Test : IMove//实现所有内容
{
    public int this[int index] 
    { 
        get => throw new NotImplementedException(); set => throw new NotImplementedException(); 
    }

    public string Name 
    { 
        get => throw new NotImplementedException(); set => throw new NotImplementedException(); 
    }

    public event Action doSomething;

    public void Fly()
    {
        throw new NotImplementedException();
    }

    public void Walk()
    {
        throw new NotImplementedException();
    }
}

3.5 显示实现接口

• 当一个类继承两个接口，但是接口中存在着同名方法时使用
• 注意：显示实现接口时，不能写访问修饰符

interface IAtk
{
    void Atk();
}
interface ISuperAtk
{
    void Atk();
}

class Player : IAtk, ISuperAtk
{
    //显示实现接口：接口名.行为名
    void IAtk.Atk()
    {

    }
    void ISuperAtk.Atk()
    {

    }
}

4 sealed 密封方法

4.1 基本概念

• 密封方法：用 sealed 修饰的重写函数，让虚方法或抽象方法不能再被重写，和 override 一起出现
• 密封类：用 sealed 修饰的类，让类不能被继承

4.2 使用

abstract class Animal
{
    public string name;

    public abstract void Eat();

    public virtual void Speak()
    {
        Console.WriteLine("giao");
    }
}

class Person : Animal
{
    public override void Eat()
    {

    }

    public override void Speak()
    {

    }
}

class WhitePerson : Person
{
    public sealed override void Eat()//不能重写了
    {
        base.Eat();
    }

    public override void Speak()
    {
        base.Speak();
    }
}