C# 核心8——多态

1.多态Vob

1.基本概念

多态按字面的意思就是“多种状态”

让继承同一父类的子类们 在执行相同方法时有不同的表现（状态）

主要目的

同一父类的对象 执行相同行为（方法）有不同的表现

解决的问题

让同一个对象有唯一行为的特征

2.解决的问题

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

3.多态的实现

我们目前已经学过的多态

编译时多态——函数重载，开始就写好的

我们将学习的：

运行时多态（vob，抽象函数，接口）

我们今天学习vob

v：virtual（虚函数）

o：override（重写）

b：base（父类）

    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()
        {
            //base的作用
            //代表父类 可以通过base来保留父类的行为
            //base.Atk();
            Console.WriteLine("玩家对象进行攻击");
        }
    }
 
    class Monster : GameObject
    {
        public Monster(string name) : base(name)
        {
            
        }
        public override void Atk()
        {
            base.Atk();
            Console.WriteLine("怪物对象进行攻击");
        }
    }

 4.多态的使用

    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("多态_vob");
 
            #region 解决的问题
            Father f = new Son();
            f.SpeakName();//Father的方法
            (f as Son).SpeakName();//Son的方法
            #endregion
 
            #region 多态的使用
            GameObject p = new Player("张三");
            p.Atk();//玩家对象进行攻击
            (p as Player).Atk();//玩家对象进行攻击
 
            GameObject m = new Monster("李四");
            m.Atk();//怪物对象进行攻击
            (m as Monster).Atk();//怪物对象进行攻击
            #endregion
        }
    }

5.总结

多态：让同一类型的对象，执行相同行为时有不同的表现

解决的问题： 让同一对象有唯一的行为特征

vob：

v：virtual 虚函数

o：override 重写

b：base 父类

v和o一定是结合使用的 来实现多态

b是否使用根据实际需求 保留父类行为

2.抽象类和抽象方法

1.抽象类

概念：被抽象关键字abstract修饰的类

特点：

1. 不能被实例化的类
2. 可以包含抽象方法
3. 继承抽象类必须重写其抽象方法

    abstract class Thing
    {
        //抽象类中 封装的所有知识点都可以在其中书写
        public string name;
 
        //可以在抽象类中写抽象函数
    }
    class Water : Thing
    {
        
    }

2.抽象函数

抽象函数  又叫 纯虚方法

用 abstract关键字修饰的方法

特点：

1. 只能在抽象类中申明
2. 没有方法体
3. 不能是私有的
4. 继承后必须实现 用override重写 

    abstract class Fruits
    {
        public string name;
        
        //抽象方法 是一定不能有函数体的
        public abstract void Bad();
 
        public virtual void Test()
        {
            //可以选择是否写逻辑
        }
    }
    class Apple : Fruits
    {
        public override void Bad()
        {
            
        }
        //虚方法是可以由我们子类选择性来实现的
        //抽象方法必须要实现
        public override void Test()
        {
            base.Test();
        }
    }
    class SuperApple : Apple
    {
        //虚方法和抽象方法 都可以被子类无限的 去重写
        public override void Bad()
        {
            base.Bad();
        }
        public override void Test()
        {
            base.Test();
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            //抽象类不能被实例化
            //Thing t = new Thing();
            //但是 可以遵循里氏替换原则 用父类容器装子类
            Thing t = new Water();           
        }
    }

3.总结

抽象类 是被abstract修饰的类 不能被实例化 可以包含抽象方法

抽象方法 没有方法体的纯虚方法 继承后必须去实现的方法

注意：

        如何选择普通类还是抽象类

        不希望被实例化的对象，相对比较抽象的类可以使用的抽象类

        父类中的行为不太需要被实现的，只希望子类去定义具体的规则 可以选择 抽象类然后使用其中的抽象方法来定义规则

作用：整体框架设计时 会使用