Java'daki yöntem parametreleri

1. Argümanları iletmek

Ve şimdi eğlence başlıyor. Muhtemelen bunun gibi yöntemlerden System.out.println()argümanları yöntemlere aktarabileceğimizi zaten biliyorsunuzdur. Metodun içine girdikten sonra, bunlara parametre diyoruz. Aslında parametreler, metot oluşturmaktan ve kullanmaktan elde ettiğimiz faydaları büyük ölçüde artırır.

Bir yöntemi parametrelerle nasıl bildiririz? Aslında oldukça basit:

public static void name(parameters)
{
  method body
}

name Yöntemin benzersiz adı nerededir ve yöntemi method body oluşturan komutları temsil eder. Ve parameters , yöntem parametreleri için virgülle ayrılmış bir yer tutucudur. Bu şablonu daha ayrıntılı olarak açıklayalım:

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

Örnekler:

public static void print(String str)
{
}

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

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

Metodun parametrelere sahip olmasını istemiyorsak parantezleri boş bırakıyoruz.

Parametreler, bir yöntem içindeki özel değişkenlerdir. Onların yardımıyla, çağrıldığında yönteme çeşitli değerler iletebilirsiniz.

Örneğin, bir metin dizisini belirli sayıda görüntüleyen bir yöntem yazalım.

Bir diziyi ekranda birkaç kez görüntülemek için nasıl kod yazılacağını zaten biliyorsunuz. Ancak hangi diziyi yazdırmalısınız? Ve kaç kez? Bunun için parametrelere ihtiyacımız var.

Bunu yapan kod şöyle görünür:

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("Hi", 10);
     printLines("Bye", 20);
   }
}

Bir yöntem her çağrıldığında, parametrelerine iletilen değerler atanır ve ancak o zaman yöntemin içindeki komutları yürütmeye başlarız.

2. Argümanlar

Parametreli bir metod çağırmaya biraz daha dikkatinizi çekmek istiyorum.

Yönteme iletilen değerler, yönteme iletildiğinde genellikle bağımsız değişken olarak adlandırılır.

Başka bir örneğe bakalım:

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("Hi", 10);
     printLines("Bye", 20);
   }
}

Yöntem printLines ilk kez çağrıldığında, parametrelerine aşağıdaki değerler atanmıştır:
String text = "Hi", int count = 10.

Yöntem printLinesikinci kez çağrıldığında, parametrelerine farklı değerler atandı:
String text = "Bye", int count = 20.

Parametreler, bir yöntem çağrıldığında belirli değerler atanan değişkenlerden daha fazla veya daha az değildir. "Hi", "Bye", 10ve değerlerinin 20kendilerine argüman denir."

3. Bir yöntem çağrılırken değişken adlarının çakışması

Değişkenler yöntem bağımsız değişkenleri olarak kullanılabilir. Bu basit ve anlaşılır, ancak potansiyel olarak bazı zorluklara neden olabilir. Aynı örneğe geri dönelim, ancak bu sefer bağımsız değişkenleri ayrı değişkenlere taşıyacağız:

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);
   }
}

Şimdiye kadar, çok iyi: bir değişkenimiz var str. textYöntem çağrıldığında değeri parametreye atanır . Bir değişkenimiz var n. countYöntem çağrıldığında değeri parametreye atanır ." Buraya kadar her şey açık.

Şimdi metoddaki değişkenlerimizi yeniden adlandıralım 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);
   }
}

İki şeye dikkat edin

Birincisi: Farklı metotlarda aynı ada sahip değişkenlerimiz var. Bunlar farklı değişkenlerdir (kasıtlı olarak farklı renkler kullanarak tasvir ediyoruz). Her şey, yöntemdeki değişkenlerin ve olarak mainadlandırıldığı önceki örnekteki gibi çalışır .strn

İkincisi: Yöntem çağrıldığında sihirli hiçbir şey olmaz. Parametrelere basitçe bağımsız değişken değerleri atanır. Sayılar, dizeler, değişkenler veya ifadeler olmalarından bağımsız olarak.

Ana yöntemde değişkenleri yeniden adlandırdıktan sonra hiçbir şey değişmedi. Daha önce farklı yöntemlerde farklı değişkenlerdi ve öyle kalıyorlar. text ve değişkenleri arasında sihirli bir bağlantı yoktur text .

4. Yöntemlere referansları iletmek

Umarım önceki dersteki her şeyi anlamışsınızdır, çünkü şimdi argümanları yöntemlere geçirme konusunu yeniden ele alacağız, sadece daha derine ineceğiz.

Bildiğiniz gibi, bazı Java değişkenleri değerlerin kendilerini değil, bunun yerine bir referansı, yani değerlerin bulunduğu bellek bloğunun adresini saklar. Dize değişkenleri ve dizi değişkenleri bu şekilde çalışır.

Bir dizi değişkenine başka bir dizi değişkeni atadığınızda ne olur? Bu doğru. İki değişken, bellekte aynı alanı ifade etmeye başlar:

Ve bu değişkenlerden biri bir yöntem parametresiyse ne olur?

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);
   }
}

Tam olarak aynı şey olur: data parametre, değişkenle aynı bellek alanına bir referans içerecektir months. Yöntem çağrıldığında basit bir atama gerçekleşir: .data = months

Ve her iki değişken de bir tamsayı depolayan aynı bellek alanına atıfta bulunduğundan, yöntem printArraySum yalnızca dizideki değerleri okumakla kalmaz, aynı zamanda onları değiştirebilir!

Örneğin, iki boyutlu bir diziyi aynı değerle dolduran kendi yöntemimizi yazabiliriz. Bu şekilde görünebilir:

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. Aynı ada sahip yöntemler

Şimdi tekrar metod isimlerine dönelim.

Java standartları, aynı sınıftaki tüm yöntemlerin benzersiz adlara sahip olmasını gerektirir. Başka bir deyişle, aynı sınıfta iki aynı adlı yöntemi bildirmek imkansızdır.

Yöntemler aynılık açısından karşılaştırıldığında, yalnızca adlar dikkate alınmaz, aynı zamanda parametrelerin türleri de dikkate alınır ! Parametre adlarının dikkate alınmadığına dikkat edin . Örnekler:

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) {
}

Neden bazı yöntemler aynı kabul edilirken diğerleri farklıdır ? Ve bir yöntemin benzersizliği belirlenirken parametre adları neden dikkate alınmaz?

Benzersizlik neden gerekli? Mesele şu ki, derleyici bir programı derlerken, herhangi bir yerde tam olarak hangi yöntemi çağırmayı planladığınızı bilmelidir.

Örneğin, yazarsanız , derleyici akıllıdır ve yöntemi burada bir parametre ile çağırmayı düşündüğünüz sonucuna kolayca varacaktır .System.out.println("Hi")println()String

Ancak yazarsanız , derleyici parametreli bir yöntem çağrısı görecektir .System.out.println(1.0)println()double

Bir metot çağrıldığında, derleyici argüman tiplerinin parametre tipleriyle eşleşmesini sağlar. Argümanların adına hiç dikkat etmez. Java'da parametre adları, derleyicinin hangi yöntemi çağıracağını belirlemesine yardımcı olmaz. Bu nedenle, bir yöntemin benzersizliği belirlenirken dikkate alınmazlar.

Bir yöntemin adı ve parametrelerinin türleri, yöntem imzası olarak adlandırılır . Örneğin,sum(int, int)

Her sınıf , benzersiz adlara sahip yöntemler yerine benzersiz imzalara sahip yöntemlere sahip olmalıdır .