Перегрузка, переопределение и сокрытие? [закрытый]

Перегрузка предоставляет несколько методов с одним и тем же именем и разными сигнатурами:

void Foo() {...}
void Foo(int i) {...}

Переопределение используется в наследовании для изменения реализации каждого подкласса:

class SomeBase {
    public virtual void Foo() {}
}
class SomeOther : SomeBase {
    public override void Foo() {
        // different implementation, possibly calling base.Foo();
    }
}

С указанным выше, даже если я:

SomeBase obj = new SomeOther();
obj.Foo();

он вызовет реализацию SomeOther.Foo . Вызываемый метод зависит от типа экземпляра , а не от переменной.

Скрытие метода противоположно; он заменяет сигнатуру метода, но применяется только в том случае, если вы вызываете метод из производного типа:

class SomeBase {
    public void Foo() {}
}
class SomeOther : SomeBase {
    public new void Foo() {
        // different implementation, possibly calling base.Foo();
    }
}

Теперь:

SomeOther obj = new SomeOther();
SomeBase baseObj = obj;
obj.Foo(); // calls SomeOther.Foo
baseObj.Foo(); // calls SomeBase.Foo

т.е. вызовы метода зависят от переменной , а не от экземпляр.

Overloading is when you create multiple methods, with different parameters. For example:

public class Car
{
  public Car()
  {
    // Do stuff
  }

  public Car(int numberOfCylinders)
  {
    // Do stuff
  }
}

You can see the constructor has the same name, but different parameters. You will see overloaded methods and constructors in Visual Studio in Intellisense, with little arrows going up and down so you can browse the signatures.

Overriding is when you provide a new implementation to a method from a base class. Example:

   public class Square 
   {
      public double x;

      // Constructor:
      public Square(double x) 
      {
         this.x = x;
      }

      public virtual double Area() 
      {
         return x*x; 
      }
   }

   class Cube: Square 
   {
      // Constructor:
      public Cube(double x): base(x) 
      {
      }

      // Calling the Area base method:
      public override double Area() 
      {
         return (6*(base.Area())); 
      }
   }

Note that in C#, you can not override a non-virtual or static method.

Предполагая, что вы понимаете объяснения, данные другими плакатами, один из способов запомнить разницу между перегрузкой и переопределением заключается в том, что при использовании избыточной нагрузки , потенциально существует загружает 'одноименных функций.

Глупо, я знаю, но у меня это работает.

Проще говоря:

Перегрузка - это когда у вас есть одно и то же имя метода с разными сигнатурами. Это может быть в том же классе. Например:

int Add (int a, int b)
{
  return a + b; // returns int
}
float Add (float a, float b)
{
return a + b; // returns float
}

Переопределение - это когда у вас есть то же имя метода и подпись в производном классе, что и в базовом классе. В этом сценарии мы говорим, что производный класс переопределяет метод базового класса. Какой метод запускается, зависит от того, какой экземпляр вызывает метод

, например,

public class Shape
    {
        public virtual void Draw() { }

    }

    public class Square : Shape
    {
        public override void Draw()
        {
            // Code to draw square
        }
    }

    public class Circle : Shape
    {
        public override void Draw()
        {
            // Code to draw circle
        }
    }

Скрытие или инкапсуляция - это когда вы объявляете переменные-члены и методы класса закрытыми, чтобы к ним не мог получить доступ любой другой класс, даже производные классы

Например,

private int onlyICanAccess;

private void OnlyICanExecute()
{
  // ...
}

Перегрузка - это пример полиморфизма, вы можете перекрыть число, тип данных и последовательность параметров, переданных между двумя методами ..

переопределение (отличается от виртуального) означает наличие определенных функций,

Перегрузка - это определение множества возможных «сигнатур» одного метода или оператора. Каждая сигнатура принимает разные аргументы и, по сути, представляет собой отдельную функцию, ничем не отличающуюся от того, если бы несколько функций имели разные имена. Это часто используется для группировки концептуально похожих операций, таких как перегрузка + для работы с BigInteger и с String : обе операции кажутся разумными для использования + для (если вы не думаете, что все перегрузки + должны определять абелевы группы - перегрузка String не определяет).

Переопределение - это определение несколько возможных реализаций одной и той же сигнатуры метода, так что реализация определяется типом среды выполнения нулевого аргумента (обычно идентифицируемого именем this в C #).

Скрытие - это определение метода в производном типе с подпись идентична сигнатуре одного из его базовых типов без переопределения .

Практическая разница между переопределением и скрытием заключается в следующем:

• Если метод переопределен , реализация для вызова основан на типе времени выполнения аргумента this .
• Если метод просто скрыт , реализация для вызова основана на тип времени компиляции аргумента this .