在C#中,什么是多态如何实现
在C#中,什么是多态?如何实现?
C#中的多态性
多态性是面向对象编程的一个核心概念,他允许对象以多种形式表现.在C#中,多态主要通过虚方法,抽象方法和接口来实现. 多态性的存在使得同一个行为可以有多个不同的表达形式 即同一个接口可以使用不同的实例来执行不同的操作
虚方法(Virtual Methods)
在C#中,可以通过在基类中定义虚方法,然后再派生类中重写这些方法来实现多态. 虚方法使用Virtual 关键字声明,然后在派生类中通过使用 override关键字重写
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace 虚方法
{
internal class Program
{
static void Main(string[] args)
{
}
}
class Animals
{
public string Name { get; set; }
public virtual void Speak()
{
Console.WriteLine("说话");
}
}
class Dog:Animals
{
public override void Speak()
{
Console.WriteLine("汪汪汪");
}
}
class Cat : Animals
{
public override void Speak()
{
Console.WriteLine("喵喵喵");
}
}
}
// 总结:抽象方法和虚方法有什么区别?
//1.抽象方法只能定义在抽象类中,虚方法可以定义在普通的类中
//2.抽象方法不可以有内容,必须在派生类中实现,虚方法可以有内容,可以不再派生类中实现,不实现则使用基类的方法
抽象类 (Abstract Classes)
抽象类是不能被实例化的类,它通常包含一个或者多个抽象方法. 抽象方法只有声明没有实现的方法,他们必须在派生类中被重写. 抽象类和方法使用 abstract关键字声明
abstract class Pay
{
public int Id { get; set; }
public string Count { get; set; }
private string main;
public abstract void payment(double money);
public abstract void payyment(double money, string main);
public string Main
{
get => Main;
set
{
if (value != "微信" || value != "支付宝")
{
throw new Exception("请选择支付方式");
}
else
{
value = Main;
}
}
}
}
class WeCht : Pay
{
public override void payment(double money)
{
Console.WriteLine($"使用微信支付,你的账户{Id},密码{Count},你需要付{money}元");
}
public override void payyment(double money, string main)
{
Console.WriteLine($"使用{main}支付,你的账户{Id},密码{Count},你需要付{money}元");
}
}
class APay : Pay
{
public override void payment(double money)
{
Console.WriteLine($"使用支付宝支付,你的账户{Id},密码{Count},你需要付{money}元");
}
public override void payyment(double money, string main)
{
Console.WriteLine($"使用{main}支付,你的账户{Id},密码{Count},你需要付{money}元");
}
}
// 总结:抽象类和普通类的区别?
//1.抽象类不能实例化,普通类可以实例化
//2.抽象类中不一定要有抽象方法,也可以没有抽象方法,普通的类不能由抽象方法
//3.抽象类可以和普通类一样,有普通方法
//4.抽象类可以继承抽象类,子类如果不是抽象类,必须重写抽象类的全部抽象方法
//5.抽象方法就是被子类重写的,所以不能使用private修饰符
接口:C#接口(Interface)-CSDN博客
析构函数~
析构函数的定义:一个和类相同的方法 , 在类名的前面加上~
析构函数的主要作用是释放对象的资源,但是析构函数是由垃圾回收控制的,无法做到显示的调用,所以使用析构函数释放资源不是良好访问
internal class Program
{
static void Main(string[] args)
{
People people = new People();
people=null;
//强制启动垃圾回收机制
GC.Collect();
Console.ReadLine();
}
}
class People
{
~People()
{
Console.WriteLine("析构函数执行");
}
}
重载
static void Main(string[] args)
{
//多态:指同一个具有不同的表现形式和能力
//多态性又可以是静态的或者动态的,静态指的是编译过程中发生的,动态指的是运行过程中发生的
//静态多态:在编译过程中,通过方法重载和运算符重载实现多态,也叫做静态绑定
//动态多态:通过抽象方法,重写方法,隐藏方法实现运行时多态,叫做动态绑定
new People();
People people = new People();
new People(12);
new People("Kitty");
//总结: 方法重载
//1.通过一个方法不同的重载可以是参数的数量不同
//2.也可以是参数的类型不同
//3.和返回值类型无关(不同返回值类型,不算重载)
}
}
class People
{
public People() { }
public People(int id) { }
public People(string name) { }
public void Eat() { }
public void Eat(int id) { }
}
class Number
{
public double Length { get; set; }
public double Width { get; set; }
public double value { get { return Width*Length; } }
//重载+运算符
//格式: public static 返回值类型 operator 要重载的运算符(参数列表)
//public static double operator+(Number a1, Number a2)
//{
// return a1.value + a2.value;
//}
public static Number operator +(Number a1, Number a2)
{
return new Number
{
Width = a1.Width + a2.Width,
Length = a1.Length + a2.Length
};
}
public static Number operator -(Number a1, Number a2)
{
return new Number
{
Width = a1.Width - a2.Width,
Length = a1.Length - a2.Length
};
}
public static bool operator >(Number a1, Number a2)
{
return a1.value > a2.value;
}
public static bool operator <(Number a1, Number a2)
{
return a1.value < a2.value;
}
}
}
在C#中，多态性还可以通过其他方式实现，如方法重载和运算符重载，这些都是静态多态性的例子，它们在编译时就已经确定了。而虚方法、抽象类和接口提供的是动态多态性，它们允许在运行时确定具体调用哪个方法。
多态性的好处在于它提高了程序的可扩展性和可维护性，使得代码更加灵活和可重用。例如，可以编写一个函数，它接受一个 Shape 类型的参数，并调用其 Draw 方法，不管传入的是 Circle 还是 Rectangle 对象，都能正确调用相应的 Draw 方法，这就是多态性的魅力。