C#中的构造函数、重写与重载
默认构造函数都从⽗类object继承了⽆参的构造⽅法。
1、类在初始化实例化对象（new）的时候将默认调⽤的是类中的默认构造函数（即⽆参的构造函数）；
2、为⽅便初始化数据，通常会构造函数（即构造函数需要带参数，⽅法名与类名、⽆参的⽅法名⼀致，只是参数个数不⼀致），那么在实例化对象（new）的时候就可以使⽤要带参数的构造函数，以便初始化数据。
⽰例：
类Monitor，包含属性String height;String width
public Monitor(){}            //⽆参的构造函数即默认构造函数，⼀般可不写，编译器⾃动创建
public Monitor(String height,String width){}
在main⽅法⾥我做初始化动作
Monitor monitor=new Monitor();//实例化时不带参数，即使在Monitor类⾥⾯带有N多个带参数的构造函数，
但这种⽅式如果要赋值，需⼿动赋值，
如:monitor.height=100;monitor.width=200;
Monitor monitor2=new Monitor("100","200");//这种⽅式是带参数的构造函数
主要⽤来在创建对象时初始化对象即为对象成员变量赋初始值，总与new运算符⼀起使⽤在创建对象的语句中，特别的⼀个类可以有多个构造函数可根据其参数个数的不同或参数类型的不同来区分它们，即构造函数的重载
1.构造函数的命名必须和类名完全相同;⽽⼀般⽅法则不能和类名相同.
2.构造函数的功能主要⽤于在类的对象创建时定义初始化的状态.它没有返回值，也不能⽤void来修饰.这就保证了它不仅什么也不⽤⾃动返回,⽽且根本不能有任何选择.⽽其他⽅法都有返回值.即使是void返回值，尽管⽅法体本⾝不会⾃动返回什么，但仍然可以让它返回⼀些东西,⽽这些东西可能是不安全的.
3.构造函数不能被直接调⽤，必须通过new运算符在创建对象时才会⾃动调⽤,⼀般⽅法在程序执⾏到它的时候被调⽤.
4.当定义⼀个类的时候，通常情况下都会显⽰该类的构造函数，并在函数中指定初始化的⼯作也可省略，编译器会提供⼀个默认的构造函数.此默认构造函数是不带参数的.⽽⼀般⽅法不存在这⼀特点
定义：
class A
{
public A(){}
}
使⽤：
A a=new A();//在这⾥，A()就是就是构造函数。
需要注意的⼀点是，如果类⾥⾯没有定义构造函数，编译器也会⾃动⽣产⼀个空构造函数，类的各个成员都赋上默认值。
但是如果在类⾥⾯只定义了⼀个私有的构造函数的时候，那么这个类将不能被实例化。
class A
{
string a;
private A() { }//这个类不能被实例化
}
如果我们定义了带参数的构造函数，⽽没有定义不带参数的构造函数，那么在实例化这个类的对象的时候必须提供参数。
class A
{
string a;
public A(string str) {a=str; }
}
不能这么实例化对象 A a=new A();
构造函数分为动态构造函数和静态构造函数。
动态构造函数是类或结构实例化时，为其分配内存空间，完成类或结构当中成员变量的初始化⼯作。动态构造函数可以重载，即相同构造函数名称拥有不同类型和数⽬的多个构造函数。带参数的构造函数和不带参数的构造函数没有本质区别，带参数的构造函数可以通过传⼊的变量控制或者直接初始化其中的成员变量，在构造函数中可以为成员变量初始化默认值。
静态构造函数不允许携带参数，即⼀个类中只允许有⼀个静态构造函数。它在第⼀次访问静态成员或者第⼀次实例化动态该类的对象之前调⽤。
override是重写（覆盖）了⼀个⽅法，以实现不同的功能。⼀般是⽤于⼦类在继承⽗类时，重写（重新实现）⽗类中的⽅法。
重写（覆盖）的规则：
1、重写⽅法的参数列表必须完全与被重写的⽅法的相同，否则不能称其为重写⽽是重载.
2、重写⽅法的访问修饰符⼀定要⼤于被重写⽅法的访问修饰符（public>protected>default>private）。
3、重写的⽅法的返回值必须和被重写的⽅法的返回⼀致；
4、重写的⽅法所抛出的异常必须和被重写⽅法的所抛出的异常⼀致，或者是其⼦类；
5、被重写的⽅法不能为private，否则在其⼦类中只是新定义了⼀个⽅法，并没s有对其进⾏重写。
6、静态⽅法不能被重写为⾮静态的⽅法（会编译出错）。
override就是⼦类将⽗类的⽅法重新实现了⼀遍。
new就是说这个⽅法就是⼦类⾃⼰的，跟⽗类没有任何继承关系关系，仅仅是重名
⼆、overload是重载，⼀般是⽤于在⼀个类内实现若⼲重载的⽅法，这些⽅法的名称相同⽽参数形式不同。
重载的规则：
1、在使⽤重载时只能通过相同的⽅法名、不同的参数形式实现。不同的参数类型可以是不同的参数类型，不同的参数个数，不同的参数顺序（参数类型必须不⼀样）；
2、不能通过访问权限、返回类型、抛出的异常进⾏重载；
构造函数可以被重载
3、⽅法的异常类型和数⽬不会对重载造成影响；
多态的概念⽐较复杂，有多种意义的多态，⼀个有趣但不严谨的说法是：继承是⼦类使⽤⽗类的⽅法，
⽽多态则是⽗类使⽤⼦类的⽅法。
⼀般，我们使⽤多态是为了避免在⽗类⾥⼤量重载引起代码臃肿且难于维护。
举个例⼦：
public class Shape
{
public static void main(String[] args){
Triangle tri = new Triangle();
System.out.println("Triangle is a type of shape? " + tri.isShape());// 继承
Shape shape = new Triangle();
System.out.println("My shape has " + Sides() + " sides."); // 多态
Rectangle Rec = new Rectangle();
Shape shape2 = Rec;
System.out.println("My shape has " + Sides(Rec) + " sides."); //重载
}
public boolean isShape(){
return true;
}
public int getSides(){
return 0 ;
}
public int getSides(Triangle tri){ //重载
return 3 ;
}
public int getSides(Rectangle rec){ //重载
return 4 ;
}
}
class Triangle extends Shape
{
public int getSides() { //重写，实现多态
return 3;
}
}
class Rectangle extends Shape
{
public int getSides(int i) { //重载
return i;
}
}
注意Triangle类的⽅法是重写，⽽Rectangle类的⽅法是重载。对两者⽐较，可以发现多态对重载的优点：
如果⽤重载，则在⽗类⾥要对应每⼀个⼦类都重载⼀个取得边数的⽅法；
如果⽤多态，则⽗类只提供取得边数的接⼝，⾄于取得哪个形状的边数，怎样取得，在⼦类⾥各⾃实现(重写)。

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。