C#多态详解

1.定义

多态是同一个行为具有多个不同表现形式或形态的能力。

多态性意味着有多重形式。在面向对象编程范式中，多态性往往表现为"一个接口，多个功能"。

多态性可以是静态的或动态的。在静态多态性中，函数的响应是在编译时发生的。在动态多态性中，函数的响应是在运行时发生的。

静态多态性：在编译时，方法和对象的连接机制被称为早期绑定，也被称为静态绑定。c# 提供了两种技术来实现静态多态性。分别为：方法重载、运算符重载

动态多态性是通过 抽象类 和 虚方法 实现的。

在 c# 中，每个类型都是多态的，因为包括用户定义类型在内的所有类型都继承自 object。

多态就是同一个接口，使用不同的实例而执行不同操作，如图所示：

2.实现多态的两个因素

1）子类重写父类方法

2）使用父类的类型（子类转换为父类：向上转型）

class animal
{
public virtual void call() {
console.writeline("无声的叫唤");
}
}

class dog : animal
{
// new的作用是隐藏父类的同名方法
//public new void call() {
//console.writeline("叫声：汪～汪～汪～");
//}

public override void call() {
console.writeline("叫声：汪～汪～汪～");
}
public void smell() {
console.writeline("嗅觉相当不错！");
}
}

animal animal = new dog(); //向上转型
animal.call();

向上转型：将子类对象转为父类对象。此处父类对象可以是接口或抽象类。

转化后的父类对象具有父类所有方法，若方法被子类重写override，那么实际调用时，调用的是重写后的实现。

int a=(int)3.5;
dog dog = (dog)animal;//向下转型
dog.call();
dog.smell();

向下转型：把父类对象转为子类对象。

转化后的子类对象，跟一般的继承子类对象一样。具有子类所有方法(包括重写方法)+父类所有方法(被重写的方法，按重写的算。)

3.案例

public class shape
{
public int x { get; private set; }
public int y { get; private set; }
public int height { get; set; }
public int width { get; set; }
// 虚方法

public virtual void draw()
{
console.writeline("执行基类的画图任务");
}
}
​

class circle : shape
{
public override void draw()
{
base.draw();
console.writeline("画一个圆形");
}
}

class rectangle : shape
{
public override void draw()
{
base.draw();
console.writeline("画一个长方形");
}
}

class triangle : shape
{
public override void draw()
{
base.draw();
console.writeline("画一个三角形");
}
}
​

class program
{
static void main(string[] args)
{
shape circle=new circle();
circle.draw();
shape rectangle=new rectangle();
rectangle.draw();
shape triangle=new triangle();
triangle.draw();
}
}

父类做返回值

class person
{
public virtual void eat()
{

}
}

class whiteperson:person
{
public override void eat()
{
console.writeline("热狗");
}
}

class yellowperson:person
{
public override void eat()
{
console.writeline("饺子");
}
 
//写一个getperson方法，返回值为父类，
//根据传入的不同人种来确定吃什么

person getperson(string s)
{
person p=null;
if (s.equals("中国人"))
{
p = new yellowperson();
}
else if (s.equals("外国人"))
{
p= new whiteperson();
}
else
{
return p;
}
p.eat();
return p;
}
}

父类做参数

class animal
{
public virtual void swimming()
{
console.writeline("动物游泳");
}
}

class cat:animal
{
public override void swimming()
{
console.writeline("猫挠");
}

//写一个方法，完成动物游泳（对象做参数）
void getswimming(animal a)//a是引用
{
if (a is cat)
{
cat c = (cat)a;//向下转型
c.swimming();
}
}

static void main(string[] args)
{
cat c = new cat();
dog d = new dog();
animal a = c;
// animal a = d;
c.getswimming(a);
}
}
static void main(string[] args)
{
cat c = new cat();
dog d = new dog();
animal a = c;
// animal a = d;
c.getswimming(a);
}
}

4、使用多态的好处

1. 应用程序不必为每一个派生类编写功能调用，只需要对抽象基类进行处理即可。大大提高程序的

可复用性。//继承
2. 派生类的功能可以被基类的方法或引用变量所调用，这叫向后兼容，可以提高可扩充性和可维护

性。 //多态的真正作用

5、string类

==和equals的区别

1、值类型

==和equals比较的内容都是一致的，都是比较内容

string a = "123";//值

console.writeline(a=="123");

console.writeline(a.equals("123"));

