Что такое перегрузка методов
Перегрузка методов
В общем, для перегрузки метода достаточно объявить разные его варианты, а об остальном позаботится компилятор. Но при этом необходимо соблюсти следующее важное условие: тип или число параметров у каждого метода должны быть разными.
Совершенно недостаточно, чтобы два метода отличались только типами возвращаемых значений. Они должны также отличаться типами или числом своих параметров. (Во всяком случае, типы возвращаемых значений дают недостаточно сведений компилятору C#, чтобы решить, какой именно метод следует использовать.) Разумеется, перегружаемые методы могут отличаться и типами возвращаемых значений. Когда вызывается перегружаемый метод, то выполняется тот его вариант, параметры которого соответствуют (по типу и числу) передаваемым аргументам.
Давайте рассмотрим пример использования перегрузки методов:
Как видите метод ui перегружается три раза. Модификаторы параметров ref и out также учитываются, когда принимается решение о перегрузке метода. Несмотря на то что модификаторы параметров ref и out учитываются, когда принимается решение о перегрузке метода, отличие между ними не столь существенно. Давайте добавим еще одну перегрузку в вышеуказанный пример:
Перегрузка методов поддерживает свойство полиморфизма, поскольку именно таким способом в C# реализуется главный принцип полиморфизма: один интерфейс — множество методов. Для того чтобы стало понятнее, как это делается, обратимся к конкретному примеру. В языках программирования, не поддерживающих перегрузку методов, каждому методу должно быть присвоено уникальное имя. Но в программировании зачастую возникает потребность реализовать по сути один и тот же метод для обработки разных типов данных.
Допустим, что требуется функция, определяющая абсолютное значение. В языках, не поддерживающих перегрузку методов, обычно приходится создавать три или более вариантов такой функции с несколько отличающимися, но все же разными именами. Например, в С функция abs() возвращает абсолютное значение целого числа, функция labs() — абсолютное значение длинного целого числа, а функция fabs () — абсолютное значение числа с плавающей точкой обычной (одинарной) точности.
В C# определено понятие сигнатуры, обозначающее имя метода и список его параметров; Применительно к перегрузке это понятие означает, что в одном классе не должно существовать двух методов с одной и той же сигнатурой. Следует подчеркнуть, что в сигнатуру не входит тип возвращаемого значения, поскольку он не учитывается, когда компилятор C# принимает решение о перегрузке метода. В сигнатуру не входит также модификатор params.
Чтобы закрепить понятие перегрузки методов, давайте рассмотрим перегрузку встроенного метода IndexOf класса String пространства имен System:
В данном примере используется только часть доступных перегрузок метода IndexOf, если бы C# не поддерживал перегрузки, то пришлось бы присваивать каждому методу свое имя, что конечно же очень неудобно. В данном случае метод IndexOf реализует несколько перегрузок, для поиска символов и подстрок в исходной строке.
Java Challengers #1: Перегрузка методов в JVM
У нас уже запустился очередной поток курса «Разработчик Java», но у нас ещё осталось немного материалов, которыми бы хотели с вами поделиться.
Добро пожаловать в серию статей Java Challengers! Этот серия статей посвящена особенностям программирования на Java. Их освоение — это ваш путь к становлению высококвалифицированным программистом на Java.
Освоение техник, рассматриваемых в этой серии статей требует некоторых усилий, но они будут иметь большое значение в вашем повседневном опыте в качестве java — разработчика. Избежать ошибок проще когда вы знаете как правильно применять основные техники программирования Java и отслеживать ошибки намного проще, когда вы точно знаете, что происходит в вашем java — коде.
Готовы ли вы приступить к освоению основных концепций программирования на Java? Тогда давайте начнем с нашей первой задачки!
Термин «Перегрузка методов»
Про термин перегрузка разработчики склонны думать, что речь идет о перезагрузке системы, но это не так. В программировании, перегрузка метода означает использование одинакового имени метода с разными параметрами.
Что такое перегрузка методов?
Перегрузка методов — это приём программирования, который позволяет разработчику в одном классе для методов с разными параметрами использовать одно и то же имя. В этом случае мы говорим, что метод перегружен.
В Листинге 1 показаны методы с разными параметрами, которые различаются количеством, типом и порядком.
Листинг 1. Три варианта перегрузки методов.
Перегрузка методов и примитивные типы
Таблица 1. Примитивные типы в Java
Зачем мне использовать перегрузку методов?
Использование перегрузки делает ваш код чище и проще для чтения, а также помогает избежать ошибок в программе.
Чем перегрузка не является
Помните, что изменение имени переменной не является перегрузкой. Следующий код не скомпилируется:
Вы также не можете перегрузить метод, изменяя возвращаемое значение в сигнатуре метода. Этот код также не скомпилируется:
Перегрузка конструктора
Вы можете перегрузить конструктор таким же способом, как и метод:
Решите задачку по перегрузке методов
Готовы ли вы к первому испытанию? Давайте выясним!
Начните с внимательного изучения следующего кода.
Листинг 2. Сложная задача по перегрузке методов
Хорошо. Вы изучили код. Какой будет вывод?
Правильный ответ приведён в конце статьи.
Что сейчас произошло? Как JVM компилирует перегруженные методы
Для того чтобы понять что произошло в Листинге 2, вам нужно знать несколько вещей о том, как JVM компилирует перегруженные методы.
Прежде всего, JVM разумно ленива: она всегда будет прилагать наименьшие усилия для выполнения метода. Таким образом, когда вы думаете о том, как JVM обрабатывает перегрузку, имейте в виду три важных особенности компилятора:
Если вы никогда не сталкивались с этими техниками, то несколько примеров должны вам помочь их понять. Обратите внимание, что JVM выполняет их в том порядке, в котором они указаны.
Вот пример расширения:
Это порядок расширения примитивных типов:
(Прим. переводчика — В JLS расширение примитивов описано с большими вариациями, например, long может быть расширен во float или в double.)
Обратите внимание, что происходит за кулисами при компиляции кода:
А вот пример распаковки:
Вот что происходит за кулисами при компиляции этого кода:
И вот пример метода с аргументами переменной длины. Обратите внимание, что методы переменной длины всегда являются последними для выполнения.
Что такое аргументы переменной длины?
Аргументы переменной длины — это просто массив значений, заданный трёмя точками (. ). Мы можем передать сколько угодно чисел int этому методу.
Аргументы переменной длины (varargs) очень удобны тем, что значения могут передаваться непосредственно в метод. Если бы мы использовали массивы, нам пришлось бы создать экземпляр массива со значениями.
Расширение: практический пример
Аналогично, если мы передаём число 1.0 JVM автоматически распознает, что это double.
Распространенные ошибки с перегрузкой
К настоящему времени вы, вероятно, поняли, что с перегрузкой методов всё может быть запутано, поэтому давайте рассмотрим несколько проблем, с которыми вы, вероятно, столкнетесь.
Автоупаковка с обёртками (autoboxing with wrappers)
Java — это строго типизированный язык программирования и, когда мы используем автоупаковку с обёртками, есть несколько вещей, которые мы должны учитывать. Во-первых, следующий код не компилируется:
Автоупаковка будет работать только с типом double потому что, когда вы скомпилируете код, он будет эквивалентен этому:
Литералы чисел в коде
Как любопытный факт. Знаете ли вы, что тип char принимает числа?
Что необходимо помнить о перегрузке
Перегрузка — это очень мощная техника для случаев, когда вам нужно одинаковое имя метода с разными параметрами. Это полезная техника, потому что использование правильных имён делает код более удобным для чтения. Вместо того, чтобы дублировать имя метода и добавлять беспорядок в ваш код, вы можете просто перегрузить его.
Это позволяет сохранять код чистым и удобным для чтения, а также снижает риск того, что дублирующие методы сломают часть системы.
Что следует иметь в виду: при перегрузке метода JVM сделает наименьшее усилие из возможных.
Вот порядок самого ленивого пути к исполнению:
На этом мы закончим о роли JVM в перегрузке методов. Важно понимать, что JVM по своей сути ленива, и всегда будет следовать по самому ленивому пути.
Ответ
Ответ к Листингу 2 — Вариант 3. efce.
Подробнее о перегрузке методов в Java
Введение в классы и объекты для абсолютных новичков, включая небольшие разделы о методах и перегрузке методов.
Узнайте больше о том, почему важно, что Java является строго типизированным языком и изучите примитивные типы Java.
Изучите ограничения и недостатки перегрузки методов, а также способы их устранения путем использования пользовательских типов и объектов параметров.
ООП. Часть 4. Полиморфизм, перегрузка методов и операторов
C# позволяет использовать один метод для разных типов данных и даже переопределить логику операторов. Разбираемся в перегрузках.
Полиморфизм (от греч. poly — много и morphe — форма) — один из главных столпов объектно-ориентированного программирования. Его суть заключается в том, что один фрагмент кода может работать с разными типами данных.
В C# это реализуется с помощью перегрузок (overloading).
Все статьи про ООП
Пишет о программировании, в свободное время создает игры. Мечтает открыть свою студию и выпускать ламповые RPG.
Перегрузка методов
C# — строго типизированный язык. Это значит, что вы не можете поместить строку в переменную типа int — сначала нужно провести преобразование. Так же и в метод нельзя передать параметр типа float, если при объявлении метода был указан тип double.
Однако если вы экспериментировали с методом WriteLine() класса Console, то могли заметить, что в него можно передавать аргументы разных типов:
Кажется, что нарушена типизация, но компилятор не выдаёт ошибку. Вместо этого всё успешно выводится на экран:
Так происходит потому, что у метода WriteLine() есть перегрузки — методы с таким же названием, но принимающие другие аргументы:
Когда вы вызовете метод Sum(), компилятор по переданным аргументам узнает, какую из его перегрузок вы имели в виду — так же, как это происходит с методом WriteLine().
При этом стоит учитывать, что значение имеют только типы и количество передаваемых аргументов. Например, можно написать такие перегрузки:
У этих методов одинаковые параметры, но разный возвращаемый тип. Попытка скомпилировать такой код приведёт к ошибке — так же, как и создание перегрузки с такими же аргументами, но с другими названиями:
Перегрузка конструкторов
То же самое можно сделать и с конструкторами классов:
Альтернатива этому решению — указать значения для аргументов по умолчанию:
Несмотря на, то что здесь меньше кода, на мой взгляд, это может запутать. Потому что придётся каждый раз заполнять все значения, даже если нужен только один аргумент из конца списка. Перегрузка же позволяет определить и порядок параметров (если они разных типов).
Перегрузка операторов
Перегрузить можно даже операторы, то есть:
Так как использоваться этот оператор должен без объявления экземпляра класса (item1 + item2, а не item1 item1.+ item2), то указываются модификаторы public static.
Например, мы хотим улучшать предметы в играх. Во многих MMO 1 популярна механика, когда один предмет улучшается за счёт другого. Мы можем сделать это с помощью перегрузки оператора сложения:
Теперь при сложении двух объектов класса Item мы будем получать третий объект с улучшенными параметрами. Вот пример использования такого оператора:
В результате в консоль будет выведено следующее:
1) MMO (англ. Massively Multiplayer Online Game, MMO, MMOG)
Массовая многопользовательская онлайн-игра
Перегрузка операторов преобразования типов
Хотя типизация в C# строгая, типы можно преобразовывать. Например, мы можем конвертировать число типа float в число типа int:
С помощью перегрузки операторов преобразования типов мы можем прописать любую логику для конвертации объектов. Для наглядности создадим класс Hero:
В этом классе хранятся данные о персонаже. В MMO часто можно увидеть такой параметр, как мощь — это сумма всех характеристик героя или предмета. Например, её можно посчитать по следующей формуле:
Мощь = (сила + ловкость + интеллект) * уровень.
Мы можем использовать преобразование типов, чтобы автоматически переводить объект в его мощь. Для этого нужно использовать такую конструкцию.
Модификатор implicit говорит компилятору, что преобразование может быть неявным. То есть оно сработает, если написать так:
Explicit, наоборот, означает, что преобразование должно быть явным:
Вот как будет выглядеть перегрузка преобразования объекта класса Hero в int:
Вот как она будет использоваться:
Вывод в консоль будет следующим:
Проблемы читаемости
Несмотря на то, что перегрузки помогают быстро реализовать какой-нибудь функционал, они могут навредить читаемости. Например, не всегда можно сразу понять, зачем в коде складываются два объекта.
Или же непонятно, зачем конвертировать Hero в int. Ясность вносит название переменной (power), но этого недостаточно.
В большинстве случаев лучше использовать более простые решения. Например, можно создать для объекта свойство Power, которое возвращает сумму характеристик.
Вместо сложения объектов можно написать метод Enhance(), который будет принимать другой предмет и прибавлять его характеристики к текущему.
Такие перегрузки стоит использовать либо если вы работаете над кодом один, либо если есть подробная документация.
Домашнее задание
Создайте игру, в которой можно улучшать одни предметы с помощью других. При улучшении предмету добавляется опыт. Когда его станет достаточно, необходимо повысить уровень. Количество опыта должно зависеть от мощи.
Заключение
Полиморфизм — очень удобный инструмент. Однако в этой статье была затронута лишь его часть; чтобы начать работать со второй, нужно ознакомиться с принципами наследования и абстракции.
Вы можете изучить ООП гораздо глубже, записавшись на курс «Профессия C#-разработчик». Он раскрывает лучшие практики работы с C# в объектно-ориентированной парадигме программирования.
Руководство по методам перегрузки в Java
Перегрузка относится к определению нескольких методов с одинаковыми именами, но разными сигнатурами в одном классе. Мы обсудим синтаксис и лучшие методы при перегрузке.
Вступление
Также нормально, когда один метод вызывает другой метод при выполнении процедуры. Тем не менее, вы ожидаете, что эти методы будут иметь разные идентификаторы, чтобы отличать их друг от друга. Или, по крайней мере, предположить, что делают их внутренние органы.
Поэтому интересно, когда классы начинают предлагать методы с одинаковыми именами – или, скорее, когда они перегружают методы, следовательно, нарушают стандарты чистого кода, такие как не повторяйтесь (СУХОЙ) принцип.
Тем не менее, как будет показано в этой статье, методы с похожими/одинаковыми именами иногда полезны. Они могут повысить интуитивность вызовов API, а при экономном и разумном использовании они могут даже улучшить читаемость кода.
Что такое перегрузка метода?
Перегрузка – это процесс определения нескольких методов с одинаковыми именами в одном классе.
Важно напомнить себе о том, как объявить метод, чтобы получить точное представление о том, как происходит перегрузка.
Видите ли, Java ожидает, что методы будут содержать до шести частей :
Таким образом, типичный метод может выглядеть следующим образом:
Поскольку Java может различать сигнатуры методов, она может позволить себе перегрузку методов.
Давайте определим класс с перегруженным методом:
Вызов метода setDetails() с определенным набором аргументов определит, какой метод будет вызван. Если ни одна подпись не соответствует вашему набору аргументов, произойдет ошибка компилятора.
Зачем нам нужна перегрузка метода?
Перегрузка методов полезна в двух основных сценариях. Когда вам нужен класс, чтобы:
Возьмем, к примеру, Адрес класс ниже:
Значения по умолчанию
И, несмотря на получение нескольких подробностей, класс все равно создаст подобие полного адреса. Он заполнит недостающие данные значениями по умолчанию.
Таким образом, по сути, перегруженные методы снизили требования, предъявляемые к клиентам. Пользователям не обязательно знать полный адрес, чтобы использовать класс.
Методы также создают стандартный способ представления сведений о классе в удобочитаемой форме. Это особенно удобно, когда вызывается функция toString() класса:
Как видно из приведенных выше выходных данных, вызов toString() всегда будет выдавать значение, которое легко интерпретировать — без нулей.
Альтернативные Типы Аргументов
Таким образом, можно задать Адрес детали, позвонив либо:
Тем не менее, в обоих случаях вызов toString для класса приведет к следующему:
Способ перегрузки по сравнению с СУХИМ принципом
Конечно, перегрузка методов вводит повторения в класс. И это противоречит самой сути того, что представляет собой СУХОЙ принцип.
В то время как 1 позволяет клиенту указать адрес без ограничений по формату, 5 это довольно строго.
В общей сложности пять методов делают API более удобным. Они позволяют пользователям предоставлять некоторые сведения об адресе. Или все. В зависимости от того, что клиент сочтет удобным.
Таким образом, за счет сухости Адрес оказывается более читабельным, чем когда у него есть сеттеры с разными именами.
Перегрузка методов в Java 8+
Тем не менее, нам необходимо отслеживать добавление и удаление адресов. Таким образом, в клиентском классе мы могли бы добавить слушателя, объявив:
Тем не менее, если вы сделаете это и скомпилируете, ваш компилятор выдаст ошибку:
В результате нам приходится включать явные объявления в лямбды. Мы должны указать на точный перегруженный метод, о котором мы говорим. Следовательно, рекомендуемый способ добавления таких прослушивателей в Java 8 и выше-это:
Git Essentials
Ознакомьтесь с этим практическим руководством по изучению Git, содержащим лучшие практики и принятые в отрасли стандарты. Прекратите гуглить команды Git и на самом деле изучите это!
Лучшие Практики
Возьмем случай, когда разработчик API сделал неправильный выбор типов параметров при перегрузке. Такой подход привел бы пользователей API в замешательство.
Это, в свою очередь, может сделать их код восприимчивым к ошибкам. Кроме того, практика накладывает чрезмерные рабочие нагрузки на JVM. Они напрягаются, чтобы решить точные типы, к которым относятся плохо спроектированные перегрузки методов.
Помните, что перегрузка обычно увеличивает количество параметров, которые клиент может предоставить, поэтому varargs вводит дополнительный уровень сложности. Это связано с тем, что они учитывают различные значения параметров — подробнее об этом через секунду.
Ограничьте использование varargs в перегруженных методах
Программисты тоже сталкиваются с головоломкой – они должны учитывать, например, количество фиксированных переменных, необходимых объекту адреса.
Полное определение объекта адреса может, например, содержать до восьми полей:
Но помните, что varargs также является отличным способом для учета различных параметров. Таким образом, мы могли бы значительно упростить код, включив метод настройки, такой как:
Таким образом, мы позволили бы клиенту класса сделать что-то вроде:
Тем не менее, это создает проблему. Вызывал ли приведенный выше код этот метод:
Или это относилось к:
Короче говоря, как код должен относиться к этим деталям? Например, конкретные поля адреса или общие сведения?
Компилятор не будет жаловаться. Он не выберет переменную arity метод. Вместо этого происходит то, что разработчик API создает двусмысленность, и это ошибка, ожидающая своего появления. Такие, как это:
Приведенный выше вызов передает пустой массив строк ( новая строка[]<> ). Хотя это не является технически ошибочным, это не решает никакой части проблемы домена. Таким образом, через varargs код теперь стал подвержен ошибкам.
Однако существует способ борьбы с этой проблемой. Это включает в себя создание метода из метода с наибольшим количеством параметров.
В этом случае, используя метод:
Тем не менее, описанный выше подход неэлегантен. Благодаря безошибочности это только увеличивает многословие API.
Будьте в курсе автобоксов и расширения
Если мы вызовем метод:
Мы получим результат:
setNumber(длинный) является вторым выбором компилятора. В отсутствие метода с примитивом int JVM отказывается от автобокса для расширения. Помните, Oracle определяет автобокс как:
…автоматическое преобразование, которое компилятор Java выполняет между примитивными типами и соответствующими им классами-оболочками объектов.
С удалением setNumber(целое число) класс печатает:
Вывод
Перегрузка методов может улучшить читаемость кода, если вы используете его с осторожностью. В некоторых случаях это даже делает решение проблем с доменом интуитивно понятным.
Тем не менее, перегрузка-сложная тактика, которой нужно овладеть. Хотя это выглядит как что — то тривиальное в использовании- это совсем не так. Это заставляет программистов учитывать иерархию типов параметров, например, вводить средства автоматического размещения и расширения Java, и перегрузка методов становится сложной средой для работы.
Кроме того, Java 8 ввела в язык новые функции, которые усугубили перегрузки методов. Например, использование функциональных интерфейсов в перегруженных методах снижает читабельность API.
Они заставляют пользователей объявлять типы параметров в клиентском методе. Таким образом, это сводит на нет всю цель перегрузки метода — простоту и интуитивность.
Классы и объекты C#: перегрузка методов
О том, что такое методы C# и как их создавать мы уже поговорили, научились создавать методы классов и использовать их для доступа к свойствам. Однако, иногда бывает необходимо создать создать более одного метода с одним и тем же именем, но различным набором параметров. В практике программирования такой подход называется перегрузкой методов (method overloading).
С перегрузкой методов как таковой мы уже сталкивались, когда создавали различные конструкторы для нашего первого класса. В языке C# мы можем объявить и создать в классе несколько методов с одним и тем же именем, но различающейся сигнатурой.
Сигнатура метода C#
В C# сигнатура метода складывается из следующих элементов:
При этом при перегрузке метода его имя не меняется. Например,вернемся к нашему классу Building и создадим метод, который линейно увеличивает все три измерения здания (длину, ширину и высоту):
Перегрузка методов в C#
Чтобы перегрузить метод мы должны оставить его имя, но изменить хотя бы одну из составляющих его сигнатуры. Например, приведенный выше метод принимает в качестве параметров только целочисленные значения. Мы можем перегрузить метод, изменив тип данных входных параметров и получить два метода с одинаковым именем в одном классе:
Также, мы можем поменять количество параметров:
Теперь у нас в классе имеется три метода изменения размеров здания, которые имеют следующие сигнатуры:
Использование перегруженных методов
Перегруженные методы используются точно также, как и любые другие методы. При выборе того или иного метода Visual Studio подскажет есть ли у метода перегрузки и укажет их количество. Например, вот так будет выглядеть редактор кода Visual Studio при выборе нашего метода:
Чтобы воспользоваться одной из перегрузок метода, мы можем полностью написать имя метода и, поставив после названия метода круглую скобку ( выбрать необходимую перегрузку из списка:
Итого
Сегодня мы познакомились с такими понятиями как сигнатура метода C# и перегрузка методов. Перегрузка методов C# позволяет создавать в классе методы с одинаковым именем, но различающейся сигнатурой.