Methodendeklaration

Hallo! Sie wissen bereits, wie Sie eigene Klassen mit Feldern und Methoden erstellen. Jetzt konzentrieren wir uns auf die Methoden. Natürlich haben wir das in unserem Unterricht schon öfter gemacht, aber wir haben uns hauptsächlich mit allgemeinen Themen beschäftigt. Heute werden wir Methoden analysieren und untersuchen, woraus sie bestehen, welche verschiedenen Möglichkeiten es gibt, sie zu erstellen und wie man mit all dem umgeht. :) Lass uns gehen!

Methodendeklaration

Der gesamte Code, der eine Methode definiert, wird als Methodendeklaration bezeichnet . Die allgemeine Form einer Methodendeklaration kann wie folgt beschrieben werden:

access modifier, return type, method name (parameter list) {
    // method body
}

Schauen Sie sich als Beispiele die Deklarationen der verschiedenen Methoden der DogKlasse an.

public class Dog {

   String name;

   public Dog(String name) {
       this.name = name;
   }

   public static void main(String[] args) {
       Dog max = new Dog("Max");
       max.woof();

   }

   public void woof() {
       System.out.println("A dog named " + name + " says \"Woof, woof!\"");
   }

   public void run(int distanceInFeet) {
       System.out.println("A dog named " + name + " ran " + distanceInFeet + " feet!");
   }

   public String getName() {
       return name;
   }
}

1. Zugriffsmodifikator

Der Zugriffsmodifikator wird immer zuerst angegeben. Alle DogMethoden der Klasse sind mit dem Modifikator public gekennzeichnet . Das bedeutet, dass wir sie aus jeder anderen Klasse aufrufen können:

public class Main {

   public static void main(String[] args) {

       Dog butch = new Dog("Butch");
       butch.run(100);
   }

}

Wie Sie sehen, Dogist der Zugriff auf die Methoden der Klasse in der MainKlasse einfach. Dies ist aufgrund des öffentlichen Modifikators möglich. In Java gibt es andere Modifikatoren. Sie erlauben nicht alle die Verwendung von Methoden in anderen Klassen. Wir werden in anderen Lektionen darüber sprechen. Das Wichtigste ist, wofür der Modifikator verantwortlich ist: ob eine Methode in anderen Klassen zugänglich ist :)

2. statisches Schlüsselwort

Eine der DogMethoden main()ist mit dem Schlüsselwort static gekennzeichnet . Es ist auch Teil der Methodendeklaration und wir kennen seine Bedeutung bereits. Wir haben es in der Methodendeklarationsvorlage zu Beginn der Lektion nicht erwähnt, da es optional ist. Wenn es angegeben ist, muss es nach dem Zugriffsmodifikator stehen. Erinnern Sie sich, dass wir in den letzten Lektionen über statische (Klassen-)Variablen gesprochen haben? Bei der Anwendung auf Methoden hat dieses Schlüsselwort ungefähr die gleiche Bedeutung. Wenn eine Methode statisch ist , kann sie ohne Verweis auf ein bestimmtes Objekt der Klasse verwendet werden. Und tatsächlich benötigen Sie kein DogObjekt, um die statische main()Methode im auszuführenDogKlasse. Ohne läuft es einwandfrei. Wenn diese Methode nicht statisch wäre, müssten wir zunächst ein Objekt erstellen, um sie auszuführen.

3. Rückgabewert

Wenn unsere Methode etwas zurückgeben soll, dann geben wir den Typ des Rückgabewerts an. Dies wird am Beispiel des getName()Getters deutlich:

public String getName() {
   return name;
}

Es gibt ein StringObjekt zurück. Wenn eine Methode nichts zurückgibt, wird stattdessen das Schlüsselwort void verwendet, wie in der woof()Methode:

public void woof() {
   System.out.println("A dog named " + name + " says \"Woof, woof!\"");
}

Methoden mit demselben Namen

