„Hallo Amigo! Ich hoffe, dass es dir Spaß gemacht hat, Aufgaben mit deinen eigenen Methoden zu lösen, und dass du merkst, wie bequem es ist, Methoden zu erstellen. Jetzt lass uns über das interessanteste Thema von allen sprechen.“

„Du hast mein Interesse geweckt, Diego... Ein neues Thema?“

„Jedes Thema ist neu für dich, mein junger Roboter! Und dieses ist keine Ausnahme. Allerdings geht es wieder um Methoden. Du hast wahrscheinlich schon bemerkt, dass wir bei solchen Methoden Argumente an Methoden übergeben können. Sobald wir uns in der Methode System.out.println()befinden , wir bezeichnen sie als Parameter.“

„Parameter sind das, was wir in Klammern schreiben?“

„Ja, genau. Und tatsächlich steigern Parameter die Vorteile, die wir aus der Erstellung und Verwendung von Methoden ziehen, erheblich.“

„Ich verstehe, was Sie über ihre Verwendung sagen, und es stellt sich heraus, dass ich es bereits getan habe. Wie deklarieren wir eine Methode mit Parametern?“

„Eigentlich ist es ganz einfach:

public static void name(parameters)
{
  method body
}

„Wo nameist der eindeutige Name der Methode und method bodystellt die Befehle dar, aus denen die Methode besteht. Und parametersist ein Platzhalter für die Methodenparameter, getrennt durch Kommas.“

„Hmm... ich glaube ich verstehe... oder vielleicht auch nicht...“

„Lassen Sie mich Ihnen einige weitere Details zu dieser Vorlage geben, damit Sie sicher sein können, dass Sie Folgendes verstehen:

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

Hier sind einige Beispiele:

Code Erläuterung 
public static void print(String str)
{
}
 Die printMethode wird mit einem Parameter deklariert:
String str		 
public static void print(String str, int count)
{
}
 Die printMethode wird mit zwei Parametern deklariert:
String str
int count		 
public static void write(int x, int y)
{
}
 Die writeMethode wird mit zwei Parametern deklariert:
int x
int y

„Ah... Jetzt ist es klar. Und wenn wir nicht wollen, dass die Methode Parameter hat, dann lassen wir die Klammern einfach leer.“

„Genau. Parameter sind im Grunde spezielle Variablen innerhalb einer Methode. Mit ihrer Hilfe können Sie der Methode beim Aufruf verschiedene Werte übergeben. Und wenn Sie keine Werte übergeben müssen, dann lassen Sie die Klammern leer.“

„Schreiben wir zum Beispiel eine Methode, die eine bestimmte Textzeile eine bestimmte Anzahl von Malen anzeigt. Haben Sie eine Idee, wie das geht?“

„Nun ... es scheint, dass ich mir gut darüber im Klaren bin, wie man Code schreibt, um eine Zeichenfolge mehrmals auf dem Bildschirm anzuzeigen ...“

„Wie legen Sie die anzuzeigende Zeichenfolge fest? Und wie legen Sie die Anzahl der angezeigten Zeilen fest? Können Sie es erraten?“

Java webinar

„Die Dinge werden langsam klarer... Wahrscheinlich mithilfe von Methodenparametern?“

„Genau. Ein String-Parameter für die Textzeile und ein numerischer Parameter für die Anzahl der angezeigten Zeilen. Der Code, der dies tut, würde so aussehen:

Code Erläuterung 
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);
   }
}
Wir haben die printLinesMethode mit den folgenden Parametern deklariert:
String text, int count

Die Methode zeigt String- text countZeiten an



. Wir rufen die printLinesMethode mit verschiedenen Parametern auf

„Jedes Mal, wenn eine Methode aufgerufen wird, werden ihren Parametern die übergebenen Werte zugewiesen, und erst dann beginnen wir mit der Ausführung der Befehle innerhalb der Methode.

Argumente

„Ich möchte, dass Sie dem Aufruf von Methoden mit Parametern besondere Aufmerksamkeit schenken. Die an die Methode übergebenen Werte werden normalerweise als Argumente bezeichnet , wenn sie an die Methode übergeben werden.

Schauen wir uns noch einmal unser Beispiel an:

Code Erläuterung 
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);
   }
}
Wir haben die printLinesMethode mit den folgenden Parametern deklariert:
String text, int count

Die Methode zeigt String- text countZeiten an.