2、引用类型

==： 比较首地址是否相等 equals：比较的是值是否相等

char[] x={'1','2','3'};

string b = new string(x);//引用

console.writeline(b=="123");

console.writeline(b.equals("123"));

1）字符串的比较

compare(str1, str2)
str1.compareto(str2)
string a = "hello",b="hello",c="hello";
console.writeline(a.compareto(b));//-1
console.writeline(string.compare(a,b));//-1
console.writeline(a.compareto(c));//0

字符串的查找

(1)contains(findstr)：找指定字符串是否包含一个字串findstr，返回值的bool类型，即只有

true和false。

(2)indexof(findstr)：查找findstr在字符串中第一次出现的位置，返回值为第一次出现

的下标，没有找到则返回-1.

(3)lastindexof(findstr)：查找findstr在字符串中最后一次出现的位置，返回值为最后

一次出现的下标，没有找到则返回-1。

console.writeline(a.contains("lo"));//true
console.writeline(a.indexof('e'));//1
console.writeline(a.lastindexof('l'));//3

字符串的截取

substring(startindex)：字符串中下标从startindex开始后面的全部字符串。
substring(startindex, len)：字符串中下标从startindex开始后面的len个长度的字符串。
console.writeline(a.substring(1));//ello
console.writeline(a.substring(1,3));//ell

字符串的分割

split(splitch)：将字符串按splitch进行分割，它的返回值是一个字符串数组。
string d="锄禾日当午#汗滴禾下土#谁知盘中餐#粒粒皆辛苦";
string[] e = d.split('#');
for (int i = 0; i < e.length; i++)
{
console.writeline(e[i]);
}

字符串的合并

string.concat(str1, str2, …., strn)：将n个字符串连接，中间没有连接符
“+”连接符号
string f = "world";
console.writeline(a+f);
console.writeline(1+2+3+a);//6hello
console.writeline(a+1+2+3);//hello123
console.writeline(string.concat(a,f));//helloworld

字符串的替换

replace(oldstr, newstr)：用newstr来替换字符串中的oldstr
console.writeline(a.replace("he","he"));//hello

字符串的插入

insert(index, str)：index是需要插入的位置，str是要插入的字符
console.writeline(a.insert(1,"ww"));//hwwello

字符串的删除

trim()：删除字符串中开始和结尾处的空格
remove(start)：start为需要删除的起始位置，该方法是将位置后的所有字符全部删除
remove(start, len)：len是指需要删除的长度，与上面格式不同的是它是从起始位置开始

删除len个字符

string s = " aaa bbb ccc ";
console.writeline(s.trim());//aaa bbb ccc
console.writeline(s.remove(6));// aaa b
console.writeline(s.remove(2,7));// aaccc

9）字符串的大小写转换

tolower()：将字符串转化为小写形式
toupper()：将字符串转换威大写形式

10）string.format()

string.format("{0:d}",system.datetime.now) //结果为：2021-3-23 （月份位置不是03）
string.format("{0:d}",system.datetime.now) //结果为：2021年3月23日
string.format("{0:f}",system.datetime.now) //结果为：2021年3月23日 15:37
string.format("{0:f}",system.datetime.now) //结果为：2021年3月23日 15:37:52
string.format("{0:g}",system.datetime.now) //结果为：2021-3-23 15:38
string.format("{0:g}",system.datetime.now) //结果为：2021-3-23 15:39:27
string.format("{0:m}",system.datetime.now) //结果为：3月23日
string.format("{0:t}",system.datetime.now) //结果为：15:41
string.format("{0:t}",system.datetime.now) //结果为：15:41:5

6.运算符重载：

关键字 abstract 声明抽象类：用于接口部分类的实现（派生类继承抽象类时，实现完成）。抽象类包含抽象方法，抽象方法可被派生类实现。

抽象类规则：

1.不能创建抽象类的实例

2.不能在抽象类外定义抽象方法

3.不能把抽象类声明为sealed（类前带关键字sealed代表该类是密封类，不能被继承）

关键字virtual声明虚方法:用于方法在继承类中的实现（在不同的继承类中有不同的实现）。

抽象类和虚方法共同实现动态多态性。

注：继承类中的重写虚函数需要声明关键字 override，在方法参数传入中写（类名 形参名）例如 public void callarea(shape sh)，意思是传入一个 shape 类型的类。

总结

本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注的更多内容！