C#面向对象核心-多态

多态

1 认识多态

1.1 基本概念

多态是同一个行为具有多个不同表现形式或形态的能力，意味着有多重形式。在面向对象编程范式中，多态性往往表现为"一个接口，多个功能"。
在 C# 中，每个类型都是多态的，因为包括用户定义类型在内的所有类型都继承自 Object。
多态性分为静态的和动态多态。在静态多态性中，函数的响应是在编译时发生的。在动态多态性中，函数的响应是在运行时发生的。

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

1.2 使用

1. class GameObject
2. {
3.     public string name;
4.     public GameObject(string name)
5.     {
6.         this.name = name;
7.     }
8.     //虚函数 可以被子类重写
9.     public virtual void Atk()
10.     {
11.         Console.WriteLine("游戏对象进行攻击");
12.     }
13. }
14. class Player : GameObject
15. {
16.     public Player(string name) : base(name)//调用父类的构造函数
17.     {
19.     }
20.     //重写虚函数
21.     public override void Atk()
22.     {
23.         Console.WriteLine("玩家对象进行攻击");
24.     }
25. }
26. class Monster : GameObject
27. {
28.     public Monster(string name) : base(name)
29.     {
31.     }
32.     public override void Atk()
33.     {
34.         base.Atk();//base代表父类，可以通过它来保留父类的行为，会调用一次父类的方法
35.         Console.WriteLine("怪物对象进行攻击");
36.     }
37. }
39. class Father
40. {
41.     public void SpeakName()
42.     {
43.         Console.WriteLine("Father的方法");
44.     }
45. }
46. class Son : Father
47. {
48.     public new void SpeakName()
49.     {
50.         Console.WriteLine("Son的方法");
51.     }
52. }
54. //Main
55. //用父类取装载子类的对象时，有两个同名的方法，会优先调用父类的 多态就用来解决这类问题
56. Father f = new Son();
57. f.SpeakName();
58. (f as Son).SpeakName();
60. GameObject p = new Player("abc");//虚函数和重写解决了问题
61. p.Atk();
63. GameObject m = new Monster("def");
64. m.Atk();
65. /*
66. 输出：
67. Father的方法
68. Son的方法
70. 玩家对象进行攻击
72. 游戏对象进行攻击
73. 怪物对象进行攻击
74. */

复制代码

2 abstract 抽象类和抽象方法

2.1 抽象类

用 abstract 关键字修饰的类。
特点：

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

1. abstract class Thing//抽象一类物品
2. {
3.     public string name;
4.    
5.     //可以在抽象类中写抽象函数
6. }
7. class Water : Thing
8. {
10. }

复制代码

2.2 抽象方法

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

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

1. abstract class Fruits
2. {
3.     public string name;
5.     public virtual void Test()
6.     {
7.         //虚方法可以写逻辑
8.     }
9.     public abstract void Bad();//抽象方法
10. }
11. class Apple : Fruits
12. {
13.     //虚方法在子类中可以选择是否重写
14.     //抽象方法一定要重写
15.     public override void Bad()
16.     {
18.     }
19. }

复制代码

3 接口

3.1 基本概念

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

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

接口使用规范：

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

特点：

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

3.2 声明

1. /*
2. interface 接口名
3. {
5. }
6. 接口名：I+帕斯卡命名法
7. */
8. interface IFly
9. {
10.     void Fly();//方法
12.     string Name//属性
13.     {
14.         get;
15.         set;
16.     }
18.     int this[int index]//索引
19.     {
20.         get;
21.         set;
22.     }
24.     event Action doSomething;//事件
25. }

复制代码

3.3 使用

接口用来继承：

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

1. class Animal
2. {
4. }
5. class Tiger : Animal, IFly//继承类和接口
6. {
7.     //实现接口内容
8.     public void Fly()
9.     {
11.     }
12.     public string Name
13.     {
14.         get;
15.         set;
16.     }
17.     public int this[int index]
18.     {
19.         get
20.         {
21.             return 0;
22.         }
23.         set
24.         {
26.         }
27.     }
28.     public event Action doSomething;
29. }

复制代码

3.4 接口继承接口

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

1. interface IWalk
2. {
3.     void Walk();
4. }
6. interface IMove : IFly, IWalk
7. {
9. }
11. class Test : IMove//实现所有内容
12. {
13.     public int this[int index]
14.     {
15.         get => throw new NotImplementedException(); set => throw new NotImplementedException();
16.     }
18.     public string Name
19.     {
20.         get => throw new NotImplementedException(); set => throw new NotImplementedException();
21.     }
23.     public event Action doSomething;
25.     public void Fly()
26.     {
27.         throw new NotImplementedException();
28.     }
30.     public void Walk()
31.     {
32.         throw new NotImplementedException();
33.     }
34. }

复制代码

3.5 显示实现接口

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

1. interface IAtk
2. {
3.     void Atk();
4. }
5. interface ISuperAtk
6. {
7.     void Atk();
8. }
10. class Player : IAtk, ISuperAtk
11. {
12.     //显示实现接口：接口名.行为名
13.     void IAtk.Atk()
14.     {
16.     }
17.     void ISuperAtk.Atk()
18.     {
20.     }
21. }

复制代码

4 sealed 密封方法

4.1 基本概念

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

4.2 使用

1. abstract class Animal
2. {
3.     public string name;
5.     public abstract void Eat();
7.     public virtual void Speak()
8.     {
9.         Console.WriteLine("giao");
10.     }
11. }
13. class Person : Animal
14. {
15.     public override void Eat()
16.     {
18.     }
20.     public override void Speak()
21.     {
23.     }
24. }
26. class WhitePerson : Person
27. {
28.     public sealed override void Eat()//不能重写了
29.     {
30.         base.Eat();
31.     }
33.     public override void Speak()
34.     {
35.         base.Speak();
36.     }
37. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！