一、多态
前言：
多态:同一个方法不同形态体现，
多态分静态多态和动态的多态
静态多态:函数重载和符号重载
动态多态：抽象和虚方法
静态多态
1.多态之函数重载
函数重载：在同一个范围内，函数名一样，参数的类型不一样、参数的个数不一样，这样函数就是重载，仅仅只有返回值类型不一样，不属于函数的重载
例：
class People { //构造函数重载 public People() { Console.WriteLine("不带参数的构造函数"); } public People(int a) { Console.WriteLine("带一个整型参数的构造函数"); } public People(string a) { Console.WriteLine("带一个字符串参数的构造函数"); } public People(string a,int b) { Console.WriteLine("带2个参数的构造函数"); } public void Eat() { Console.WriteLine("中文吃饭"); } public void Eat(string a) { Console.WriteLine("中文吃"+a); } public void Eat(string a,int count) { Console.WriteLine("中文吃" + a); } }new People(); new People(10); new People("11"); new People().Eat(); new People().Eat("biangbiang面"); new People().Eat("豆豉糖"); Console.ReadKey();2.多态之符号重载
符号重载：把常用的算术运算符号、逻辑运算符号按照自己的定义方式进行运算 能够使对象进行运算 例如+，可以计算俩个数字相加， 10+10=20
如果想实现俩个对象相加 可以通过符号重载实现
class Shape { public int X { get; set; }//长 public int Y { get; set; } //宽 public int Z { get; set; }// 高 public Shape() { } public Shape(int x, int y, int z) { this.X = x; this.Y = y; this.Z = z; } //重载+ 让俩个对象相加，计算俩个对象体积相加的结果 //符号重载：定义成静态的方法 ，在符号前面添加operator关键字 public static int operator +(Shape s1, Shape s2) { //s1.X*s1.Y*s1.Z s1的体积 //s2.X * s2.Y * s2.Z s2的体积 return s1.X * s1.Y * s1.Z + s2.X * s2.Y * s2.Z; } // 俩个对象相减，返回一个对象，对象属性值为俩个对象属性的差值 //s1- s2 = s3(0,0,0) //s1:10 20 30 //s2:10 20 30 public static Shape operator -(Shape s1, Shape s2) { Shape s3 = new Shape(); s3.X = Math.Abs(s1.X - s2.X); s3.Y = Math.Abs(s1.Y - s2.Y); s3.Z = Math.Abs(s1.Z - s2.Z); return s3; } //重载++符号 //s1(10 ,20 ,30) => s1++ =>s1(11,21,31) public static Shape operator ++(Shape s1) { Shape s3 = new Shape(); s3.X = s1.X++; s3.Y = s1.Y++; s3.Z = s1.Z++; return s3; } // 重载一个>符号 public static bool operator >(Shape s1, Shape s2) { return s1.X * s1.Y * s1.Z > s2.X * s2.Y * s2.Z; } public static bool operator <(Shape s1, Shape s2) { return s1.X * s1.Y * s1.Z < s2.X * s2.Y * s2.Z; } //重载==号 public static bool operator ==(Shape s1,Shape s2) { return s1.X* s1.Y* s1.Z == s2.X * s2.Y * s2.Z; } //重载!=号 public static bool operator !=(Shape s1, Shape s2) { return s1.X * s1.Y * s1.Z != s2.X * s2.Y * s2.Z; }Shape p1 = new Shape(100,200,300); Shape p2 = new Shape(10,20,30); Console.WriteLine(p1+p2);// 允许俩个Shape对象相加 重载+ Console.WriteLine(10+20);//30 Console.WriteLine((p1-p2).X+"-----"+ (p1 - p2).Y+"--------"+ (p1 - p2).Z); //重载- Console.WriteLine((p1++).X+ "-----" + (p1++).Y + "--------" + (p1++).Z); //重载++ Console.WriteLine(p1>p2);//true 重载> Console.WriteLine(p1<p2);//false 重载< Console.WriteLine(p1==p2);//false == Console.WriteLine(p1!=p2); //true != Console.ReadKey();动态多态
1.动态多态表现:抽象
动态多态表现:抽象
抽象类：用于提供类的部分成员实现，包含抽象方法也可以普通的方法，如果是抽象方法不用去实现，谁继承这个抽象类谁去实现抽象方法
抽象类里面也可以定义抽象成员， 如果是抽象成员，需要在派生类去实现成员
//定义抽象类 public abstract class People{} public abstract class People { public int Age { get; set; } = 10;// 普通的属性 //public abstract string Name { get; set; } = "上海一女子单身46死亡了 遗产几百万被当地民政局没收，墓地费需要表弟承担"; // 抽象属性 不能赋值 public abstract string Name { get; set; } //普通方法可以正常定义和实现 public void Eat() { Console.WriteLine("吃相难看"); } //抽象方法不能有方法体 不能加{} public abstract void SayHello(int a) ; } //在子类实现抽象成员 public class China : People { //需要重写抽象成员和抽象方法 //重写关键字 override public override string Name { get; set; } = "博物馆火了"; //重写抽象方法 public override void SayHello(int a) { Console.WriteLine("你好 吃了么"); } } public class Japan : People { public override string Name { get; set; } = "首相"; public override void SayHello(int a) { Console.WriteLine("こんにちは (Konnichiwa)"); // สวัสดี（发音：sa - wàt - dii） // 안녕하세요（An-nyeong-ha-se-yo） } }//定义抽象类 public abstract class People{} //定义抽象方法 public abstract void SayHello(int a) ; //派生类实现的时候添加override关键字 public override void SayHello(int a) { Console.WriteLine("你好 吃了么"); } China china = new China(); china.Age = 10;//继承过来的普通属性 china.Name = "ss";//调用子类的实现的抽象成员 china.SayHello(10);//调用子类的实现的抽象方法 china.Eat();//继承过来的普通方法 Japan japan = new Japan(); japan.SayHello(10); // 调用子类的实现的抽象方法 japan.Eat();// 继承过来的普通方法2.动态多态表现：虚方法
抽象方法和虚方法的区别
* 1 抽象成员和抽象方法只能定义抽象类里面 ，但是虚方法和虚成员可以定义普通类里面
* 2 抽象方法和抽象成员在抽象类不能实现， 但是虚方法和虚成员可以定义普通类里面可以实现
* 3 抽象方法和抽象成员在派生类必须实现， 但是虚方法和虚成员可以不用在派生类实现
* 4 可以使用overrid重写基类的抽象方法或者虚方法
public class People { public virtual int A { get; set; } = 10; public string Name { get; set; } // 普通属性 //public abstract int Age { get; set; }// 抽象成员不能定义在普通类中 //public abstract void Eat(); //抽象方法不能定义在普通类中 public virtual void Eat() //添加virtual关键字 使方法变成虚方法，虚方法可以定义普通类中,并且可以实现。 { Console.WriteLine("Peoplel的eat方法"); } } public class HanGuo : People { //通过重写override基类虚方法 public override void Eat() { Console.WriteLine("韩国吃泡菜"); } } public class YinDu:People { //new 新建一个eat方法，和基类eat的方法没有任何关系， public new void Eat() { Console.WriteLine("印度人吃咖喱"); } }HanGuo h1 = new HanGuo(); h1.Name = "金喜善"; h1.Eat(); YinDu yd = new YinDu(); yd.Name = "阿三"; yd.Eat(); Console.ReadKey();二、密封类和静态类
static void Main(string[] args) { // 密封类的使用 A a = new A(); a.Name = "好"; a.Eat(); // 静态类的使用 B.Age = 10; B.Eat(); //static class静态类：添加静态成员，不能new 实例化 //sealed class 密封类，特点不能被继承 Console.ReadKey(); } } //抽象类被继承 // sealed 密封类，特点不能被继承 public sealed class A { public string Name { get; set; } public void Eat() { Console.WriteLine("eat"); } //密封类不允许被继承的，虚方法设计目的就是为了在子类重写这个虚方法，俩者设计理念违背了 //public virtual void Eat2() //{ // Console.WriteLine("aa1"); //} } //class B :A{ } 特点不能被继承 //静态类：添加静态成员，不能new 实例化 static class B { public static int Age { get; set; } public static void Eat() { Console.WriteLine("111"); } }三、总结
/*1 函数重载:方法名相同、参数个数不一样或者参数类型不一样，
*2 符号重载： public static void operator +(People p1) {}
*3 抽象类
* public abstract class People{
* public abstract void Eat(); //不用添加方法体
* public abstract int Age{get;set;}//抽象成员
*
* }
* class A：People
* { 重写抽象属性和方法
* public override void Eat(){}
* }
* 4 虚方法
* class People
* {
* public virtual void Eat(){} 可以定义普通方法 并且可以实现
}
* class A：People
* {
// 虚方法可以不用在子类实现 使用override、new
}
*
* 5 密封和静态*/
