Привет! Ты уже освоил создание собственных классов, с полями и методами. Сегодня мы как раз подробно поговорим про методы.
Мы, конечно, уже не раз делали это в наших лекциях, но мы говорили в основном об общих моментах. Сегодня же мы буквально разберем методы “по частям” — узнаем из чего они состоят, какие варианты их создания существуют и как всем этим можно управлять:) Поехали!
Сигнатура метода
Весь код, который описывает метод, называется объявлением метода. Сигнатура метода включает название метода и типы параметров в определенном порядке.
Общий вид объявления можно описать так:
модификатор доступа, тип возвращаемого значения, имя метода(список параметров) {
// тело метода
}
Рассмотрим для примера объявлений нескольких методов класса Dog.
public class Dog {
String name;
public Dog(String name) {
this.name = name;
}
public static void main(String[] args) {
Dog max = new Dog("Макс");
max.woof();
}
public void woof() {
System.out.println("Собака по имени " + name + " говорит \"Гав-гав!\"");
}
public void run(int meters) {
System.out.println("Собака по имени " + name + " пробежала " + meters + " метров!");
}
public String getName() {
return name;
}
}
1. Модификатор доступа
Модификатор доступа всегда указывается первым.
Все методы класса Dog обозначены модификатором public. То есть мы можем вызвать их из любого другого класса:
public class Main {
public static void main(String[] args) {
Dog butch = new Dog("Бутч");
butch.run(100);
}
}
Методы класса Dog, как видишь, легко доступны в классе Main.
Это возможно именно благодаря модификатору public.
В Java есть и другие модификаторы, и не все из них позволят использовать метод внутри другого класса. О них мы поговорим в других лекциях.
Главное, запомни за что отвечает модификатор: за доступность/недоступность метода в других классах:)
2. Ключевое слово static
Один из методов Dog, а именно main() обозначен ключевым словом static.
Если же оно есть — то указать его необходимо после модификатора доступа.
Помнишь, в прошлых лекциях мы говорили о статических переменных класса?
Применительно к методам это слово имеет примерно тот же смысл.
Если метод указан как static — это означает, что он может использоваться без ссылки на конкретный объект класса.
И действительно — чтобы запустить статический метод main() в классе Dog тебе не нужно создавать экземпляр Dog, он запускается и без этого.
Если бы этот метод не был статическим — то для его использования нам понадобилось бы сперва создать объект.
3. Возвращаемое значение.
Если наш метод должен что-то вернуть, то далее мы указываем тип возвращаемого значения.
Это видно на примере геттера getName():
public String getName() {
return name;
}
Он возвращает объект типа String.
Если же метод ничего не возвращает — вместо типа указывается ключевое слово void, как в методе woof():
public void woof() {
System.out.println("Собака по имени " + name + " говорит \"Гав-гав!\"");
}
Методы с одинаковыми именами
Бывают ситуации, когда в нашей программе нужно несколько вариантов работы метода.
Почему бы нам не создать свой собственный искусственный интеллект? У Amazon есть Alexa, у Яндекса — Алиса, так чем мы хуже?:)
В фильме про Железного Человека Тони Старк создал собственный выдающийся искусственный интеллект — J.A.R.V.I.S.
Отдадим должное прекрасному персонажу и назовем наш ИИ в его честь:)
Первое, чему мы должны научить Джарвиса — здороваться с людьми, которые заходят в комнату (будет странно, если столь великий интеллект окажется невежливым).
public class Jarvis {
public void sayHi(String name) {
System.out.println("Добрый вечер, " + name + ", как ваши дела?");
}
public static void main(String[] args) {
Jarvis jarvis = new Jarvis();
jarvis.sayHi("Тони Старк");
}
}
Вывод в консоль:
Добрый вечер, Тони Старк, как ваши дела?
Отлично! Джарвис умеет приветствовать вошедшего. Чаще всего, конечно, это будет его хозяин — Тони Старк.
Но ведь он может прийти не один! А наш метод sayHi() принимает на вход только один аргумент. И, соответственно, сможет поприветствовать только одного из пришедших, а другого проигнорирует. Не очень-то вежливо, согласен?:/
В этом случае чтобы решить проблему мы можем просто написать в классе 2 метода с одинаковым названием, но с разными параметрами:
public class Jarvis {
public void sayHi(String firstGuest) {
System.out.println("Добрый вечер, " + firstGuest + ", как ваши дела?");
}
public void sayHi(String firstGuest, String secondGuest) {
System.out.println("Добрый вечер, " + firstGuest + ", " + secondGuest + ", как ваши дела?");
}
}
Это называется перегрузкой методов. Перегрузка позволяет нашей программе быть более гибкой и учитывать различные варианты работы. Проверим как это работает:
public class Jarvis {
public void sayHi(String firstGuest) {
System.out.println("Добрый вечер, " + firstGuest + ", как ваши дела?");
}
public void sayHi(String firstGuest, String secondGuest) {
System.out.println("Добрый вечер, " + firstGuest + ", " + secondGuest + ", как ваши дела?");
}
public static void main(String[] args) {
Jarvis jarvis = new Jarvis();
jarvis.sayHi("Тони Старк");
jarvis.sayHi("Тони Старк", "Капитан Америка");
}
}
Вывод в консоль:
Добрый вечер, Тони Старк, как ваши дела?
Добрый вечер, Тони Старк, Капитан Америка, как ваши дела?
Отлично, оба варианта сработали:)
Тем не менее, проблему мы не решили!
Что, если гостей будет трое? Конечно, мы можем еще раз перегрузить метод sayHi(), чтобы он принимал имена трех гостей. Но их ведь может быть и 4, и 5. И так до бесконечности.
Нет ли другого способа научить Джарвиса работать с любым количеством имен, без миллиона перегрузок метода sayHi()? :/
Конечно, есть! Иначе была бы разве Java самым популярным в мире языком программирования? ;)
public class Jarvis {
public void sayHi(String...names) {
for (String name: names) {
System.out.println("Добрый вечер, " + name + ", как ваши дела?");
}
}
public static void main(String[] args) {
Jarvis jarvis = new Jarvis();
jarvis.sayHi("Тони Старк");
System.out.println();
jarvis.sayHi("Тони Старк", "Капитан Америка");
}
}
Запись (String...names) переданная в качестве параметра позволяет нам указать, что в метод передается какое-то количество строк. Мы не оговариваем заранее сколько их должно быть, поэтому работа нашего метода становится теперь намного более гибкой:
public class Jarvis {
public void sayHi(String...names) {
for (String name: names) {
System.out.println("Добрый вечер, " + name + ", как ваши дела?");
}
}
public static void main(String[] args) {
Jarvis jarvis = new Jarvis();
jarvis.sayHi("Тони Старк", "Капитан Америка", "Черная Вдова", "Халк");
}
}
Вывод в консоль:
Добрый вечер, Тони Старк, как ваши дела?
Добрый вечер, Капитан Америка, как ваши дела?
Добрый вечер, Черная Вдова, как ваши дела?
Добрый вечер, Халк, как ваши дела?
Внутри метода мы в цикле перебираем все аргументы и выводим готовые фразы с именами на консоль.
Здесь мы применяем упрощенный цикл for-each (ты уже с ним сталкивался). Он отлично подходит, потому что запись String...names — на самом деле означает, что все переданные параметры помещаются компилятором в массив. Поэтому с переменной names можно работать как с массивом, в том числе — перебирать в цикле.
При этом он сработает при любом количестве переданных строк! Две, десять, хоть тысяча — метод будет стабильно работать с любым количеством гостей. Намного удобнее, чем делать перегрузки для всех возможных вариантов, согласен?:)
Приведем еще один пример перегрузки метода.
Добавим Джарвису метод printInfoFromDatabase(). Он будет печатать в консоль информацию о человеке из базы данных. Если в базе данных указано, что человек является супергероем или суперзлодеем — эта информация также будет выведена на экран:
public class Jarvis {
public void printInfoFromDatabase (String bio) {
System.out.println(bio);
}
public void printInfoFromDatabase(String bio, boolean isEvil, String nickname) {
System.out.println(bio);
if (!isEvil) {
System.out.println("Также известен как супергерой " + nickname);
} else {
System.out.println("Также известен как суперзлодей " + nickname);
}
}
public static void main(String[] args) {
Jarvis jarvis = new Jarvis();
jarvis.printInfoFromDatabase("Лора Палмер. Дата рождения - 22 июля 1972, город Твин Пикс, штат Вашингтон");
System.out.println();
jarvis.printInfoFromDatabase("Макс Эйзенхарт. Рост 188см, вес 86 кг.", true, "Магнето");
}
}
Вывод:
Лора Палмер. Дата рождения - 22 июля 1972, город Твин Пикс, штат Вашингтон
Макс Эйзенхарт. Рост 188см, вес 86 кг
Также известен как суперзлодей Магнето
Вот так, наш метод работает в зависимости от данных которые мы в него передаем.
Еще один важный момент: порядок следования аргументов имеет значение!
Допустим, наш метод принимает на вход строку и число:
public class Man {
public static void sayYourAge(String greeting, int age) {
System.out.println(greeting + " " + age);
}
public static void main(String[] args) {
sayYourAge("Мой возраст - ", 33);
sayYourAge(33, "Мой возраст - "); //ошибка!
}
}
Если метод sayYourAge() класса Man принимает на вход строку и число — значит именно в таком порядке их нужно передавать в программе! Если мы передадим их в другом порядке — компилятор выдаст ошибку и человек не сможет назвать свой возраст.
Кстати, конструкторы, которые мы проходили в прошлой лекции, тоже являются методами! Их тоже можно перегружать (создавать несколько конструкторов с разным набором аргументов) и для них тоже принципиально важен порядок передачи аргументов. Настоящие методы!:)
Как вызывать методы с похожими параметрами
Как ты знаешь, в Java есть такое слово как null.
При работе с ним очень важно понимать, что null не является ни объектом, ни типом данных.
Представь себе, что у нас есть класс Man и метод introduce(), который объявляет имя человека и его возраст. При этом возраст можно передать в форме текста, а можно - числом.
public class Man {
public void introduce(String name, String age) {
System.out.println("Меня зовут " + name + ", мой возраст - " + age);
}
public void introduce(String name, Integer age) {
System.out.println("Меня зовут " + name + ", мой возраст - " + age);
}
public static void main(String[] args) {
Man sasha = new Man();
sasha.introduce("Саша", "двадцать один");
Man masha = new Man();
masha.introduce("Мария", 32);
}
}
С перегрузкой мы уже знакомы, поэтому знаем, что метод оба раза отработает как надо:
Меня зовут Саша, мой возраст - двадцать один
Меня зовут Мария, мой возраст - 32
Но что будет, если в качестве второго параметра мы передаем не строку и не число, а null?
public static void main(String[] args) {
Man victor = new Man();
victor.introduce("Виктор", null);//Ambiguous method call!
}
Мы получим ошибку компиляции!
Ошибка “Ambiguous method call” переводится как “двусмысленный вызов метода”.
Из-за чего она могла возникнуть и в чем заключается “двусмысленность”?
На самом деле все просто.
Дело в том, у нас есть два варианта метода: со String и с Integer в качестве второго аргумента.
Но и String, и Integer могут быть null!
Для обоих типов (поскольку они ссылочные) null является значением по умолчанию.
Именно поэтому компилятор в данной ситуации не может разобраться, какой вариант метода он должен вызвать.
Решить эту проблему достаточно просто. Дело в том, что null можно явно преобразовать к конкретному ссылочному типу.
Поэтому при вызове метода ты можешь указать в скобках нужный тебе тип данных для второго аргумента! Компилятор поймет твой “намек” и вызовет нужный метод:
public class Man {
public void introduce(String name, String age) {
System.out.println("Метод с двумя строками!");
System.out.println("Меня зовут " + name + ", мой возраст - " + age);
}
public void introduce(String name, Integer age) {
System.out.println("Метод со строкой и числом!");
System.out.println("Меня зовут " + name + ", мой возраст - " + age);
}
public static void main(String[] args) {
Man victor = new Man();
victor.introduce("Виктор", (String) null);
}
}
Вывод:
Метод с двумя строками!
Меня зовут Виктор, мой возраст - null
А вот если бы числовой параметр был примитивом int, а не объектом ссылочного типа Integer — такой ошибки не возникло бы.
public class Man {
public void introduce(String name, String age) {
System.out.println("Метод с двумя строками!");
System.out.println("Меня зовут " + name + ", мой возраст - " + age);
}
public void introduce(String name, int age) {
System.out.println("Метод со строкой и числом!!");
System.out.println("Меня зовут " + name + ", мой возраст - " + age);
}
public static void main(String[] args) {
Man victor = new Man();
victor.introduce("Виктор", null);
}
}
Догадался почему?
Если догадался — молодец:)
Потому что примитивы не могут быть равны null. Теперь у компилятора остался только один вариант вызова метода introduce() — с двумя строками.
Именно этот вариант метода и будет отрабатывать каждый раз при вызове метода.
Александр увлекся программированием еще в школе, писал игры. Позже это увлечение переросло в профессиональную разработку. Поработа ...
[Читать полную биографию]
"Если метод указан как static — это означает, что он может использоваться без ссылки на конкретный объект класса.
И действительно — чтобы запустить статический метод main() в классе Dog тебе не нужно создавать экземпляр Dog, он запускается и без этого.
Если бы этот метод не был статическим — то для его использования нам понадобилось бы сперва создать объект. "
Может кто-то этот момент осветить подробнее, на примерах. Как-то я не могу себе представить метод main без static. Или дать ссылку на хороший материал, где это разжевано. Заранее спасибо.
Чукча не писать, чукча читатель
Видите новую тему на javarush, сразу открывайте гугл и читайте 3 любых других сайта, т.к. здесь авторы очень часто не удосуживаются связывать предложения между собой.
Вотаквот с сохранением структуры чоб было, а не каждое имя с новой строки. Пойду за пирожком с полки.
public class Jarvis {
public void sayHi(String...names) {
String text = "";
for (String name: names) {
text += name + ", ";
}
System.out.println("Добрый вечер, " + text + "как ваши дела?");
}
public static void main(String[] args) {
Jarvis jarvis = new Jarvis();
jarvis.sayHi("Тони Старк", "Капитан Америка", "Черная Вдова", "Халк");
}
}
Vsevolod діло в тому що поки що ми працюєм в одному текстовому файлі де описуємо декілька класів. в реальній програмі кожний клас описується в іншому текстовому файлі. тоді ти конкретно розумієш за що кожний клас відповідає і обявляєш його в любому з класів де тобі потрібно його методи - клас це як маленька під програма яка щось виконує .
лучше объясните то, чему нас никогда не учили.я реально не понимаю, как воспринимать эту информацию, у нас не было никакой по ней практики.
Сначала мы пишем всё в public class Dog, там же и главная функция, а в следующем окошке у нас уже почему-то public class Main, и там у нас главная функция. Я один не понимаю? Как это всё полностью будет выглядеть?
это два разных класса (Main, Dog)
в задачах на ДЖВР если мы создавали новый класс - мы делали это все в одном коде
на самом деле это не совсем правильно
в нашем случае надо создать отдельный класс Dog и Main (в одном package) и уже в Main создать экзепляр Dog, чтобы использовать его методы)
по хорошему, в package должен быть только один клас с public static void main(String[] args)
откуда начинается работа программы
Когда-то мы уже читали эту статью ; )
Спасибо, конечно, на 9 уровне статья раскрывается в совершенно новом свете, более осознанно и даёт приятное ощущение прогресса. Не понятно только, почему именно сейчас, в теме про исключения, её решили преподать вновь?..
Кодёры, подскажите.
Какой практический смысл запрашивать аргумент Integer вместо int?
И второй вопрос. Я усвоил, что переменные нужно инициализировать.
То есть почему этот код не сработает - понятно
String s; //нужно String s = "";
s =+ "Строка";
Но почему этот код тоже не работает без инициализации, если в примитиве по умолчанию 0?
Ответ на первый вопрос.
Смысл в том, что int - примитив со свойствами примитива, а Integer - класс, со свойствами класса 😉 Если нужно обратиться к числу, как к объекту класса, то нужно использовать Integer.
Конкретно в этом примере просто показали, с какой проблемой можно столкнуться, выбрав Integer. Насколько я поняла из статьи, теоретически можно в качестве аргумента указать как int, так и Integer.
"Локальные переменные объявляются в основном для выполнения некоторых вычислений. Таким образом, это решение программиста установить значение переменной, и оно не должно принимать значение по умолчанию. Если программист по ошибке не инициализировал локальную переменную и она приняла значение по умолчанию, то на выходе может получиться какое-то неожиданное значение. Поэтому в случае локальных переменных компилятор попросит программиста инициализировать их с помощью некоторого значения, прежде чем они обратятся к переменной, чтобы избежать использования неопределенных значений."
Чаще задавайте вопросы в гугл.
То есть согласно этому твоему гуглу, у объявленной в в классе и не инициализированной переменной не может произойти ничего неожиданного? То есть она для вычислений не используется? И поэтому такой код работает без проблем? 🤣
public class Cat {
public static int i;
public static void main(String[] args) throws IOException {
i++;
System.out.println(i);
Что-то бредит твой гугл походу.
Причина проста: локальные переменные не получают значений по умолчанию. Java Language Specification Chapter 16. Definite Assignment
Почему? Вопрос к разработчикам.
Лично у меня после прочтения Java Stack and Heap: Java Memory Allocation появилась мысль, что просто для скорости: методы живут и умирают (стираются из памяти) очень быстро, а классовые переменные могут жить долго. И соответственно каждый раз давать значения по умолчанию для методов не рационально. Но это только догадка.
Какой практический смысл запрашивать аргумент Integer вместо int?
Класс - обёртка содержит большое количество методов, которые для примитива не доступны. Например, преобразования в двоичный формат.
String s; //нужно String s = "";
s =+ "Строка";
В первой строчке ты обьявлешь переменную ссылочного типа, то есть ссылку на элемент типа String в памяти, то есть ссылка есть, а обьекта, на который ссылаются нет. Во второй строчки кода происходит конкатенация строк, ты прибавляешь к несозданному обьекту, обьект "Строка". Соотвественно получается ошибка. NPE.
кто то может разжевать зачем там sout пустой?
public class Jarvis {
public void printInfoFromDatabase (String bio) {
System.out.println(bio);
}
public void printInfoFromDatabase(String bio, boolean isEvil, String nickname) {
System.out.println(bio);
if (!isEvil) {
System.out.println("Также известен как супергерой " + nickname);
} else {
System.out.println("Также известен как суперзлодей " + nickname);
}
}
public static void main(String[] args) {
Jarvis jarvis = new Jarvis();
jarvis.printInfoFromDatabase("Лора Палмер. Дата рождения - 22 июля 1972, город Твин Пикс, штат Вашингтон");
System.out.println();
jarvis.printInfoFromDatabase("Макс Эйзенхарт. Рост 188см, вес 86 кг.", true, "Магнето");
}
}
Помогите пожалуйста разобраться!
"И действительно — чтобы запустить статический метод main() в классе Dog тебе не нужно создавать экземпляр Dog, он запускается и без этого.
Если бы этот метод не был статическим — то для его использования нам понадобилось бы сперва создать объект. "
Но разве вот тут, мы не создаем объект класса Dog?
public static void main(String[] args) {
Dog max = new Dog("Макс");
max.woof();
}
создаём, конечно, потому что вызываем далее не статический метод woof()... а для того, чтобы вызвать статический метод main() экземпляр класса Dog создавать не надо.
Когда читаю подобные повторные статьи, то такое ощущение, что раньше это была отдельная лекция, потом ее переписали усовершенствовали и новую лекцию воткнули в курс. а эту старую отправили в статьи. И теперь не пылиться же ей, дают на нее ссылку, мол еще раз прочитай все тоже самое и капельку нового, ибо повторение мать ученья.
Вот кстати, я правильно помню, что public void sayHi(String...names) перегрузка только по одному параметру быть может, и он должен быть последним?
т.е.
public void sayHi(String...names, int age)
либо
public void sayHi(String...names, double ...prices)
"Внутри метода мы в числе перебираем все аргументы" - опечаточка ;)
'мы в циКле перебираем' , я так думаю :)
Для тех кто пытается понять суть внимательным изучением статьи - любая опечатка может буть ступором :)
Вы меня не знаете, да и доброта тут не при чем. Ничего личного, только бизнес. Безграмотность - это непрофессионально. Здесь она зашкаливает, у меня же не из-за одной ошибки подгорело) А деньги действительно немалые, хотелось бы получать материалы на достойном уровне. Не всем еще плевать на русский, знаете ли.
На фикс:
Мы, конечно, уже не раз это делали в наших лекциях
Если же "оно" есть — то указать его необходимо после модификатора доступа.
#смысл понятен лишь с - 3-го прочтения (имхо). Лучше было написать: "static указывается после модификатора доступа".
Спасибо за статью. Впрочем, кажется мне я уже её читал...
Здесь в качестве примера сигнатуры метода приведен катастрофически не верный пример.
То что показано здесь - это не сигнатура метода, это общий синтаксис объявления метода.
Применительно к Java сигнатура обозначает имя метода и список его параметров. Следует, однако,
иметь в виду, что сигнатура не включает в себя тип возвращаемого значения,
поскольку он не используется в Java при принятии решения о перегрузке.
Вырезка цитаты из книги Герберта Шилдта. "Руководство для начинающих" 7-е издание. Глава 6 страница 238. Сноска "Спросим у эксперта".
P.S. В других изданиях номер страницы может отличаться. Ищите тему "Перегрузка методов" в :-ой главе. В конце этой темы будет объяснение что такое сигнатура. Не поленитесь прочитайте тему а потом определение, понятней будет.
Возможно не точно выразился.
В этой статье идёт рассказ конкретно не о сигнатуре метода, а как уже указали, об объявлении метода, тут же упоминается и о сигнатуре.
Сигнатура метода
Весь код, который описывает метод, называется объявлением метода.
Сигнатура метода включает название метода и типы параметров в определенном порядке.
Так что статью, думаю, можно назвать "Объявление, сигнатура и перегрузка метода"
Конкретно по сигнатуре ниже в комментариях хорошие примеры и ссылки приводят.
К тому же это не лекция, а статья, не знаю, следят ли тут за этим. Механизма указания на ошибку в статье не заметил. (Аля "Увидели ошибку - выделите и нажмите...")
Дополню. В Шилдте Полное руководство 10е издание так же запутано написано: При вызове перегружаемого метода для определения нужного его варианта в Java используется тип и /или количество аргументов метода. Следовательно, перегружаемые методы должны отличаться по типу и/или количеству их параметров. Последняя фраза "по типу и/или количеству их параметров также путает". Однако он дальше пишет: Когда в исполняющей среде Java встречается вызов перегружаемого метода, в ней просто выполняется тот вариант, параметры которого соответствуют аргументам, указанным в вызове. Также дальше есть более точное предложение: возвращаемый тип никоим образом не влияет на поиск перегружаемого варианта метода. Вероятно на JavaRush и у Шилда нужно читать оригинал статьи на английском. Скорее всего это ошибки перевода.
Всем,привет)
Почему не можем просто вызывать методы столько, сколько нам нужно, а обязательно должны создать обьект и уже через ссылку которую мы присвоили данному обьекту через точку вызвать метод?
Заранее спасибо)
Почему не можем - можем)) Только нужно прикрутить к вызываемому методу модификатор static - без него ошибка будет.
public class Man {
public static void introduce(String name, String age) {
System.out.println("Метод с двумя строками!");
System.out.println("Меня зовут " + name + ", мой возраст - " + age);
}
public static void introduce(String name, int age) {
System.out.println("Метод со строкой и числом!!");
System.out.println("Меня зовут " + name + ", мой возраст - " + age);
}
public static void main(String[] args) {
Man victor = new Man();
victor.introduce("Виктор", null);
introduce("Вася", 15);
introduce("Коля", "двадцать лет");
}
}
Сигнатура метода
Весь код, который описывает метод, называется сигнатурой метода.
Простите, но мне кажется что сигнатура - совокупность имени метода с набором параметров (порядок важен !). Не больше не меньше. Возвращаемое значение, модификатор доступа, ексепшены и тело метода не входят в сигнатуру метода.
Пруф.
Тут рассказали об "общем смысле" сигнатуры:
More generally, method declarations have six components, in order:
Modifiers—such as public, private, and others you will learn about later.
The return type—the data type of the value returned by the method, or void if the method does not return a value.
The method name—the rules for field names apply to method names as well, but the convention is a little different.
The parameter list in parenthesis—a comma-delimited list of input parameters, preceded by their data types, enclosed by parentheses, (). If there are no parameters, you must use empty parentheses.
An exception list—to be discussed later.
The method body, enclosed between braces—the method's code, including the declaration of local variables, goes here.
Но чистое определение, да: название и типы параметров.Definition: Two of the components of a method declaration comprise the method signature—the method's name and the parameter types.
The signature of the method declared above is:
calculateAnswer(double, int, double, double)
https://docs.oracle.com/javase/tutorial/java/javaOO/methods.html
Definition: Two of the components of a method declaration comprise the method signature—the method's name and the parameter types.
The signature of the method declared above is:
calculateAnswer(double, int, double, double)
Нету никакого "общего смысла" у сигнатуры. И это крайне важно. Потому что сигнатура позволяет однозначно идентифицировать метод. Имя + параметры, все остальное не имеет к сигнатуре вообще никакого отношения.
А то потом будут красные подчеркивания в IDE и круглые глаза, а что, собственно, происходит.
ПЕРЕЙДИТЕ В ПОЛНУЮ ВЕРСИЮ