C#面向对象核心-多态

云高 · 发表于 2023-3-28 23:38:43

多态

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，接口是行为的抽象规范，是抽象行为的“基类”，各种类通过继承它来实现对应的行为。
接口声明规范：

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

接口使用规范：

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

特点：

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

3.2 声明

/*
interface 接口名
{
}
接口名：I+帕斯卡命名法
*/
interface IFly
{
void Fly();//方法
string Name//属性
{
get;
set;
}
int this[int index]//索引
{
get;
set;
}
event Action doSomething;//事件
}

复制代码

3.3 使用

接口用来继承：

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

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();
}
}

复制代码

来源:https://www.cnblogs.com/tanyuyang/archive/2023/03/28/17266518.html
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】我们会及时删除侵权内容，谢谢合作！