Es gibt Situationen, in denen wir mehrere unterschiedliche Möglichkeiten zum Aufrufen einer Methode benötigen. Warum nicht unsere eigene künstliche Intelligenz erschaffen? Amazon hat Alexa, Apple hat Siri, warum sollten wir also keine haben? :) Im Film Iron Man erschafft Tony Stark seine eigene unglaubliche künstliche Intelligenz, Jarvis. Lasst uns diesem großartigen Charakter Tribut zollen und unserer KI zu seinen Ehren einen Namen geben. :) Das erste, was wir tun müssen, ist, Jarvis beizubringen, die Leute zu begrüßen, die den Raum betreten (es wäre seltsam, wenn sich ein so erstaunlicher Intellekt als unhöflich erweisen würde).

public class Jarvis {

   public void sayHi(String name) {
       System.out.println("Good evening, " + name + ". How are you?");
   }

   public static void main(String[] args) {
       Jarvis jarvis = new Jarvis();
       jarvis.sayHi("Tony Stark");
   }
}

Konsolenausgabe: Guten Abend, Tony Stark. Wie geht es dir? Sehr gut! Jarvis kann nun Gäste begrüßen. Natürlich häufiger als sein Meister, Tony Stark. Aber was ist, wenn er nicht alleine kommt! Unsere sayHi()Methode akzeptiert jedoch nur ein Argument. Daher kann es nur eine Person begrüßen, die den Raum betritt, und ignoriert die andere Person. Nicht sehr höflich, stimmst du zu? :/ In diesem Fall können wir das Problem lösen, indem wir einfach zwei Methoden mit demselben Namen, aber unterschiedlichen Parametern schreiben:

public class Jarvis {

   public void sayHi(String firstGuest) {
       System.out.println("Good evening, " + firstGuest + ". How are you?");
   }

   public void sayHi(String firstGuest, String secondGuest) {
       System.out.println("Good evening, " + firstGuest + " and " + secondGuest + ". How are you?");
   }

}

Dies wird als Methodenüberladung bezeichnet . Durch die Überladung von Methoden ist unser Programm flexibler und ermöglicht die Anpassung an verschiedene Arbeitsweisen. Sehen wir uns an, wie es funktioniert:

public class Jarvis {

   public void sayHi(String firstGuest) {
       System.out.println("Good evening, " + firstGuest + ". How are you?");
   }

   public void sayHi(String firstGuest, String secondGuest) {
       System.out.println("Good evening, " + firstGuest + " and " + secondGuest + ". How are you?");
   }

   public static void main(String[] args) {
       Jarvis jarvis = new Jarvis();
       jarvis.sayHi("Tony Stark");
       jarvis.sayHi("Tony Stark", "Captain America");
   }
}

Konsolenausgabe: Guten Abend, Tony Stark. Wie geht es dir? Guten Abend, Tony Stark und Captain America. Wie geht es dir? Hervorragend, beide Versionen haben funktioniert. :) Aber wir haben das Problem nicht gelöst! Was ist, wenn drei Gäste anwesend sind? Wir könnten die Methode natürlich sayHi()noch einmal überladen, sodass sie drei Gastnamen akzeptiert. Aber es könnten auch 4 oder 5 sein. Bis ins Unendliche. Gibt es nicht eine bessere Möglichkeit, Jarvis beizubringen, mit einer beliebigen Anzahl von Namen umzugehen, ohne die sayHi()Methode millionenfach zu überlasten ()? :/ Natürlich gibt es das! Wenn das nicht der Fall wäre, glauben Sie, dass Java die beliebteste Programmiersprache der Welt wäre? ;)

public class Jarvis {

   public void sayHi(String...names) {

       for (String name: names) {
           System.out.println("Good evening, " + name + ". How are you?");
       }
   }

   public static void main(String[] args) {
       Jarvis jarvis = new Jarvis();
       jarvis.sayHi("Tony Stark");
       System.out.println();
       jarvis.sayHi("Tony Stark", "Captain America");
   }
}

Wenn ( String... Namen ) als Parameter verwendet wird, bedeutet dies, dass eine Sammlung von Strings an die Methode übergeben wird. Wir müssen nicht im Voraus angeben, wie viele es sein werden, daher ist unsere Methode jetzt viel flexibler:

