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

Question

Кто-нибудь может объяснить, что такое перегрузка, переопределение и скрытие в.Net?

Спасибо

Answer 1

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

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

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

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

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

Answer 2

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

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

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

Answer 3

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

Общественный автомобиль класса
{
  общественный автомобиль ()
  {
    // Делаем вещи
  }

  общественный автомобиль (int numberOfCylinders)
  {
    // Делаем вещи
  }
}

Вы можете видеть, что конструктор имеет то же имя, но разные параметры. Вы увидите перегруженные методы и конструкторы в Visual Studio в Intellisense, с маленькими стрелками, идущими вверх и вниз, чтобы вы могли просматривать подписи.

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

   Площадь общественного класса 
   {
      публичный двойной х;

      // Конструктор:
      общественная площадь (двойной х) 
      {
         this.x = x;
      }

      публичная виртуальная двойная зона () 
      {
         вернуть х * х; 
      }
   }

   Класс Cube: Квадрат 
   {
      // Конструктор:
      общедоступный куб (двойной х): базовый (х) 
      {
      }

      // Вызов базового метода Area:
      public override double Area() 
      {
         return (6*(base.Area())); 
      }
   }

Обратите внимание, что в C# вы не можете переопределить не виртуальный или статический метод.

Answer 4

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

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

Answer 5

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

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

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, чтобы они не могли быть доступны для любого другого класса, даже для производных классов.

Например

private int onlyICanAccess;

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

Answer 6

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

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

Сокрытие означает скрытие внутренних функций и представление основных функций, что является одной из особенностей концепции ООП.

ПОЖАЛУЙСТА, чтобы получить конфиденциальную информацию