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 Dog
Klasse 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. AlleDog
Methoden 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, Dog
ist der Zugriff auf die Methoden der Klasse in der Main
Klasse 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 derDog
Methoden 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 Dog
Objekt, um die statische main()
Methode im auszuführenDog
Klasse. 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 desgetName()
Getters deutlich:
public String getName() {
return name;
}
Es gibt ein String
Objekt 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-each
Schleife (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 Person
der 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,null
ist es ein Schlüsselwort in Java. Es ist sehr wichtig zu verstehen, dass null
es sich weder um ein Objekt noch um einen Datentyp handelt . Stellen Sie sich vor, wir hätten eine Person
Klasse 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 null
als 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 String
als zweitem Argument und eine mit an Integer
als zweitem Argument. Aber a String
und an Integer
können beides sein null
! Da es sich um Referenztypen handelt, null
ist 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. Null
kann 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.
Mehr Lektüre: |
---|
GO TO FULL VERSION