Wir rufen die printLinesMethode mit den folgenden Argumenten auf:
text = "Hi"; count = 10;
text = "Bye"; count = 20;

„Beim printLinesersten Aufruf der Methode wurden ihren Parametern folgende Werte zugewiesen:

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

„Beim printLineszweiten Aufruf der Methode wurden ihren Parametern unterschiedliche Werte zugewiesen:

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

„Parameter sind nicht mehr und nicht weniger als Variablen, denen beim Aufruf einer Methode bestimmte Werte zugewiesen werden. Die Werte "Hi", "Bye", 10und 20werden selbst Argumente genannt.“

„Ich werde versuchen, mich an den Unterschied zu erinnern und diese Konzepte nicht zu verwechseln.“

Widersprüchliche Variablennamen beim Aufruf einer Methode

„Wenn Sie eine Methode aufrufen, können Sie Variablen als Argumente verwenden.

„Nun, das macht Sinn!“

„Es macht Sinn, kann aber möglicherweise zu einigen Schwierigkeiten führen. Kehren wir noch einmal zu unserem Beispiel zurück, aber dieses Mal verschieben wir die Argumente in separate Variablen:

Code Erläuterung 
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);
   }
}
Wir haben die printLinesMethode mit den folgenden Parametern deklariert:
String text, int count

Die Methode zeigt String- text countZeiten an.



Wir rufen die printLinesMethode mit den folgenden Argumenten auf:
text = str;
count = n;

„Hmm... ich sehe keine Schwierigkeiten. Wir haben eine strVariable. Ihr Wert wird dem Parameter zugewiesen, textwenn die Methode aufgerufen wird. Wir haben eine nVariable. Ihr Wert wird dem Parameter zugewiesen count, wenn die Methode aufgerufen wird.“ „Bisher ist alles klar.“

„Gut, gut. Jetzt benennen wir unsere Variablen in der mainMethode um:

Code Erläuterung 
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);
   }
}
Wir haben die printLinesMethode mit den folgenden Parametern deklariert:
String text, int count

Die Methode zeigt String- text countZeiten an.



Wir rufen die printLinesMethode mit den folgenden Argumenten auf:
text = text;
count = count;

„Achten Sie auf zwei Dinge

Erstens: Wir haben Variablen mit demselben Namen in verschiedenen Methoden. Dabei handelt es sich um unterschiedliche Variablen (wir stellen sie bewusst mit unterschiedlichen Farben dar). Alles funktioniert genauso wie im vorherigen Beispiel, wo die Variablen in der mainMethode benannt wurden strund n.

Zweitens: Beim Aufruf der Methode passiert nichts Magisches. Den Parametern werden einfach die Argumentwerte zugewiesen. Unabhängig davon, ob es sich um Zahlen, Zeichenfolgen, Variablen oder Ausdrücke handelt.

„Nachdem wir die Variablen in der Hauptmethode umbenannt haben, hat sich nichts geändert. Sie waren zuvor in verschiedenen Methoden unterschiedliche Variablentext und bleiben es auch. Es gibt keine magische Verbindung zwischen den beiden Variablen.“

"Jetzt weiß ich."

Übergabe von Referenzen auf Methoden

„Ich hoffe, Sie haben bereits alles aufgenommen, was ich Ihnen über die Übergabe von Argumenten an Methoden gesagt habe. Das sage ich, weil wir jetzt etwas tiefer in dieses Thema eintauchen. Hören Sie gut zu.“

„Sie wissen bereits, dass einige Variablen in Java nicht die Werte selbst, sondern eine Referenz speichern , also die Adresse des Speicherblocks, in dem sich die Werte befinden. So funktionieren String-Variablen und Array-Variablen.“

„Was passiert, wenn ein Entwickler einer Array-Variablen eine andere Array-Variable zuweist?“

„Zeigen sie dann auf die gleiche Adresse?“

„Richtig. Die beiden Variablen beginnen, auf denselben Speicherplatz im Speicher zu verweisen:

„Und was passiert, wenn eine dieser Variablen ein Methodenparameter ist?

Code Erläuterung 
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);
   }
}

Die sumMethode berechnet die Summe der Zahlen im übergebenen Array und zeigt sie auf dem Bildschirm an

„Genau das Gleiche passiert: Der dataParameter enthält einen Verweis auf denselben Speicherbereich wie die monthsVariable. Wenn die Methode aufgerufen wird, erfolgt eine einfache Zuweisung: .data = months

