Funktionsparameter in Java

1. Argumente weitergeben

Und jetzt beginnt der Spaß. Sie wissen wahrscheinlich bereits von solchen Methoden System.out.println(), dass wir Argumente an Methoden übergeben können. Sobald wir uns in der Methode befinden, bezeichnen wir sie als Parameter. Tatsächlich steigern Parameter die Vorteile, die wir aus der Erstellung und Verwendung von Methoden ziehen, erheblich.

Wie deklarieren wir eine Methode mit Parametern? Eigentlich ist es ganz einfach:

public static void name(parameters)
{
  method body
}

Wo name ist der eindeutige Name der Methode und method body stellt die Befehle dar, aus denen die Methode besteht? Und parameters ist ein durch Kommas getrennter Platzhalter für die Methodenparameter. Beschreiben wir diese Vorlage genauer:

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

Beispiele:

public static void print(String str)
{
}

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

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

Wenn wir nicht möchten, dass die Methode Parameter hat, lassen wir die Klammern einfach leer.

Parameter sind spezielle Variablen innerhalb einer Methode. Mit ihrer Hilfe können Sie der Methode beim Aufruf verschiedene Werte übergeben.

Schreiben wir beispielsweise eine Methode, die eine Textzeichenfolge eine bestimmte Anzahl von Malen anzeigt.

Sie wissen bereits, wie man Code schreibt, um eine Zeichenfolge mehrmals auf dem Bildschirm anzuzeigen. Aber welche Zeichenfolge soll gedruckt werden? Und wie oft? Dafür brauchen wir die Parameter.

Der Code, der dies tut, würde so aussehen:

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

Bei jedem Aufruf einer Methode werden deren Parameter die übergebenen Werte zugewiesen und erst dann beginnen wir mit der Ausführung der Befehle innerhalb der Methode.

2. Argumente

Ich möchte Ihre Aufmerksamkeit etwas mehr auf den Aufruf einer Methode mit Parametern lenken.

Die an die Methode übergebenen Werte werden normalerweise als Argumente bezeichnet, wenn sie an die Methode übergeben werden.

Schauen wir uns ein weiteres Beispiel an:

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

printLines Beim ersten 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 als Argumente bezeichnet.“

3. Widersprüchliche Variablennamen beim Aufruf einer Methode

Variablen können als Methodenargumente verwendet werden. Das ist einfach und verständlich, kann aber möglicherweise zu Schwierigkeiten führen. Kehren wir zu demselben Beispiel zurück, aber dieses Mal verschieben wir die Argumente in separate Variablen:

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

So weit, so gut: Wir haben eine strVariable. Sein Wert wird dem textParameter beim Aufruf der Methode zugewiesen. Wir haben eine nVariable. Sein Wert wird dem countParameter beim Aufruf der Methode zugewiesen.“ Bisher ist alles klar.

Jetzt benennen wir unsere Variablen in der mainMethode um:

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

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. Früher handelte es sich bei verschiedenen Methoden um unterschiedliche Variablen , und so bleiben sie auch weiterhin. Es gibt keine magische Verbindung zwischen den text und text -Variablen.

4. Übergabe von Referenzen an Methoden

Ich hoffe, Sie haben alles aus der vorherigen Lektion verstanden, denn jetzt werden wir uns noch einmal mit der Übergabe von Argumenten an Methoden befassen, nur werden wir tiefer eintauchen.

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

Was passiert, wenn Sie einer Array-Variablen eine andere Array-Variable zuweisen? Das ist richtig. Die beiden Variablen beginnen, auf denselben Speicherplatz im Speicher zu verweisen:

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

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

Es passiert genau das Gleiche: Der data Parameter enthält einen Verweis auf denselben Speicherbereich wie die monthsVariable. Beim Aufruf der Methode erfolgt eine einfache Zuweisung: .data = months

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

Wir können beispielsweise unsere eigene Methode schreiben, die ein zweidimensionales Array mit demselben Wert füllt. So könnte es aussehen:

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. Methoden mit demselben Namen

Kommen wir nun noch einmal zu den Methodennamen zurück.

Java-Standards verlangen, dass alle Methoden in derselben Klasse eindeutige Namen haben. Mit anderen Worten: Es ist unmöglich, zwei Methoden mit identischem Namen in derselben Klasse zu deklarieren.

Beim Vergleich von Methoden auf Gleichheit werden nicht nur die Namen berücksichtigt, sondern auch die Typen der Parameter ! Beachten Sie, dass die Namen der Parameter nicht berücksichtigt werden . Beispiele:

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

Warum gelten einige Methoden als gleich , während andere unterschiedlich sind ? Und warum werden Parameternamen bei der Bestimmung der Eindeutigkeit einer Methode nicht berücksichtigt?

Warum ist Einzigartigkeit überhaupt notwendig? 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 .System.out.println("Hi")println()String

Wenn Sie jedoch schreiben , sieht der Compiler einen Aufruf der Methode mit einem Parameter.System.out.println(1.0)println()double

Beim Aufruf einer Methode stellt der Compiler sicher, dass die Typen der Argumente mit den Typen der Parameter übereinstimmen. Auf die Namen der Argumente wird keine Rücksicht genommen. In Java helfen Parameternamen dem Compiler nicht dabei, zu bestimmen, welche Methode aufgerufen werden soll. Und deshalb werden sie bei der Bestimmung der Einzigartigkeit einer Methode nicht berücksichtigt.

Der Name einer Methode und die Typen ihrer Parameter werden als Methodensignatur bezeichnet . Zum Beispiel,sum(int, int)

Jede Klasse muss über Methoden mit eindeutigen Signaturen und nicht über Methoden mit eindeutigen Namen verfügen.