Die minimal erforderliche Definition lautet wie folgt.
Hier ruft die main -Methode die hello -Methode auf und wird verwendet.
↑ Manchmal sage ich das.
public class Main{
//Hauptmethodendefinition
public static void main(String[] args){
hello();
}
//Hallo Methodendefinition
public static void hello(){
System.out.println("Hello World!");
}
}
Natürlich können Methodenaufrufe verschachtelt werden.
//Hauptmethodendefinition
public static void main(String[] args){
methodA();
}
//methodA Definition
public static void methodA(){
System.out.println("this is methodA");
methodB();
}
//MethodeB Definition
public static void methodB(){
System.out.println("this is methodB");
}
Argumente können in der Methodendefinitionsanweisung festgelegt werden. Es scheint, dass das vom Angerufenen beschriebene Argument ein ** formales Argument ** ist.
//Hauptmethodendefinition
public static void main(String[] args){
printName("tanaka");
printName("suzuki");
printName("satou");
}
//printName-Methodendefinition
public static void printName(String name){
System.out.println( name + "Hallo,");
}
Bei Verwendung mehrerer Argumente kann eine Überladung verwendet werden. In diesem Fall können Anzahl, Typ und Reihenfolge der Argumente unterschiedlich sein. Es wird auch gesagt, dass die ** Signatur ** unterschiedlich sein sollte.
//Hauptmethodendefinition
public static void main(String[] args){
System.out.println("Das Argument ist 2:"+ov(10,20));
System.out.println("Argument ist 3:"+ov(10,20,30));
System.out.println("Argument ist 4:"+ov(10,20,30,40));
System.out.println("Argumente können Zeichen sein:"+ov("takahashi"));
}
//ov Methodendefinition
public static int ov(int p, int q){ //Formelles Argument 2
int ans = p *q;
return ans;
}
public static int ov(int p, int q, int r){ //Formelles Argument 3
int ans = p * q - r;
return ans;
}
public static int ov(int p, int q, int r, int s){ //Formelles Argument 4
int ans = p * q - r * s;
return ans;
}
public static String ov(String name){ //
String ans = name;
return ans;
}
Die Hauptmethode selbst ist übrigens auch eine Methode ohne Ausnahme. Wenn Sie also ein Befehlszeilenargument in das Terminal eingeben, können Sie diese Informationen dem Programm hinzufügen.
Zum Beispiel am Terminal
Java Main 24 Jahre alter Student
Wenn Sie eingeben, geben Sie die Hauptmethode der Datei Main.java ein
public static void main (String[] args)
Elemente 24 Jahre alt, Student werden zu diesem Array vom Typ String args hinzugefügt.
args [0] == 24 Jahre alt, args [1] == student.
Sie können den Wert an die Hauptmethode übergeben, indem Sie den Rückgabewert in der Anweisung für die Methodendeklaration festlegen.
Hier wird der Rückgabewert vom Typ int mit return an die Hauptmethode zurückgegeben.
//Hauptmethodendefinition
public static void main(String[] args){
System.out.println("Das Produkt von 100 und 200"+ret(100,200));
}
//Definition der Ret-Methode
public static int ret(int x, int y){
int ans = x * y;
return ans;
}
Wenn ein Array normalerweise als Argument an eine Methode übergeben wird, sieht es so aus.
Hier reicht es aus, den Argumenttyp beim Definieren der printArray-Methode auf int->int []zu setzen.
//Hauptmethodendefinition
//Erstellen Sie hier ein Array
public static void main(String[] args){
int[] array={10,20,30,40};
printArray(array);
}
//Definition der printArray-Methode
public static void printArray(int[] x){
for(int value: x){
System.out.println(value);
}
}
Natürlich kann ein Array als Rückgabewert verwendet werden.
Setzen Sie in diesem Fall den Rückgabewert der makeArray-Methodendefinitionsanweisung auf void->int [].
In diesem Programm ermittelt die Methode makeArray basierend auf dem in der Hauptmethode angegebenen Wert die Anzahl der Elemente gemäß diesem Wert und erstellt ein Array mit den Werten 1,2,3, .... Es wird als Rückgabewert an die Hauptmethode zurückgegeben.
//Hauptmethodendefinition
public static void main(String[] args){
int[] newArray= makeArray(5);
for(int value: newArray){
System.out.println(value);
}
}
//Definition der makeArray-Methode
//Erstellen Sie hier ein Array
public static int[] makeArray(int size){
int[] x = new int[size];
for(int i=1; i<x.length; i++){
x[i] = i;
}
return x;
}
Beim normalen Austausch von Argumenten und Rückgabewerten zwischen Methoden kann gesagt werden, dass die Werte selbst ausgetauscht werden (** Wert übergeben, Wert aufrufen ). Beim Austausch eines Arrays als Argument / Rückgabewert zwischen Methoden wird jedoch die Adresse im Speicher anstelle des Werts selbst übergeben ( als Referenz übergeben, als Referenz aufrufen **). Daher das von der Hauptmethode erstellte Array
int[] array = {1,2,3,4} //Hauptmethode
Als Argument für eine andere Methode, dann innerhalb dieser Methode
array[0]=10; //Aufgerufene Methode
Wenn Sie so etwas ersetzen, ändert sich der Wert im Speicher. Daher in der Hauptmethode
System.out.println(array[0]);
Wenn Sie so etwas treffen, ist der zurückgegebene Wert "10" anstelle von "1". Dass das Array als "10,2,3,4" umgeschrieben werden kann.
P.S### Eine Variable, der anstelle des Werts selbst eine Adresse im Speicher zugewiesen ist, heißt ** Referenztyp **. Bei Nicht-Array-Typen ist der Klassentyp ** Klassentyp ** enthalten.
Hier ist ein Beispiel für das Umschreiben eines Arrays durch Übergabe als Referenz.
//Hauptmethodendefinition
public static void main(String[] args){
int[] array={1,2,3,4};
incArray(aray);
for (int value: aray){
System.out.println(value);
}
}
//incArray-Methodendefinition
public static void incArray(int[] x){
for(int i=0; i<x.length; i++){
x[i]++;
}
}
Das zurückgegebene Array sollte "2,3,4,5" sein.
[Einführung in Java 2nd Edition] (https://www.amazon.co.jp/dp/B00MIM1KFC/ref=dp-kindle-redirect?_encoding=UTF8&btkr=1) Kapitel 5 S. 170-202, 336.
Recommended Posts