多态函数重载
定义
封装、继承、多态、抽象
多态：同一个方法不同形态的体现，就叫多态
多态分为静态多态和动态多态，静态多态包含函数重载和符号重载，动态多态包括抽象和虚方法
函数重载：在同一个范围内，函数名一样，参数类型不一样，参数个数不用，这样的函数就是重载
仅仅只有返回值不一样，不属于函数的重载
代码
cs
public class People
{
//构造函数
public People()
{
Console.WriteLine("不带参数的构造函数");
}
public Peopke (int id)
{
Console.WriteLine("带一个参数的构造函数");
}
public People (string a,string b);
{
Console.WriteLine("带两个字符串的构造函数");
}
public void Eat()
{
Console.WriteLine("eat food")
}
public void Eat(int a)
{
Console.WriteLine("eat"+a);
return a;
}
}符号重载
定义
把常用的运算符号、逻辑符号、按照自己定义的方式进行运算，能够使自己进行运算，例如加号，可以计算两个数的和，10+10=20，但如果想实现对象相加，可以通过符号重载来实现
重载符号，让两个对象相加，计算两个对象面积相加的结果
符号重载定义成静态方法
在符号前面加上关键字operator
代码
cs
public class Shape
{
public int X { get; set; }
public int Y { get; set; }
public int Z { get; set; }
public Shape(int x,int y,int z}{ this.X=x,this.Y=y,this.Z=z;}
public Shape(){}
public static int operator +(Shape s1,Shape s2)
{
//体积
return s1.X * s1.Y * s1.Z + s2.X * s2.Y * s2.Z;
}
//两个对象相减，返回一个对象，对象包含了属性值为两个对象属性的插值
//s2-s1=s3（2，2，2）
//s1：1，2，3
//s2：3，4，5
public static Shape operator -(Shape s1,Shape s2)
{
{
Shape s3 = new Shape();
s3.X = Math.Abs(s2.X - s1.X);
s3.Y = Math.Abs(s2.Y - s1.Y);
s3.Z = Math.Abs(s2.Z - s1.Z);
return s3;
}
}
//重载++符号
//s1(1,2,3)=>s1++=>s1(2,3,4)
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;
}
}main函数则是直接调用即可
cs
Shape shape = new Shape(1, 2, 3);
Shape shape2 = new Shape(4, 5, 6);
//Console.WriteLine(shape +shape2);报错，对象不能相加(没有写符号重载之前)
Console.WriteLine(shape + shape2);//允许两个对象相加
Console.WriteLine((shape - shape2).X + "----" + (shape - shape2).Y + "------" + (shape - shape2).Z);
Console.WriteLine((shape++).X + "-----"+ (shape++).Y+"------"+ (shape++).Z);
Console.WriteLine(shape >shape2);//true
Console.WriteLine(shape < shape2);//false抽象
定义
动态多态体现：抽象
抽象类：用于提供类的部分成员实验，包含抽象方法也可以普通方法，如果是抽象方法不用去实现，谁继承这个抽象谁去实现抽象方法
抽象类可以定义抽象成员，如果是抽象成员，需要在派生类里面去实现成员
代码
cs
//定义抽象类：abstract
public abstract class People
{
public int Id{set;get;}//普通属性
//public abstract string Name{get;set;}="1234";报错，抽象属性不能赋值
public abstract string Name{set;get;}
//普通方法可以证书定义和现实
public void Eat()
{
Console.WriteLien("eat ice-cream");
}
//抽象方法不能有方法体，不能加{ }
public abstract void Say(int id);
public class Man:People
{
//需要重写抽象成员和方法
//重写：override
publice override string Name {get;set;}="1qwe";
public override void Say(int id);
{
Console.WriteLine("qwe");
}
//继承
public class AI:People
{
public override string Name{get;set;}="111";
public override void Say(int id)
{
Console.WriteLine("sad");
}
}虚方法
虚方法与抽象方法的区别
抽象成员只能定义在抽象类里面，但是虚方法和虚成员可以定义在普通类里面
抽象方法和抽象成员在抽象类里面不能实现，但是虚方法和虚成员能
抽象方法和抽象成员在派生里必须实现，但是虚方法与虚成员可以不用
都可以使用override重写基类
代码
cs
public class People
{
public string Name{get;set;}//普通属性
// public abstract int Age { get; set; }报错；抽象成员不能定义在普通类中
//public abstract void Eat();报错， 抽象方法不能定义在普通类中
public virtual void Eat()//添加virtual关键字，是方法变成虚方法，虚方法可以定义在普通类当中
{
Console.WriteLine("people的eat方法");
}
public class Chinese:People
{
//通过override 重写虚方法
public override void Eat()
{
Console.WriteLine("rice");
}
public class India : People
{
//new 新建一个eat方法，和基类eat的方法没有任何关系
public new void Eat()
{
Console.WriteLine("印度人吃玛莎拉");
}
}总结
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
}