Параметри на метода в Java

1. Предаване на аргументи

И сега започва забавлението. Вероятно вече знаете от подобни методи System.out.println(), че можем да предаваме аргументи на методи. След като сме вътре в метода, ние ги наричаме параметри. Всъщност параметрите значително увеличават ползите, които получаваме от създаването и използването на методи.

Как да декларираме метод с параметри? Всъщност е доста просто:

public static void name(parameters)
{
  method body
}

Където name е уникалното име на метода и method body представлява командите, които съставят метода. И parameters е контейнер за параметрите на метода, разделени със запетаи. Нека опишем този шаблон по-подробно:

public static void name(Type1 name1, Type2 name2, Type3 name3)
{
  method body
}

Примери:

public static void print(String str)
{
}

public static void print(String str, int count)
{
}

public static void write(int x, int y)
{
}

Ако не искаме методът да има параметри, тогава просто оставяме скобите празни.

Параметрите са специални променливи в метода. С тяхна помощ можете да предавате различни стойности на метода, когато бъде извикан.

Например, нека напишем метод, който показва низ от текст определен брой пъти.

Вече знаете How да пишете code за показване на низ на екрана няколко пъти. Но кой низ трябва да отпечатате? И колко пъти? Ето за Howво са ни необходими параметрите.

Кодът, който прави това, ще изглежда така:

class Solution
{
   public static void printLines(String text, int count)
   {
     for (int i = 0; i < count; i++)
       System.out.println(text);
   }

   public static void main(String[] args)
   {
     printLines("Hello", 10);
     printLines("Bye", 20);
   }
}

Всеки път, когато се извика метод, на неговите параметри се присвояват предадените стойности и едва тогава започваме да изпълняваме командите вътре в метода.

2. Аргументи

Бих искал да насоча вниманието ви малко повече към извикването на метод с параметри.

Стойностите, предавани на метода, обикновено се наричат ​​аргументи, когато се предават на метода.

Нека да разгледаме друг пример:

class Solution
{
   public static void printLines(String text, int count)
   {
     for (int i = 0; i < count; i++)
       System.out.println(text);
   }

   public static void main(String[] args)
   {
     printLines("Hello", 10);
     printLines("Bye", 20);
   }
}

Когато printLines методът беше извикан за първи път, на неговите параметри бяха присвоени следните стойности:
String text = "Hi", int count = 10.

Когато printLinesметодът беше извикан втори път, на неговите параметри бяха присвоени различни стойности:
String text = "Bye", int count = 20.

Параметрите са не повече и не по-малко от променливи, на които се присвояват определени стойности, когато се извиква метод. Самите стойности "Hi", "Bye", 10и 20се наричат ​​аргументи."

3. Конфликтни имена на променливи при извикване на метод

Променливите могат да се използват като аргументи на метода. Това е просто и разбираемо, но потенциално може да създаде някои трудности. Нека се върнем към същия пример, но този път ще преместим аргументите в отделни променливи:

class Solution
{
   public static void printLines(String text, int count)
   {
     for (int i = 0; i < count; i++)
       System.out.print(text);
   }

   public static void main(String[] args)
   {
     String str = "Hi";
     int n = 10;
     printLines(str, n);
   }
}

Дотук добре: имаме променлива str. Стойността му се присвоява на textпараметъра при извикване на метода. Имаме nпроменлива. Стойността му се присвоява на countпараметъра при извикването на метода." Дотук всичко е ясно.

Сега нека преименуваме нашите променливи в mainметода:

class Solution
{
   public static void printLines(String text, int count)
   {
     for (int i = 0; i < count; i++)
       System.out.print(text);
   }

   public static void main(String[] args)
   {
     String text = "Hi";
     int count = 10;
     printLines(text, count);
   }
}

Обърнете внимание на две неща

Първо: имаме променливи с едно и също име в различни методи. Това са различни променливи (умишлено ги изобразяваме с различни цветове). Всичко работи по същия начин, Howто в предишния пример, където променливите в mainметода са именувани strи n.

