C#面向对象核心-多态
多态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//索引
{
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
{
get
{
return 0;
}
set
{
}
}
public event Action doSomething;
}3.4 接口继承接口
[*]接口继承接口时，不需要实现
[*]类继承接口后，去实现接口的所有内容
interface IWalk
{
void Walk();
}
interface IMove : IFly, IWalk
{
}
class Test : IMove//实现所有内容
{
public int this
{
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】 我们会及时删除侵权内容，谢谢合作！
页:
[1]