重载和重载
超载和重写有什么区别。
超载
重载是指在同一个作用域中有多个方法，名称相同但签名不同。
//Overloading public class test { public void getStuff(int id) {} public void getStuff(string name) {} } 重写
重写是一个原则，允许您更改子类中方法的function。
//Overriding public class test { public virtual void getStuff(int id) { //Get stuff default location } } public class test2 : test { public override void getStuff(int id) { //base.getStuff(id); //or - Get stuff new location } }
简单的定义为重载和重载
重载 （编译时间多态）::具有相同名称和不同参数的函数
public class A { public void print(int x, int y) { Console.WriteLine("Parent Method"); } } public class B : A { public void child() { Console.WriteLine("Child Method"); } public void print(float x, float y) { Console.WriteLine("Overload child method"); } }
覆盖 （运行时多态性）::扩展类中的函数具有与基类中相同的名称和相同的参数，但具有不同的行为。
public class A { public virtual void print() { Console.WriteLine("Parent Method"); } } public class B : A { public void child() { Console.WriteLine("Child Method"); } public override void print() { Console.WriteLine("Overriding child method"); } }
- 重载=多个方法签名，方法名称相同
- 重写=相同的方法签名（声明为虚拟），在子类中实现
一个精明的面试官会跟进：
压倒一切和阴影有什么区别？
我想分享一个在我学习的时候对我很有意义的例子：
这只是一个不包含虚拟方法或基类的例子。 只是提供一个关于主要想法的暗示。
假设有一台洗车机，它有一个称为“洗车”的function，并接受汽车作为一种types。
获取汽车input并清洗汽车。
public void Wash(Car anyCar){ //wash the car }
让我们重载Wash（）函数
重载：
public void Wash(Truck anyTruck){ //wash the Truck }
洗车function只是洗车前，但现在超载洗车也是如此。
- 如果提供的input对象是一辆汽车，它将执行洗车（汽车anyCar）
- 如果提供的input对象是卡车，则将执行清洗（Truck anyTruck）
让我们重写Wash（）函数
重写：
public override void Wash(Car anyCar){ //check if the car has already cleaned if(anyCar.Clean){ //wax the car } else{ //wash the car //dry the car //wax the car } }
清洗function现在有一个条件来检查车是否已经干净，不需要再次清洗。
-
如果汽车是干净的，那就把它打蜡。
-
如果不干净，那么先洗车，然后擦干，然后蜡
。
所以这个function已经被添加一个新的function或完全不同的东西覆盖。
正如迈克尔所说：
- 重载=多个方法签名，方法名称相同
- 重写=相同的方法签名（声明为虚拟），在子类中实现
和
- Shadowing =如果将其视为DerivedClass，则使用派生方法，如果使用BaseClass，则使用base方法。
拥有多个名称相同但参数不同的方法/构造函数称为重载。 这是一个编译时间事件。
Class Addition { int add(int a, int b) { return a+b; } int add(int a, int b, int c) { return a+b+c; } public static main (String[] args) { Addition addNum = new Addition(); System.out.println(addNum.add(1,2)); System.out.println(addNum.add(1,2,3)); } }
O / P：
3 6
重写是一个运行时事件，意思是根据你的代码在运行时改变输出。
class Car { public int topSpeed() { return 200; } } class Ferrari extends Car { public int topSpeed() { return 400; } public static void main(String args[]) { Car car = new Ferrari(); int num= car.topSpeed(); System.out.println("Top speed for this car is: "+num); } }
注意在两个类topSpeed（）中都有一个通用的方法。 由于我们实例化了法拉利，我们得到了不同的结果。
O / P：
Top speed for this car is: 400
在C＃中没有Java像隐藏覆盖，没有关键字覆盖重写方法！ 请参阅这些C＃实现：
变体1没有覆盖 ：结果是200
class Car { public int topSpeed() { return 200; } } class Ferrari : Car { public int topSpeed(){ return 400; } } static void Main(string[] args){ Car car = new Ferrari(); int num= car.topSpeed(); Console.WriteLine("Top speed for this car is: "+num); Console.ReadLine(); }
变体2与覆盖关键字：结果是400
class Car { public virtual int topSpeed() { return 200; } } class Ferrari : Car { public override int topSpeed(){ return 400; } } static void Main(string[] args){ Car car = new Ferrari(); int num= car.topSpeed(); Console.WriteLine("Top speed for this car is: "+num); Console.ReadLine(); }
Car类上的关键字virtual在Java上是final的 ，意思是不是最终的 ，如果Car是抽象的，你可以重写或实现
shadowing =在派生类中维护两个定义，以便投影映射（隐藏）派生类定义的基类定义，反之亦然。
还有一点要补充。
重载多个具有相同名称的方法。 相同或不同的返回types。 不同的参数或不同types的参数。 在相同的类或派生类。
int Add（int num1，int num2）int Add（int num1，int num2，int num3）double Add（int num1，int num2）double Add（double num1，double num2）
可以在同一个类或派生类中使用。 一般比较喜欢同一class。 例如Console.WriteLine（）有19个重载的方法。
可以重载类的构造函数，方法。
可以考虑为编译时（静态/早期绑定）多态。
================================================== ================================================== =
在同一个class上， 重写是不可能的。 可以覆盖类方法，属性，索引器，事件。
有一些限制，如重写的基本方法必须是虚拟的，抽象的，或重写。 您不能使用新的，静态的或虚拟的修饰符来修改覆盖方法。
可以考虑运行时（dynamic/后期绑定）多态性。
有助于版本化http://msdn.microsoft.com/en-us/library/6fawty39.aspx
================================================== ================================================== =
有用的url
http://msdn.microsoft.com/en-us/library/ms173152.aspx 编译时间多态性与运行时多态性
当我们inheritance基类和派生类时重写，那么如果在派生类中有一个方法与方法（相同名称，相同的参数，相同的返回types）相同的名称在基类中定义，那么它的称为覆盖..
class Vehicle{ void run() { System.out.println("Vehicle is running"); } } class Bike2 extends Vehicle{ void run() { System.out.println("Bike is running safely"); } public static void main(String args[]){ Bike2 obj = new Bike2(); obj.run(); }
输出：自行车正在安全运行……..要更清楚地了解覆盖，请访问： http : //javabyroopam.blogspot.in/
重载只是两个名称相同，但参数列表不同的方法称为重载。
class Calculation{ void sum(int a,int b){System.out.println(a+b);} void sum(int a,int b,int c){System.out.println(a+b+c);} public static void main(String args[]){ Calculation obj=new Calculation(); obj.sum(10,10,10); obj.sum(20,20); } }
输出30,20
重载是静态多态的一部分，用于实现名称相同但签名不同的不同方法。 重写是用来完成不完整的方法。 在我看来，这两个概念之间没有任何比较，唯一相似的是两个词汇都是一样的。
方法重载和方法重写是完全不同的两个概念。 方法重载具有相同的方法名称，但具有不同的签名。 方法重写正在改变派生类中基类方法的默认实现。 下面你可以find2个优秀的video教程来解释这些概念。
方法重写Vs隐藏
方法重载
重载是一个概念，其中你有相同的签名或方法名称相同，但参数不同和重写，我们有相同的名称方法与不同的参数也有inheritance被称为覆盖