public class Jarvis {

   public void sayHi(String...names) {

       for (String name: names) {
           System.out.println("Good evening, " + name + ". How are you?");
       }
   }

   public static void main(String[] args) {
       Jarvis jarvis = new Jarvis();
       jarvis.sayHi("Tony Stark", "Captain America", "Black Widow", "Hulk");
   }
}

Konsolenausgabe: Guten Abend, Tony Stark. Wie geht es dir? Guten Abend, Captain America. Wie geht es dir? Guten Abend, Black Widow. Wie geht es dir? Guten Abend, Hulk. Wie geht es dir? Innerhalb der Methode durchlaufen wir alle Argumente und zeigen mit Namen formatierte Phrasen an. Hier verwenden wir eine vereinfachte for-eachSchleife (die Sie bereits gesehen haben). Hier ist es perfekt, denn die ( String...-Namen )-Notation bedeutet tatsächlich, dass der Compiler alle übergebenen Argumente in ein Array einfügt. Dadurch können wir mit Variablennamen arbeitenso wie wir mit einem Array arbeiten würden, auch indem wir es in einer Schleife durchlaufen. Außerdem funktioniert es mit einer beliebigen Anzahl übergebener Zeichenfolgen! Zwei, zehn, sogar tausend – die Methode funktioniert bei beliebig vielen Gästen. Viel bequemer, als die Methode mit all den Möglichkeiten zu überladen, finden Sie nicht? :) Hier ist ein weiteres Beispiel für Methodenüberladung. Geben wir Jarvis eine printInfoFromDatabase()Methode. Es werden Informationen über eine Person aus einer Datenbank angezeigt. Wenn aus der Datenbank hervorgeht, dass es sich bei einer Person um einen Superhelden oder Superschurken handelt, zeigen wir diese Informationen an:

public class Jarvis {

   public void printInfoFromDatabase (String bio) {

       System.out.println(bio);
   }

   public void printInfoFromDatabase(String bio, boolean isEvil, String nickname) {

       System.out.println(bio);
       if (!isEvil) {
           System.out.println("Also known as the superhero " + nickname);
       } else {
           System.out.println("Also known as the supervillain " + nickname);
       }
   }

   public static void main(String[] args) {
       Jarvis jarvis = new Jarvis();
       jarvis.printInfoFromDatabase("Laura Palmer. Date of birth: July 22, 1972. Twin Peaks, Washington");
       System.out.println();
       jarvis.printInfoFromDatabase("Max Eisenhardt. Height: 15.6 ft. Weight: 189 lbs. ", true, "Magneto");
   }
}

Ausgabe: Laura Palmer. Geburtsdatum: 22. Juli 1972. Twin Peaks, Washington Max Eisenhardt. Höhe: 15,6 Fuß. Gewicht: 189 Pfund. Auch als Superschurke Magneto bekannt . Das Verhalten unserer Methode hängt also von den Daten ab, die wir an sie übergeben. Hier noch ein wichtiger Punkt: Auf die Reihenfolge der Argumente kommt es an! Nehmen wir an, unsere Methode benötigt einen String und eine Zahl:

public class Person {

   public static void sayYourAge(String greeting, int age) {
       System.out.println(greeting + " " + age);
   }

   public static void main(String[] args) {

       sayYourAge("My age is ", 33);
       sayYourAge(33, "My age is "); // Error!
   }
}

Wenn die Methode Personder Klasse sayYourAge()einen String und eine Zahl als Eingabe akzeptiert, müssen diese Argumente in dieser Reihenfolge an die Methode übergeben werden! Wenn wir sie in einer anderen Reihenfolge übergeben, generiert der Compiler einen Fehler und die Person kann ihr Alter nicht sagen. Übrigens sind auch Konstruktoren, die wir in der letzten Lektion behandelt haben, Methoden! Sie können sie auch überladen (dh mehrere Konstruktoren mit unterschiedlichen Parametersätzen erstellen) und die Reihenfolge der übergebenen Argumente ist auch für sie von grundlegender Bedeutung. Das sind echte Methoden! :) :)