Второ: Нищо магическо не се случва, когато методът бъде извикан. На параметрите просто се присвояват стойностите на аргумента. Независимо дали са числа, низове, променливи or изрази.

След като преименуваме променливите в основния метод, нищо не се е променило. Те бяха различни променливи в различни методи преди това и така си остават. Няма магическа връзка между променливите text и text .

4. Предаване на препратки към методи

Надявам се, че сте разбрали всичко от предишния урок, защото сега ще преразгледаме предаването на аргументи към методите, само че ще се потопим по-дълбоко.

Както вече знаете, някои Java променливи съхраняват не самите стойности, а instead of това препратка, т.е. address на блока от паметта, където се намират стойностите. Ето How работят низовите променливи и масивните променливи.

Когато присвоите друга променлива от масив към променлива от масив, Howво се случва? Това е вярно. Двете променливи започват да се отнасят към едно и също пространство в паметта:

И Howво се случва, ако една от тези променливи е параметър на метод?

class Solution
{
   public static void printArraySum(int[] data)
   {
     int sum = 0;
     for (int i = 0; i < data.length; i++)
       sum = sum + data[i];
     System.out.println(sum);
   }
   
   public static void main(String[] args)
   {
     int[] months = {31, 28, 31, 30, 31, 30, 31, 31, 30};
     printArraySum(months);
   }
}

Случва се абсолютно същото: data параметърът ще съдържа препратка към същата област от паметта като променливата months. Когато методът бъде извикан, възниква просто присвояване: .data = months

И тъй като и двете променливи се отнасят до една и съща област от паметта, съхраняваща цяло число, тогава методът printArraySum може не само да чете стойности от масива, но и да ги променя!

Например, можем да напишем наш собствен метод, който запълва двуизмерен масив със същата стойност. Ето How може да изглежда:

class Solution
{
   public static void fill(int[][] data, int value)
   {
     for (int i = 0; i < data.length; i++)
     {
       for (int j = 0; j < data[i].length; j++)
         data[i][j] = value;
     }
  }

   public static void main(String[] args)
   {
     int[][] months = {{31, 28}, {31, 30, 31}, {30, 31, 31}};
     fill (months, 8);
   }
}

5. Методи със същото име

Сега нека се върнем отново към имената на методите.

Стандартите на Java изискват всички методи в един и същ клас да имат уникални имена. С други думи, невъзможно е да декларирате два метода с еднакви имена в един и същи клас.

Когато методите се сравняват за еднаквост, се вземат предвид не само имената, но и типовете на параметрите ! Имайте предвид, че имената на параметрите не се вземат предвид . Примери:

void fill(int[] data, int value) {
}
void fill(int[][] data, int value) {
}
void fill(int[][][] data, int value)  {
}

void print(String str) {
}
void print(String str, String str2) {
}
void print(int val) {
}
void print(double val) {
}
void print() {
}

void sum(int x, int y) {
}
void sum(int data, int value) {
}

Защо някои методи се считат за еднакви , докато други са различни ? И защо имената на параметрите не се вземат предвид при определяне на уникалността на даден метод?

Защо изобщо е необходима уникалност? Работата е там, че когато компилаторът компorра програма, той трябва да знае точно кой метод възнамерявате да извикате на дадено място.

Например, ако напишете , компилаторът е умен и лесно ще заключи, че възнамерявате да извикате метода тук с параметър.System.out.println("Hi")println()String

Но ако напишете , компилаторът ще види извикване на метода с параметър.System.out.println(1.0)println()double

Когато се извика метод, компилаторът гарантира, че типовете на аргументите съответстват на типовете на параметрите. Не обръща внимание на името на аргументите. В Java имената на параметрите не помагат на компилатора да определи кой метод да извика. И затова те не се вземат предвид при определяне уникалността на даден метод.

Името на метода и типовете на неговите параметри се наричат ​​сигнатура на метода . Например,sum(int, int)

Всеки клас трябва да има методи с уникални сигнатури, а не методи с уникални имена.