Name der öffentlichen statischen Rückgabewertmethode(Argument Datentyp Variablenname){
Was passiert, wenn eine Methode aufgerufen wird?
}
(Beispiel)
public static void maiu(String[] args){
System.out.println("Rufen Sie die Methode auf");
method();
System.out.println("Der Methodenaufruf ist abgeschlossen!");
}
(Beispiel)
public static void main(String[] args){
hello("A");
hello("B");
hello("C");
}
public static void hello(String name){
System.out.println("Hallo"+name+"Herr.");
}
(Ausgabeergebnis)
Hallo A's
Hallo Herr B.
Hallo C's
(Beispiel)
public class li5_5 {
public static void main(String[] args){
add("Hallo","Herr A.");
add("Guten Abend","Herr B.");
}
public static void add(String x,String y) {
System.out.println(x+y);
}
}
(Ausgabeergebnis)
Hallo A's
Guten Abend B.
"Hallo", "A", "Guten Abend", "B" ist, um dem tatsächlichen Wert des Übergabewerts zu entsprechen.
Formales Argument, weil String x, String y den Wert erhalten hat.
Verwendung des Rückgabewerts
(Rückgabe des Rückgabewerts)
public static Rückgabetyp Methodenname(Streit){
Was passiert, wenn eine Methode aufgerufen wird?
return Rückgabewert;
}
Rückgabetyp void bedeutet keine Rückgabe
(So rufen Sie den Methodennamen auf und erhalten den Rückgabewert)
`Typ Variablenname = Methodenname (Argumentliste)`
(Beispiel) * Ignorieren Sie den Mangel an Sinn für Wortwahl
public class li5_7 {
public static String Hello(String x,String y) {
String aisatsu = x + y;
return aisatsu;
}
public static void main(String[] args) {
String aisatsu = Hello("Guten Morgen","Yo");
System.out.println(aisatsu);
}
}
(Ausgabeergebnis)
```
Guten Morgen
```
Verwenden Sie den Rückgabewert direkt
(Idee)
Im obigen Beispiel nach dem einmaligen Empfang des Werts als Variable mit String aisatsu = Hello ("Oha", "Yo"); in der Hauptmethode System.out Sie verwenden den Rückgabewert in .println (aisatsu); .
Der folgende Code empfängt nicht in der Variablen der Hauptmethode, sondern verwendet den direkten Rückgabewert in der Anweisung.
(Beispiel) * Bitte lassen Sie mich wissen, ob es ein anderes modisches Beispiel als guten Morgen gibt
public class li5_8 {
public static String add(String x,String y) {
String ans = x + y;
return ans;
}
public static void main(String[] args) {
System.out.println(add(add("Oh","Ist"),add("Yo","U.")));
}
}
(Ergänzung)
In add (add ("o", "is"), add ("yo", "u") wird das erste add ("o", "is")) Sie können "Guten Morgen" mit und "Sie" mit dem nächsten hinzufügen ("yo", "u") . Ich kann.
Sie können "Guten Morgen" mit dem am Ende zusammengefassten Add.
(Ausgabeergebnis)
```
Guten Morgen
```
# Hinweise zur return-Anweisung
(Idee)
return beendet die Methode
(Beispiel)
public class li5_8 {
public static String add(String x,String y) {
String ans = x + y;
return ans;
System.out.println(ans);
}
}
(Ergänzung)
System.out.println (ans); führt zu einem Kompilierungsfehler
Methodenüberladung
(Idee)
Es kann nur eine Methode mit demselben Namen verwendet werden. Es gibt jedoch Fälle, in denen mehrere Methoden ähnlicher Verarbeitung verwendet werden.
In einem solchen Fall können Sie mehrere Methoden mit demselben Namen verwenden, indem Sie den Datentyp des Arguments oder die Anzahl der Daten des Arguments ändern.
(Beispiel ~ Beim Ändern des Datentyps des Arguments ~)
public static int add(int x,int y) {
return x + y ;
}
public static double add(double x, double y) {
return x + y ;
}
public static String add(String x, String y) {
return x + y ;
}
public static void main(String[] args) {
System.out.println(add(10,20));
System.out.println(add(3.5,2.7));
System.out.println(add("Hellow","World"));
}
(Ausgabeergebnis)
30
6.2
HellowWorld
――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――
(Beispiel ~ Beim Ändern der Anzahl der Argumentdaten ~)
public static String hello(String x,String y) {
return x + y ;
}
public static String hello(String x,String y,String z) {
return x + y + z ;
}
public static void main(String[] args) {
System.out.println(hello("Guten Morgen","Yo"));
System.out.println(hello("Oh","Ist","Yo"));
}
(Ausgabeergebnis)
Guten Morgen
Guten Morgen
Wert übergeben und Referenz übergeben
(Idee)
Normale Variablen werden als Wert übergeben. Selbst wenn sich der Quellwert ändert, ändert sich der Zielwert nicht.
Wenn ein Array übergeben wird, wird es als Referenz übergeben. Wenn sich also der Quellwert ändert, ändert sich auch der Zielwert für die Übergabe.
(Beispiel ~ Normale Variable ~)
public class li5_13_1 {
public static void method1(int x) {
System.out.println(x);
x = 20;
}
public static void main(String[] args) {
int x = 10;
method1(x);
System.out.println(x);
}
}
(Ausgabeergebnis)
10
10
(Ergänzung)
Der Wert 10 wird von der Hauptmethode der Methode Methode 1 zugewiesen.
Der Wert wird mit "x = 20" am Ende von "method1 method" geändert, aber die Ausgabe von "main method" bleibt 10.
――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――
(Beispiel ~ Array-Variable ~)
public class li5_13_2 {
public static void incArray(int[] array){
for(int i=0 ;i<array.length ;i++) {
array[i]++;
}
}
public static void main(String[] args) {
int[] array = {1,2,3};
incArray(array);
for(int i :array) {
System.out.println(i);
}
}
}
(Ausgabeergebnis)
2
3
4
(Ergänzung)
Da es sich um eine Array-Variable handelt, wird die Referenzadresse anstelle des Referenzwerts von der Hauptmethode der inArray-Methode zugewiesen.
Bei der "inArray-Methode" wird 1 zum Inhalt des "Array-Variablen-Arrays" hinzugefügt. Da es sich um eine Arrayvariable handelt, wurden die an der angegebenen Adresse gespeicherten Daten geändert. Das heißt, die Originaldaten werden neu geschrieben.
Daher wird in der "inArray-Methode" der Wert nicht durch "return" an die "Hauptmethode" zurückgegeben, sondern das Ausgabeergebnis der "Hauptmethode" ist der Wert nach der Verarbeitung der "inArray-Methode".
Aus dem oben Gesagten bei Array-Variablen ein Bild, das die Originaldaten gemeinsam nutzt.
Recommended Posts