Java'daki yöntem parametreleri

"Merhaba Amigo! Umarım kendi yöntemlerinizi kullanarak görevleri çözmekten keyif almışsınızdır ve yöntemler oluşturmanın ne kadar kolay olduğunu fark etmişsinizdir. Şimdi en ilginç konudan bahsedelim."

"İlgimi çektin Diego... Yeni bir konu mu?"

System.out.println()"Her konu senin için yeni, genç robotum! Ve bu bir istisna değil. Yine de bu yöntemler hakkında. Muhtemelen, bu tür yöntemlerden , argümanları yöntemlere aktarabileceğimizi zaten fark etmişsindir. Yöntemin içine girdikten sonra , biz bunları parametreler olarak adlandırırız."

"Parantez içinde yazdığımız parametreler?"

"Evet, kesinlikle. Ve aslında, parametreler, yöntemler oluşturup kullanmaktan elde ettiğimiz faydaları büyük ölçüde artırır."

"Onları kullanmakla ilgili söylediklerini anlıyorum ve görünüşe göre bunu zaten yapmışım. Parametreli bir yöntemi nasıl ilan ederiz?"

"Aslında çok basit:

public static void name(parameters)
{
  method body
}

" nameYöntemin benzersiz adı nerededir ve method bodyyöntemi oluşturan komutları temsil eder. parametersYöntem parametreleri için virgülle ayrılmış bir yer tutucudur."

"Hmm... Sanırım anladım... Veya belki de..."

"Size bu şablon hakkında biraz daha ayrıntı vereyim, böylece anladığınızdan emin olabilirsiniz:

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

İşte bazı örnekler:

public static void print(String str)
{
}

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

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

"Ah... Şimdi anlaşıldı. Ve eğer yöntemin parametrelere sahip olmasını istemiyorsak parantezleri boş bırakıyoruz."

"Aynen öyle. Temel olarak parametreler, bir yöntem içindeki özel değişkenlerdir. Onların yardımıyla, yöntem çağrıldığında çeşitli değerleri iletebilirsiniz. Değerleri iletmeniz gerekmiyorsa parantezleri boş bırakın.

"Örneğin, belirli bir metin satırını belirli sayıda görüntüleyen bir yöntem yazalım. Bunun nasıl yapılacağı hakkında bir fikriniz var mı?"

"Pekala... Görünüşe göre bir diziyi ekranda birkaç kez görüntülemek için nasıl kod yazacağımın farkındayım..."

"Görüntülenecek dizeyi nasıl belirlersiniz? Ve görüntülenen satırların sayısını nasıl belirlersiniz? Tahmin edebiliyor musunuz?"

"Her şey netleşmeye başlıyor... Muhtemelen yöntem parametrelerinin yardımıyla mı?"

"Kesinlikle. Metin satırı için bir dizi parametresi ve görüntülenen satırların sayısı için bir sayısal parametre. 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.

Argümanlar

"Parametreleri olan yöntemleri çağırmaya özellikle dikkat etmenizi istiyorum. Yönteme iletilen değerler, yönteme iletildiğinde genellikle argüman olarak adlandırılır.

Örneğimize bir kez daha 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);
   }
}

" printLinesMetod ilk kez çağrıldığında, parametrelerine aşağıdaki değerler atanmıştır:

String text = "Hi", int count = 10.

" printLinesMetod ikinci kez çağrıldığında, parametrelerine farklı değerler verildi:

String text = "Bye", int count = 20.

"Parametreler, bir yöntem çağrıldığında belirli değerler atanan değişkenlerden ne eksik ne de fazla. , , ve değerlerinin "Hi"kendilerine "Bye"bağımsız 10değişken 20adı verilir."

"Farkı hatırlamaya çalışacağım ve bu kavramları karıştırmayacağım."

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

"Bir yöntemi çağırdığınızda değişkenleri bağımsız değişken olarak kullanabilirsiniz.

"Eh, bu mantıklı!"

"Mantıklı ama potansiyel olarak bazı zorluklara yol açabilir. Örneğimize bir kez daha geri dönelim, ancak bu sefer argümanları 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";
     String n = 10;
     printLines(str, n);
   }
}

"Hmm... Ben bir zorluk görmüyorum. Bir değişkenimiz var . Yöntem çağrıldığında parametreye strdeğeri atanıyor . Bir değişkenimiz var. Yöntem çağrıldığında değeri parametreye atanıyor ." "Şimdiye kadar her şey açık."textncount

