对于不同的对象同一个方法调用不同的行为，称之为多态性
方法重载：
方法的名称相同，由于参数的不容，而导致不同的返回值。（方法的返回类型不能作为方法重载的判断依据）
方法签名：c#中如果两个方法如果是参数的数量，参数的类型，参数的顺序都一样的时候，则称为方法的签名相同。
方法重载又叫”静态多态性“，指同一个类中方法的比较与研究
方法签名。参数的数量，类型，顺序
/**
多态
**/
using System;
namespace damo1
{
class MainClass
{
public int Sum(int num1,int num2)
{
return num1 + num2;
}
public float Sum(float num1, float num2)
{
return num1 + num2;
}
public string Sum(string str1, string str2)
{
return str1 + str2;
}
public double Sum(double num1, double num2)
{
return num1 + num2;
}
public static void Main(string[] args)
{
MainClass obj = new MainClass();
int sum1 = obj.Sum(10,20);
Console.WriteLine("Hello World!{0}",sum1);
float sum2 = obj.Sum(10.554f, 2.545f);
Console.WriteLine("Hello World!{0}", sum2);
string sum3 = obj.Sum("你好", "世界");
Console.WriteLine(sum3);
double sum4 = obj.Sum(10, 20);
Console.WriteLine("Hello World!{0}", sum4);
}
}
}
构造函数重载
子类调用父类构造函数通过不同参数实现多态性
using System;
namespace damo2
{
public class father
{
private int _IntHeight;
private int _IntWeight;
public father()
{
_IntHeight = 180;
_IntWeight = 70;
}
public father(int height)
{
_IntHeight = height;
_IntWeight = 70;
}
public father(int height,int weight)
{
_IntHeight = height;
_IntWeight = weight;
}
public void InitDisplay()
{
Console.WriteLine("身高{0},体重{1}", _IntHeight,_IntWeight);
}
}
}
using System;
namespace damo2
{
public class son:father
{
public son():base()
{
}
public son(int height):base(height)
{
}
public son(int height ,int weight):base(height,weight)
{
}
public static void Main() {
son obj = new son();
//son obj = new son(50);
//son obj = new son(50,70);
obj.InitDisplay();
}
}
}
构造函数中输入不同的参数 得到的结果不同（调用不同的构造函数）
方法重写
指继承关系中不同类型之间方法之间的比较与研究。
方法重写使用virtual与override关键字。
virtual和override的目的是父类如果写了virtual暗示这个方法写的不完善但是可以用，子类用了override暗示这个方法比父类的方法更加的完善
注意
如果父类没有定义virtual则派生类就不能加override，如果不加就是方法覆盖，一般刻意的使用方法覆盖可以在方法名前面加new 如public new void speak（）{}
不能重写父类中的sealed方法（密封方法）
不能重写父类中的static 方法
子类必须重写父类中的抽象方法
类的ToString()方法都是继承与Object类的虚方法，打印出来时类的全路径名称，我们可以重写自己的ToString（）方法。ToString调用当前的类名称，在c#库里面我们写的所有的类都是继承了一个叫object的父类，这个父类里面写了一个ToString虚方法，我们可以通过方法重写的方式来定义新的ToString。
/**
*
*
*
* 方法重写。
*
*
*
* **/
using System;
namespace damo3
{
public class BaseClass
{
public virtual void Speak()
{
Console.WriteLine("父类说话方法");
}
}
}
using System;
namespace damo3
{
public class ChildClass:BaseClass
{
public override void Speak()
{
Console.WriteLine("子类说话方法");
}
public ChildClass()
{
}
public static void Main(string[] args)
{
ChildClass obj = new ChildClass();
obj.Speak();
}
}
}
sealed关键字（密封类）
：不允许继承不允许重写，在c#库中有很多的密封类，如string float int等
抽象类
实现方法：abstract class Person，
抽象类用来举例所需要的行为，抽象类不能被实例化，抽象类不明确提供具体实现方法，抽象类必须由其子类实现它的抽象方法（除非子类也具有抽象性），重写抽象类一定要加 override
/**
*
*
*
* 抽象类和抽象方法
*
*
*
* **/
using System;
namespace damo1
{
//定义抽象类
public abstract class Person
{
//抽象方法
abstract public void SpeakLanguage();
//普通方法
public void walk()
{
Console.WriteLine("人会走路");
}
}
}
using System;
namespace damo1
{
public class Sjy : Person
{
public Sjy()
{
}
//重写抽象类一定要加 override
public override void SpeakLanguage()
{
Console.WriteLine("sjy说中国话");
}
public static void Main(string[] args)
{
Sjy obj = new Sjy();
obj.SpeakLanguage();
obj.walk();
}
}
}
父类提供一系列规定，约束了子类的行为
父类可以提供一些共性行为。
抽象类和抽象方法
抽象方法一定属于抽象类，但是抽象类不一定要包含抽象方法。
抽象方法不能是私有的，而且抽象方法及其重载方法的访问显示应当相同。
抽象方法不能使用virtual关键字进行修饰。（virtual不是一定要被重写，而abstract一定是要被重写的）
/**
*
*
*
*
*
* 抽象类和抽象方法
*
* 申请一个抽象类，继承求图形面积
*
*
*
* **/
using System;
namespace damo2
{
abstract public class Shape
{
abstract public double Area();
}
}
/**
*
*
* 圆面积
*
*
*
*
*
* **/
using System;
namespace damo2
{
public class Circle: Shape
{
int Init_r;
public override double Area() {
return 3.14 * Init_r * Init_r;
}
public Circle(int r)
{
Init_r = r;
}
}
}
/**
*
*
* 三角面积
*
*
*
*
*
* **/
using System;
namespace damo2
{
public class Triangle:Shape
{
int Init_down;
int Init_high;
public Triangle(int down,int high)
{
Init_high = high;
Init_down = down;
}
public override double Area()
{
return (Init_down * Init_high) / 2;
}
}
}
/**
*
*
* 梯形面积
*
*
*
*
*
* **/
using System;
namespace damo2
{
public class Tranpezoid:Shape
{
int Init_up;
int Init_down;
int Init_high;
public Tranpezoid(int up,int down,int high)
{
Init_up = up;
Init_down = down;
Init_high = high;
}
public override double Area()
{
return (Init_down + Init_up) * Init_high / 2;
}
}
}
using System;
namespace damo2
{
public class test
{
public static void Main(string[] args)
{
Circle cirobj = new Circle(10);
Tranpezoid tranobj = new Tranpezoid(2, 5, 5);
Triangle triobj = new Triangle(5, 7);
Console.WriteLine("圆的面积{0},梯形面积{1},三角形面积{2}", cirobj.Area(), tranobj.Area(), tranobj.Area());
}
}
}
接口和多重接口
接口就是不同物理设备与软件程序实现沟通与数据传输的规格和标准，接口就是某个事物对外提供的一些功能的声明。
C#中用interface关键字类定义接口，与类是同等级的概念，不存在接口属于什么类的说法，或者类属于什么接口的说法
可以利用接口实现多态，同时接口也弥补了单一继承的弱点
一般使用接口声明方法或常量，接口中的方法只能声明，不能是具体的实现
接口可以继承，类似于类的继承
接口和抽象类不能被实例化
接口的任何派生实现类，都必须实现接口所有的方法
接口里面只能默认定义公共抽象方法，而且不能加abstract关键字
实现接口的子类不能加override，不是重写是实现，区别于虚方法与抽象方法
接口不允许有任何构造函数或者字段
接口成员总是公共的，不能声明虚拟和静态的
一般首字母用大写I
继承只能实现单继承，就接口可以多重接口
接口中不允许指定任何访问修饰符（隐式为public）
接口不允许定义任何字段
接口的显示实现
void ISpeakAble.speak()```
定义一个calculatie 接口
通过circularity类实现
```csharp
using System;
namespace damo4
{
interface ICalculate
{
void getArea();
void getZC();
}
}
using System;
namespace damo4
{
public class Circularity:ICalculate
{
private const float PI = 3.14159F;
private float _FloR;
public Circularity(float R)
{
_FloR = R;
}
public void getArea()
{
Console.WriteLine("圆的面积{0}",PI*_FloR*_FloR);
}
public void getZC()
{
Console.WriteLine("圆的周长{0}",2*PI*_FloR);
}
public static void Main(string[] args)
{
Circularity obj = new Circularity(10);
obj.getArea();
obj.getZC();
}
}
}
总结
方法重载（静态多态性）：同一个类中有多个方法名称相同，但是方法的参数不同的内容
方法重写（动态多态性）：继承关系中，父类中定义了虚方法（virtual），子类使用关键字override重写，方法重写的目的：就是可以不断优化代码的一种机制
sealed关键字密封方法，不能被继承
抽象类与抽象方法，abstract，一个抽象方法必须在抽象类中，当时抽象类中不一定要有抽象方法，一个类继承抽象类，则必须重写抽象方法。
接口与多重接口
关键字interface
接口是与类相同的编程单位，相互相之间不是隶属关系，接口中只能定义抽象方法，不能有public abstract关键字，接口可以多重继承，继承接口的类必须实现所有的方法。
扫一扫
1003
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
