Полиморфизм в C#: перегрузка и переопределение методов

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

Существует два типа полиморфизма:

• Перегрузка метода
• Переопределение метода

Их часто путают из-за похожих по звучанию названий.

В этой статье мы рассмотрим перегрузку методов и концепцию переопределения методов в C#. Мы попытаемся продемонстрировать пошаговые различия между ними.

Перегрузка метода

Перегрузка методов известна как полиморфизм во время компиляции (или статический), поскольку каждый из перегруженных методов определяется при компиляции приложения. У этого метода есть несколько названий, таких как "Полиморфизм во время компиляции" или "Статический полиморфизм", а иногда его называют "Ранним связыванием".

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

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

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

using System;

namespace DemoCsharp {
    class Program {
        public int Add(int num1, int num2) {
            return (num1 + num2);
        }
        public int Add(int num1, int num2, int num3) {
            return (num1 + num2 + num3);
        }

        public float Add(float num1, float num2) {
            return (num1 + num2);
        }

        public string Add(string value1, string value2) {
            return (value1 + " " + value2);
        }

        static void Main(string[] args) {
            Program objProgram = new Program();
            Console.WriteLine("Сложение с двумя int: " + objProgram.Add(3, 2));
            Console.WriteLine("Сложение с тремя int: " + objProgram.Add(3, 2, 8));
            Console.WriteLine("Сложение с двумя float: " + objProgram.Add(3 f, 22 f));
            Console.WriteLine("Сложение с двумя string: " + objProgram.Add("привет", "мир"));
            Console.ReadLine();
        }
    }
}

Вывод:

Сложение с двумя int: 5
Сложение с тремя int: 13
Сложение с двумя float: 25
Сложение с двумя string: привет мир

В приведенном выше примере вы можете видеть, что существует четыре метода с одинаковыми названиями, но тип параметров или их количество различаются. Когда вы вызываете Add(4,5), компилятор автоматически вызывает метод, который имеет два целочисленных параметра, а когда вы вызываете Add("привет", "мир"), компилятор автоматически вызывает метод, который имеет два строковых параметра. Таким образом, в основном при перегрузке метода компилятор проверяет, какой метод должен быть вызван во время компиляции.

Примечание: Изменение типа возвращаемого значения метода не приводит к перегрузке метода. Вы не можете создать перегруженный метод, который зависит только от типа возвращаемого значения.

Переопределение метода

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

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

Если мы хотим повторить, переопределение метода означает наличие двух методов с одинаковыми именами и сигнатурами (т.е. параметр), один из которых должен находиться в базовом классе, а другой - в производном классе (дочернем классе). Вы можете переопределить функциональность метода базового класса, чтобы создать метод с тем же именем и той же сигнатурой в производном классе. Вы можете добиться переопределения метода с помощью наследования. Ключевые слова Virtual и Override используются для переопределения метода.

using System;

namespace TestPolymorphism {
    class BaseClass {
        public virtual int Add(int num1, int num2) {
            return (num1 + num2);
        }
    }

    class ChildClass: BaseClass {
        public override int Add(int num1, int num2) {
            if (num1 <= 0 || num2 <= 0) {
                Console.WriteLine("Значения не могут быть меньше нуля или равны нулю");
                Console.WriteLine("Введите первое значение: ");
                num1 = Convert.ToInt32(Console.ReadLine());
                Console.WriteLine("Введите второе значение: ");
                num2 = Convert.ToInt32(Console.ReadLine());
            }

            return (num1 + num2);
        }
    }

    class Program {
        static void Main(string[] args) {
            BaseClass baseClassObj;
            baseClassObj = new BaseClass();
            Console.WriteLine("Метод Add из BaseClass: " + baseClassObj.Add(-3, 8));
            childClassObj = new ChildClass();
            Console.WriteLine("Метод Add из ChildClass: " + childClassObj.Add(-2, 2));
            Console.ReadLine();
        }
    }
}

Вывод:

Метод Add из BaseClass: 5
Значения не могут быть меньше нуля или равны нулю
Введите первое значение: 5
Введите второе значение: 7
Метод Add из ChildClass :12

В приведенном выше примере мы создали два метода с одинаковыми именами как в BaseClass, так и в ChildClass.

Мы используем ключевые слова virtual и override, что означает, что BaseClass является виртуальным, и ChildClass может реализовывать этот класс, а override означает, что этот дочерний класс имеет то же имя и ту же сигнатуру метода, что и родительский класс.

Когда вы вызываете метод Add из BaseClass с значением меньше нуля в качестве параметров, он успешно выполняет сложение. Но когда вы вызываете метод Add из ChildClass с значением меньше нуля, он проверяет наличие отрицательного значения. И если передаваемые значения отрицательные, то он запрашивает новое значение.

Здесь BaseClass по-прежнему использует свою собственную реализацию, но наследующий ChildClass имеет свою собственную переопределенную реализацию, которую он использует. Приложение проверяет во время выполнения, каков тип класса (базовый или дочерний), и вызывает метод для этого конкретного типа.

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

Помните об следующих ограничениях:

• Метод не может быть private
• Только abstract или virtual метод может быть переопределен
• Какой метод следует вызвать, определяется во время выполнения

Заключение

Итак, сегодня мы узнали, что такое полиморфизм в ООП, и сравнили две формы полиморфизма в C# - перегрузку и переопределение. Мы увидели, что:

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