„Und da sich beide Variablen auf denselben Speicherbereich beziehen, in dem eine Ganzzahl gespeichert ist, sumkann die Methode Werte aus dem Array nicht nur lesen, sondern auch ändern!“

„Ich glaube, ich verstehe, aber ich brauche mehr Beispiele!“

„Nun, wir können zum Beispiel unsere eigene Methode schreiben, die ein zweidimensionales Array mit demselben Wert füllt. So könnte es aussehen:

Code Erläuterung 
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);
   }
}

Die fill Methode durchläuft jede Zelle im übergebenen zweidimensionalen Array und weist valuediese zu.






Wir erstellen ein zweidimensionales Array.
Wir füllen das gesamte Array mit der Zahl 8.

Methoden mit demselben Namen

„Jetzt kehren wir noch einmal zu den Methodennamen zurück.“

„Ich kann mir nicht vorstellen, was man sonst noch über Namen sagen könnte!“

„Nun, der Java-Sprachstandard verlangt, dass alle Methoden in derselben Klasse eindeutige Namen haben.

„Es ist also unmöglich, zwei gleichnamige Methoden in derselben Klasse zu deklarieren?“

„Jetzt – aufgepasst! Methoden in einer Klasse können tatsächlich identische Namen haben! In diesem Fall müssen sie jedoch unterschiedliche Parameter haben die Typen der Parameter ! Beachten Sie, dass ich ausdrücklich Typen gesagt habe. Die Namen der Parameter werden nicht berücksichtigt . Beispiele:

Code Erläuterung 
void fill(int[] data, int value) {
}
void fill(int[][] data, int value) {
}
void fill(int[][][] data, int value)  {
}
 Diese drei Methoden sind unterschiedliche Methoden. Sie können in derselben Klasse deklariert werden. 
void print(String str) {
}
void print(String str, String str2) {
}
void print(int val) {
}
void print(double val) {
}
void print() {
}
 Jede dieser fünf Methoden gilt als unterschiedlich . Sie können in derselben Klasse deklariert werden. 
void sum(int x, int y) {
}
void sum(int data, int value) {
}
 „Diese beiden Methoden gelten als gleich , das heißt, sie können nicht in derselben Klasse deklariert werden.“

„Ich bin völlig verwirrt! Warum brauchen wir das alles? Warum werden einige Methoden als gleich angesehen , während andere unterschiedlich sind ? Und warum werden Parameternamen bei der Bestimmung der Eindeutigkeit einer Methode nicht berücksichtigt? Warum ist Eindeutigkeit notwendig? alle?"

„Wenn der Compiler ein Programm kompiliert, muss er genau wissen, welche Methode Sie an einer bestimmten Stelle aufrufen möchten.

„Wenn Sie beispielsweise schreiben , ist der Compiler intelligent und wird leicht zu dem Schluss kommen, dass Sie beabsichtigen, die Methode hier mit einem Parameter aufzurufen . Wenn Sie jedoch schreiben , sieht der Compiler einen Aufruf der Methode mit einem Parameter. Er hat keine Ahnung. “ welchen Namen der Programmierer dem Parameter bei der Deklaration der Methode gegeben hat.“System.out.println("Hi")println()StringSystem.out.println(1.0)println()double

Ahh, es scheint langsam durchzukommen!

„Wenn eine Methode aufgerufen wird, stellt der Compiler sicher, dass die Typen der Argumente mit den Typen der Parameter übereinstimmen. Er achtet nicht auf den Namen der Argumente. In Java helfen Parameternamen dem Compiler nicht dabei, zu bestimmen, welche Methode verwendet werden soll Aufruf. Programmierer brauchen sie, nicht den Compiler.

„Und ich vermute, dass sie deshalb bei der Bestimmung der Einzigartigkeit einer Methode nicht berücksichtigt werden?“

„Ja, das ist völlig richtig. Der Name einer Methode und die Typen ihrer Parameter werden als Methodensignatur bezeichnet . Beispiel: sum (int, int)„

„Daher muss jede Klasse Methoden mit eindeutigen Signaturen haben und nicht Methoden mit eindeutigen Namen.“

„Gut gemacht, Amigo! Du hast diese Lektion perfekt zusammengefasst. Wenn etwas unklar bleibt, geraten Sie nicht in Panik. Dieses Thema wird nach ein paar Aufgaben klar sein.“