 |
Вопрос: А вот этот a++ на значении переменной n как-то сказалось?
|
|
|
|
Вопрос: А вот этот a++ на значении переменной n как-то сказалось?
Ответ: Нет. Поэтому когда я вызываю функцию, значения аргументов (n, m, 1) – они передаются по значению аргумента в переменные, которые как параметры объявлены. В Java только механизм передачи по значению.
Вопрос: Зачем это сделано?
Ответ: Для надежности, потому что метод ничего не может испортить то, что находится во вне. Представьте, если бы я мог изменить и n, и m. Какой бы это был кошмар. Кто-то вызывает метод, а он берет и меняет ваши переменные во вне. Вы вообще не пожете понять, почему так происходит. Поэтому, вы работаете с копией. Можете делать с ней все, что захотите, но n, m и 1 вам никак не испортить.
Вопрос: А что происходит для ссылочных типов?
Ответ: Вначале надо разобрать, а что такое ссылочные типы. Надо будет нарисовать, как они устроены в памяти, и тогда мы сможем понять, как они передаются в методы в ссылочные типы.
Перегрузка и методы с переменным числом аргументов.
 Перегрузка функций
– void solve(int a)
– void solve(int a, int b)
Функции с переменным числом аргументов
– void vsolve1(Object … arg)
– void vsolve2(int [] … arg)
Java разрешает определение внутри одного класса двух или более методов с одним именем, если только объявления их параметров различны. В этом случае методы называют перегруженными, а процесс — перегрузкой методов. Перегрузка методов — один из способов поддержки полиморфизма в Java. Тем читателям, которые никогда не использовали язык, допускающий перегрузку методов, эта концепция вначале может показаться странной. Но, как вы вскоре убедитесь, перегрузка методов — одна из наиболее впечатляющих и полезных функциональных возможностей Java.
При вызове перегруженного метода для определения нужной версии Java использует тип и/или количество аргументов метода. Следовательно, перегруженные методы должны различаться по типу и/или количеству их параметров. Хотя возвращаемые типы перегруженных методов могут быть различны, самого возвращаемого типа недостаточно для различения двух версий метода. Когда Java встречает вызов перегруженного метода, она просто выполняет ту его версию, параметры которой соответствуют аргументам, использованным в вызове.
Перегрузка ценна тем, что она позволяет обращаться к схожим методам по общему имени. Таким образом, имя abs представляет общее действие, которое должно выполняться. Выбор нужной конкретной версии для данной ситуации — задача компилятора. Программисту нужно помнить только об общем выполняемом действии. Полиморфизм позволяет свести несколько имен к одному. Хотя приведенный пример весьма прост, если эту концепцию расширить, легко убедиться в том, что перегрузка может облегчить выполнение более сложных задач.
При перегрузке метода каждая версия этого метода может выполнять любые необходимые действия. Не существует никакого правила, в соответствии с которым перегруженные методы должны быть связаны между собой. Однако со стилистической точки зрения перегрузка методов предполагает определенную связь. Таким образом, хотя одно и то же имя можно использовать для перегрузки несвязанных методов, поступать так не следует. Например, имя sqr можно было бы использовать для создания методов, которые возвращают квадрат целочисленного значения и квадратный корень значения с плавающей точкой. Но эти две операции принципиально различны. Такое применение перегрузки методов противоречит ее исходному назначению. В частности, следует перегружать только тесно связанные операции.
|
Для методов существует еще несколько дополнительных возможностей – перегрузка. Я могу сделать один метод, например, сумма. Но ко мне приходит заказчик, и говорит: «Ты мне сделай сумму для двух параметров, для трех, для четырех, для пяти». А я ему: «А давай до ста! ». А он: «Да, давай до ста! ». Можно было бы написать summa1(), summa2, …, summa100(). Это очень не удобно. Представьте, что у вас по всей программе вызывается метод summa75(), потом вы хотите сделать 73 параметра, а вам надо еще и имя менять в методе. Это очень неудобно. А когда у меня есть перегрузка, то мне разрешено все методы назвать одинаково. Они все выполняют одну функцию – суммирование. Но они должны отличаться числом параметров(! ) или типом(! ) имея одинаковое имя, имея одинаковый тип возвращаемого значения.
|
|
|
|
|
|
Посмотрите на перегрузку из жизни – println.
Вот он существует в стольких вариантах. println() – переход на новую строку. А также есть и для других типов и мы это видим. Есть также println(Object o) – это для всех ссылочных типов. И отдельно есть для строк (строки – это отдельная история).
Поэтому получается, что println существует, как вариант на все случаи жизни.
А теперь представьте, что у меня гигантская программа и вдруг моя переменная, которая была double, поменяла тип на int. В одном случае у меня вызывался метод printDouble, а мне бы пришлось, поменяв тип переменной потом по всей программе поменять вызов метода на printInt. Представляете, какой бы был ужас? Перегрузка – это идеальное решение.
Вопрос: Есть в Java перегрузка операций?
Ответ: Нет. +, - перегружать в Java вы не будете. И, слава богу, никому это не нужно. Я не очень представляю, как складывать двух сотрудников. И даже >, < для сотрудников не представляю, как реализовать. Никому это не нужно.
Вернемся к нашим баранам…
Но дело можно довести до маразма, и тот же самый заказчик придет, и скажет: «Ну хорошо! Ты мне написал сумма от 1 до 100. А если мне понадобится больше? ».
И тогда вы можете предложить ему такой вариант: «А давай мы тебе сделаем так: мы тебе напишем один вариант, но на вход в массив будет всего 1 параметр – массив. Массив же может быть любой размерности, правильно? Ты создай массив, положи туда свои замечательные числа. Вызови сумму, и на вход в массив. Я тебе все скажу! У тебя будет одна версия! ». А он скажет: «Нет, я хочу через запятую! И чтобы было сколько угодно! ». Вот тогда вам пригодится для решения такой задачи метод с переменным числом аргументов (…).
|
|
|
Функции с переменным числом аргументов
– void vsolve1(Object … arg)
– void vsolve2(int [] … arg)
«Три точки» - это такой синтаксис, который говорит компилятору – это не один параметр, а число аргументов с произвольным количеством. Их можно указывать через запятую и их всех положат в один arg.
Вопрос: А кто такой arg, который способен хранить много чисел?
Ответ: Это arg-массив. Это может быть не обязательно Object - тип может быть любым. Это может быть не обязательно такой простой тип, как int или double. На вход можно передать любое количество массивов через запятую. Т. е. можно сделать практически, что хочешь.
И поэтому если мы хотим попробовать вариант с переменным числом аргументов, то мы можем использовать наш код.
Вот это правильный синтаксис. Осталось написать что-то внутри.
Вопрос: А сколько можно передать на вход данных?
Ответ: От нуля. Разрешено передавать даже 0. Самое приятное, что такой синтаксис позволяет на вод передать не только через запятую сто чисел, но можно на вод передать массив.
|
|
|
