Question

重载和覆盖之间有什么区别。

Answer 1

<强>重载

重载是指同一作用域中有多个方法，名称相同但签名不同。

//Overloading
public class test
{
    public void getStuff(int id)
    {}
    public void getStuff(string name)
    {}
}

<强>重写

覆盖是一个允许您更改子类中方法功能的原则。

//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
        }
}

Answer 2

重载和覆盖的简单定义

重载（编译时多态性）::具有相同名称和不同参数的函数

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");
    }
}

Answer 3

重载=多个方法签名，方法名称相同
覆盖=在子类中实现的相同方法签名（声明为虚拟）

精明的采访者会跟进：

What's the difference between overriding and shadowing?

Answer 4

我想分享一个在我学习时对我很有意义的例子：

这只是一个不包含虚方法或基类的示例。只是提出一个关于主要想法的提示。

我们假设有一台洗车机，它有一个叫做＆＃34; Wash＆＃34;并接受汽车作为一种类型。

获取Car输入并清洗汽车。

bottom: 20px

让我们重载Wash（）函数

<强>重载：

public void Wash(Car anyCar){
       //wash the car
}

洗涤功能之前只洗过一辆车，但现在它也超载了洗车。

如果提供的输入对象是Car，它将执行Wash（Car anyCar）
如果提供的输入对象是Truck，那么它将执行洗（卡车anyTruck）

让我们覆盖Wash（）函数

<强>重写：

public void Wash(Truck anyTruck){
   //wash the Truck  
}

洗涤功能现在有条件检查汽车是否已经清洁并且不需要再次清洗。

如果汽车是干净的，那么只需打蜡即可。
如果不清洁，请先洗车，然后擦干，再打蜡它

。

因此，通过添加新功能或执行完全不同的操作来覆盖功能。

Answer 5

迈克尔说：

重载=多个方法签名，方法名称相同
覆盖=在子类中实现的相同方法签名（声明为虚拟）

和

阴影=如果被视为DerivedClass，它使用派生方法，如果它作为BaseClass使用基本方法。

Answer 6

具有相同名称但不同参数的多个方法/构造函数称为重载。这是一个编译时事件。

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

Answer 7

在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类的

关键字虚拟与Java上的 final 相反，意味着不是最终的，您可以覆盖或实现Car是抽象的

Answer 8

shadowing =在派生类中维护两个定义，并且为了投影基类定义，它隐藏（隐藏）派生类定义，反之亦然。

Answer 9

要补充的另一点。

重载多个具有相同名称的方法。相同或不同的返回类型。不同的参数或不同类型的参数。在同一类或派生类中。

int Add（int num1，int num2） int Add（int num1，int num2，int num3） double add（int num1，int num2） double添加（double num1，double num2）

可以在同一个类或派生类中使用。通常喜欢同一类。例如。 Console.WriteLine（）有19个重载方法。

可以重载类构造函数，方法。

可以视为编译时（静态/早期绑定）多态。

=============================================== ================================================== ====

覆盖在同一个课程中无法实现。可以覆盖类方法，属性，索引器，事件。

有一些限制重写的基本方法必须是虚拟，抽象或覆盖。您不能使用new，static或virtual修饰符来修改覆盖方法。

可以视为运行时（动态/后期绑定）多态性。

帮助版本化http://msdn.microsoft.com/en-us/library/6fawty39.aspx

=============================================== ================================================== ====

有用的链接

http://msdn.microsoft.com/en-us/library/ms173152.aspx Compile time polymorphism vs. run time polymorphism

Answer 10

重载是静态多态的一部分，用于实现具有相同名称但签名不同的不同方法。覆盖用于完成不完整的方法。在我看来，这两个概念之间没有比较，唯一相似的是两者都有相同的词汇结束。

Answer 11

方法重载和方法覆盖是两个完全不同的不同概念。方法重载具有相同的方法名称但具有不同的签名。方法重写是在派生类中更改基类方法的默认实现。您可以在下面找到2个解释这些概念的优秀视频教程。

Method overriding Vs hiding

Method overloading

Answer 12

重载是一个概念，你有相同的签名或方法具有相同的名称但不同的参数和覆盖，我们有相同的名称方法与不同的参数也有继承被称为重写。

重载和覆盖

12 个答案: