La définition minimale requise est la suivante.
Ici, la méthode main appelle la méthode hello et est utilisée.
--Appelant: méthode main
--Callee: méthode bonjour
↑ Parfois, je dis cela.
public class Main{
//Définition de la méthode principale
public static void main(String[] args){
hello();
}
//hello définition de la méthode
public static void hello(){
System.out.println("Hello World!");
}
}
Bien entendu, les appels de méthode peuvent être imbriqués.
//Définition de la méthode principale
public static void main(String[] args){
methodA();
}
//méthode Une définition
public static void methodA(){
System.out.println("this is methodA");
methodB();
}
//méthodeB définition
public static void methodB(){
System.out.println("this is methodB");
}
Les arguments peuvent être définis dans l'instruction de définition de méthode. Il semble que l'argument décrit par l'appelé soit un ** argument formel **.
//Définition de la méthode principale
public static void main(String[] args){
printName("tanaka");
printName("suzuki");
printName("satou");
}
//Définition de la méthode printName
public static void printName(String name){
System.out.println( name + "Salut,");
}
Lors de l'utilisation de plusieurs arguments, la surcharge peut être utilisée. Dans ce cas, le nombre, le type et l'ordre des arguments peuvent être différents. On dit également que la ** signature ** devrait être différente.
//Définition de la méthode principale
public static void main(String[] args){
System.out.println("L'argument est 2:"+ov(10,20));
System.out.println("L'argument est 3:"+ov(10,20,30));
System.out.println("L'argument est 4:"+ov(10,20,30,40));
System.out.println("Les arguments peuvent être des caractères:"+ov("takahashi"));
}
//définition de la méthode ov
public static int ov(int p, int q){ //Argument formel 2
int ans = p *q;
return ans;
}
public static int ov(int p, int q, int r){ //Argument formel 3
int ans = p * q - r;
return ans;
}
public static int ov(int p, int q, int r, int s){ //Argument formel 4
int ans = p * q - r * s;
return ans;
}
public static String ov(String name){ //
String ans = name;
return ans;
}
À propos, la méthode principale elle-même est également une méthode sans exception, donc si vous tapez un argument de ligne de commande dans le terminal, vous pouvez ajouter ces informations au programme.
Par exemple au terminal
java Main étudiant de 24 ans
Si vous tapez, dans la méthode principale du fichier Main.java
public static void main (String[] args)
Les éléments 24 years old, student sont ajoutés à ce tableau de type String ʻargs. ʻArgs [0] == 24 ans, ʻargs [1] == étudiant`.
Vous pouvez transmettre la valeur à la méthode main en définissant la valeur de retour dans l'instruction de déclaration de méthode.
Ici, la valeur de retour de type int est renvoyée à la méthode principale avec return.
//définition de la méthode principale
public static void main(String[] args){
System.out.println("Le produit de 100 et 200"+ret(100,200));
}
//définition de la méthode ret
public static int ret(int x, int y){
int ans = x * y;
return ans;
}
Lorsque vous passez normalement un tableau à une méthode en tant qu'argument, cela ressemble à ceci.
Ici, il suffit de définir le type d'argument sur ʻint-> ʻint [] lors de la définition de la méthode printArray.
//définition de la méthode principale
//Créez un tableau ici
public static void main(String[] args){
int[] array={10,20,30,40};
printArray(array);
}
//Définition de la méthode printArray
public static void printArray(int[] x){
for(int value: x){
System.out.println(value);
}
}
Bien entendu, un tableau peut être utilisé comme valeur de retour.
Dans ce cas, définissez la valeur de retour de l'instruction de définition de la méthode makeArray sur void-> ʻint []`.
Dans ce programme, en fonction de la valeur spécifiée dans la méthode main, la méthode makeArray détermine le nombre d'éléments en fonction de cette valeur et crée un tableau comme 1,2,3, .... Il est renvoyé à la méthode main en tant que valeur de retour.
//définition de la méthode principale
public static void main(String[] args){
int[] newArray= makeArray(5);
for(int value: newArray){
System.out.println(value);
}
}
//Définition de la méthode makeArray
//Créez un tableau ici
public static int[] makeArray(int size){
int[] x = new int[size];
for(int i=1; i<x.length; i++){
x[i] = i;
}
return x;
}
Lors de l'échange normal d'arguments et de valeurs de retour entre méthodes, on peut dire que les valeurs elles-mêmes sont échangées (** passer par valeur, appel par valeur ). Cependant, lors de l'échange d'un tableau en tant qu'argument / valeur de retour entre les méthodes, l'adresse en mémoire est passée à la place de la valeur elle-même ( passer par référence, appeler par référence **). Par conséquent, le tableau créé par la méthode principale
int[] array = {1,2,3,4} //méthode principale
Comme argument d'une autre méthode, puis dans cette méthode
array[0]=10; //Méthode appelée
Si vous remplacez quelque chose comme ça, la valeur en mémoire changera. Par conséquent, dans la méthode principale
System.out.println(array[0]);
Si vous frappez quelque chose comme ça, la valeur renvoyée sera «10» au lieu de «1». Que le tableau peut être réécrit comme «10,2,3,4».
P.S### Une variable à laquelle une adresse en mémoire est affectée au lieu de la valeur elle-même est appelée ** type de référence **. Pour les types non-tableau, ** type de classe ** est inclus dans le type de référence.
Voici un exemple de réécriture d'un tableau en passant par référence.
//définition de la méthode principale
public static void main(String[] args){
int[] array={1,2,3,4};
incArray(aray);
for (int value: aray){
System.out.println(value);
}
}
//définition de la méthode incArray
public static void incArray(int[] x){
for(int i=0; i<x.length; i++){
x[i]++;
}
}
Le tableau renvoyé doit être «2,3,4,5».
[Introduction à Java 2nd Edition] (https://www.amazon.co.jp/dp/B00MIM1KFC/ref=dp-kindle-redirect?_encoding=UTF8&btkr=1) Chapitre 5 Pp.170-202, 336.
Recommended Posts