"Güzel, güzel. Şimdi yöntemdeki 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";
     String 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öntemdeki 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. İki değişken arasında sihirli bir bağlantı yok text."

"Şimdi biliyorum."

Yöntemlere başvuruları iletmek

"Umarım argümanları yöntemlere dönüştürme konusunda sana söylediğim her şeyi özümsemişsindir. Bunu söylüyorum, çünkü şimdi bu konuyu biraz daha derinlemesine inceleyeceğiz. Dikkatlice dinle."

"Java'daki bazı değişkenlerin değerlerin kendilerini değil, bunun yerine bir referansı , yani değerlerin bulunduğu bellek bloğunun adresini sakladığını zaten biliyorsunuz. Dize değişkenleri ve dizi değişkenleri bu şekilde çalışır.

"Bir geliştirici bir dizi değişkenine başka bir dizi değişkeni atadığında ne olur?"

"Aynı adresi mi gösteriyorlar?"

"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 sum(int[] data)
   {
     int total = 0;
     for (int i = 0; i < data.length; i++)
       total = total + data[i];
     System.out.println(total);
   }
   
   public static void main(String[] args)
   {
     int[] months = {31, 28, 31, 30, 31, 30, 31, 31, 30};
     sum(months);
   }
}

"Tam olarak aynı şey olur: dataparametre, 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 sumyalnızca dizideki değerleri okumakla kalmaz, aynı zamanda onları değiştirebilir!"

"Sanırım anlıyorum ama daha fazla örneğe ihtiyacım var!"

"Örneğin, iki boyutlu bir diziyi aynı değerle dolduran kendi yöntemimizi yazabiliriz. Şu ş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);
   }
}

Aynı ada sahip yöntemler

"Şimdi bir kez daha yöntem adlarına dönelim."

"İsimler hakkında başka ne söylenebileceğini hayal bile edemiyorum!"

"Pekala, Java dili standardı, aynı sınıftaki tüm yöntemlerin benzersiz adlara sahip olmasını gerektirir.

"Yani, aynı sınıfta iki aynı adlı yöntemi bildirmek imkansız mı?"

"Şimdi - dikkat! Bir sınıftaki metotlar gerçekten de aynı isimlere sahip olabilir! Ama bu durumda farklı parametrelere sahip olmaları gerekir. Diğer bir deyişle, metotlar aynılık açısından karşılaştırılır, sadece isimler dikkate alınmaz, aynı zamanda metotlar da dikkate alınır . Parametrelerin türleri !Özellikle türler dediğime dikkat edin.Parametrelerin adları dikkate alınmaz.Ö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) {
}

"Kafam tamamen karıştı! Tüm bunlara neden ihtiyacımız var? Neden bazı yöntemler aynı iken diğerleri farklı kabul ediliyor? Ve bir yöntemin benzersizliği belirlenirken neden parametre adları dikkate alınmıyor? Tümü?"

"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 buradaki yöntemi bir parametre ile çağırmayı düşündüğünüzü kolayca anlayacaktır . Ancak yazarsanız , derleyici yönteme bir parametre ile çağrı yapıldığını görecektir. programcının yöntemi bildirirken parametreye verdiği isim."System.out.println("Hi")println()StringSystem.out.println(1.0)println()double

Ahh, geçmeye başlıyor gibi görünüyor!

"Bir metot çağrıldığında, derleyici argüman türlerinin parametrelerin tipleriyle eşleşmesini sağlar. Argümanların ismine hiç dikkat etmez. Java'da parametre isimleri, derleyicinin hangi yöntemi kullanacağını belirlemesine yardımcı olmaz. Derleyicinin değil, programcıların bunlara ihtiyacı vardır.

"Ve sanırım bu yüzden bir yöntemin benzersizliği belirlenirken dikkate alınmıyorlar?"

"Evet, bu tamamen doğru. Bir yöntemin adı ve parametre türleri, yöntem imzası olarak adlandırılır . Örneğin, sum (int, int)"

"Dolayısıyla, her sınıfın benzersiz adlara sahip yöntemlerden ziyade benzersiz imzalara sahip yöntemleri olmalıdır ."

"Aferin Amigo! Bu dersi mükemmel bir şekilde özetledin. Bir şey net değilse panik yapma. Bu konu birkaç görevden sonra netleşecek."