So rufen Sie Methoden mit ähnlichen Parametern auf

Wie Sie wissen, nullist es ein Schlüsselwort in Java. Es ist sehr wichtig zu verstehen, dass nulles sich weder um ein Objekt noch um einen Datentyp handelt . Stellen Sie sich vor, wir hätten eine PersonKlasse und eine introduce()Methode, die den Namen und das Alter der Person ankündigt. Darüber hinaus kann das Alter als Text oder Zahl übergeben werden.

public class Person {

   public void introduce(String name, String age) {
       System.out.println("My name is " + name + ". My age is " + age);
   }

   public void introduce(String name, Integer age) {
       System.out.println("My name is " + name + ". My age is " + age);
   }

   public static void main(String[] args) {

       Person alex = new Person();
       alex.introduce ("Alex", "twenty-one");

       Person mary = new Person();
       mary.introduce("Mary", 32);
   }
}

Wir sind bereits mit Überladung vertraut und wissen daher, dass sich beide Methoden wie erwartet verhalten: Mein Name ist Alex. Ich bin einundzwanzig Jahre alt. Mein Name ist Mary. Ich bin 32 Jahre alt. Aber was passiert, wenn wir nullals zweiten Parameter anstelle einer Zeichenfolge oder einer Zahl übergeben?

public static void main(String[] args) {

   Person victor = new Person();
   victor.introduce("Victor", null);// Ambiguous method call!
}

Wir erhalten einen Kompilierungsfehler! Was verursacht das und was genau ist die „Mehrdeutigkeit“? Eigentlich ist alles ganz einfach. Das Problem besteht darin, dass wir zwei Versionen der Methode haben: eine mit a Stringals zweitem Argument und eine mit an Integerals zweitem Argument. Aber a Stringund an Integerkönnen beides sein null! Da es sich um Referenztypen handelt, nullist für beide der Standardwert. Deshalb kann der Compiler in dieser Situation nicht herausfinden, welche Version der Methode er aufrufen soll. Die Lösung für dieses Problem ist ganz einfach. Nullkann explizit in einen bestimmten Referenztyp konvertiert werden. Wenn Sie also eine Methode aufrufen, können Sie in Klammern den gewünschten Datentyp für das zweite Argument angeben! Der Compiler wird Ihren „Hinweis“ verstehen und die richtige Methode aufrufen:

public class Person {

   public void introduce(String name, String age) {
       System.out.println("Method with two strings!");
       System.out.println("My name is " + name + ". My age is " + age);
   }

   public void introduce(String name, Integer age) {
       System.out.println("Method with a string and a number!");
       System.out.println("My name is " + name + ". My age is " + age);
   }

   public static void main(String[] args) {

       Person victor = new Person();
       victor.introduce("Victor", (String) null);
   }
}

Ausgabe: Methode mit zwei Strings! Mein Name ist Victor. Mein Alter ist null.int Beachten Sie, dass ein solcher Fehler nicht aufgetreten wäre, wenn der Parameter „number“ ein primitiver Parameter und nicht eine Instanz des Integer-Referenztyps gewesen wäre .

public class Person {

   public void introduce(String name, String age) {
       System.out.println("Method with two strings!");
       System.out.println("My name is " + name + ". My age is " + age);
   }

   public void introduce(String name, int age) {
       System.out.println("Method with a string and a number!!");
       System.out.println("My name is " + name + ". My age is " + age);
   }

   public static void main(String[] args) {

       Person victor = new Person();
       victor.introduce("Victor", null);
   }
}

Kannst du erraten warum? Wenn Sie erraten haben, warum: Gut gemacht! :) Weil Grundelemente nicht sein können null. Jetzt hat der Compiler nur noch eine Wahl, nämlich die Methode mit zwei Strings aufzurufen introduce(). Dies ist die Version der Methode, die bei jedem Aufruf der Methode ausgeführt wird.