Méthode Java
Dans les chapitres précédents, nous avons souvent utilisé System.out.println(), alors qu'est-ce que c'est ?
println() est une méthode (Method), et System est la classe système (Class), et out est l'objet de sortie standard (Object). L'utilisation de cette phrase consiste à appeler la méthode println() dans l'objet de sortie standard de la classe système System.
Alors quelle est la méthode ?
Une méthode Java est un ensemble d'instructions qui remplissent ensemble une fonction.
Une méthode est une combinaison ordonnée d'étapes pour résoudre un type de problème
Une méthode est contenue dans une classe ou un objet
Les méthodes sont créées dans le programme et référencées ailleurs
Définition des méthodes
Généralement, la définition d'une méthode comprend les éléments suivants Syntaxe : La méthode
修饰符 返回值类型 方法名 (参数类型 参数名){
...
方法体
...
return 返回值;
}contient un en-tête de méthode et un corps de méthode. Voici toutes les parties d'une méthode :
Modificateur : Le modificateur , qui est facultatif, indique au compilateur comment appeler la méthode. Définit le type d'accès pour cette méthode.
Type de valeur de retour : Les méthodes peuvent renvoyer une valeur. returnValueType est le type de données de la valeur de retour de la méthode. Certaines méthodes effectuent l'opération requise mais ne renvoient pas de valeur. Dans ce cas, returnValueType est le mot-clé void.
Nom de la méthode : est le nom réel de la méthode. Le nom de la méthode et la liste des paramètres forment ensemble la signature de la méthode.
Type de paramètre : Le paramètre est comme un espace réservé. Lorsque la méthode est appelée, les valeurs sont transmises aux paramètres. Cette valeur est appelée paramètre ou variable réelle. La liste des paramètres fait référence au type de paramètre, à l'ordre et au nombre de paramètres de la méthode. Les paramètres sont facultatifs et les méthodes ne peuvent contenir aucun paramètre.
Corps de la méthode : Le corps de la méthode contient des instructions spécifiques qui définissent la fonction de la méthode.
Par exemple :
public static int age(int birthday){...}Il peut y avoir plusieurs paramètres :
static float interest(float principal, int year){...}Remarque : Dans certaines autres langues, les méthodes font référence à des procédures et des fonctions. Une méthode qui renvoie une valeur de retour non vide est appelée une fonction ; une méthode qui renvoie une valeur de retour vide est appelée une procédure.
Exemple
La méthode suivante contient 2 paramètres num1 et num2, et elle renvoie la valeur maximale de ces deux paramètres.
/** 返回两个整型变量数据的较大值 */
public static int max(int num1, int num2) {
int result;
if (num1 > num2)
result = num1;
else
result = num2;
return result;
}Appel de méthode
Java prend en charge deux façons d'appeler des méthodes, choisissez selon que la méthode renvoie ou non une valeur.
Lorsqu'un programme appelle une méthode, le contrôle du programme est donné à la méthode appelée. Le contrôle est renvoyé au programme lorsque l'instruction return de la méthode appelée est exécutée ou que la parenthèse fermante du corps de la méthode est atteinte.
Lorsqu'une méthode renvoie une valeur, l'appel de méthode est généralement traité comme une valeur. Par exemple :
int larger = max(30, 40);
Si la valeur de retour de la méthode est nulle, l'appel de la méthode doit être une instruction. Par exemple, la méthode println renvoie void. L'appel suivant est une instruction :
System.out.println("Welcome to Java!");Exemple
L'exemple suivant montre comment définir une méthode et comment l'appeler :
public class TestMax {
/** 主方法 */
public static void main(String[] args) {
int i = 5;
int j = 2;
int k = max(i, j);
System.out.println("The maximum between " + i +
" and " + j + " is " + k);
}
/** 返回两个整数变量较大的值 */
public static int max(int num1, int num2) {
int result;
if (num1 > num2)
result = num1;
else
result = num2;
return result;
}
}Les résultats de compilation et d'exécution de l'exemple ci-dessus sont les suivants :
The maximum between 5 and 2 is 5
Ce programme contient la méthode main et la méthode max. La méthode Main est appelée par la JVM. En dehors de cela, la méthode main n'est pas différente des autres méthodes.
L'en-tête de la méthode main est inchangé. Comme le montre l'exemple, elle a les modificateurs public et static, renvoie une valeur de type void, le nom de la méthode est main et prend un paramètre de type String[]. String[] indique que le paramètre est un tableau de chaînes.
mot-clé void
Cette section explique comment déclarer et appeler une méthode void.
L'exemple suivant déclare une méthode nommée printGrade et l'appelle pour imprimer la note donnée.
Exemple
public class TestVoidMethod {
public static void main(String[] args) {
printGrade(78.5);
}
public static void printGrade(double score) {
if (score >= 90.0) {
System.out.println('A');
}
else if (score >= 80.0) {
System.out.println('B');
}
else if (score >= 70.0) {
System.out.println('C');
}
else if (score >= 60.0) {
System.out.println('D');
}
else {
System.out.println('F');
}
}
}Les résultats de compilation et d'exécution de l'exemple ci-dessus sont les suivants :
C
La méthode printGrade ici est une méthode de type void et elle ne renvoie pas de valeur .
Un appel à une méthode void doit être une instruction. Par conséquent, il est appelé comme instruction sur la troisième ligne de la méthode principale. Comme toute instruction se terminant par un point-virgule.
Passer les paramètres par valeur
Lors de l'appel d'une méthode, vous devez fournir des paramètres, et vous devez les fournir dans l'ordre spécifié dans la liste des paramètres.
Par exemple, la méthode suivante imprime un message n fois de suite :
public static void nPrintln(String message, int n) {
for (int i = 0; i < n; i++)
System.out.println(message);
}Exemple
L'exemple suivant démontre l'effet du passage par valeur.
Ce programme crée une méthode utilisée pour échanger deux variables.
public class TestPassByValue {
public static void main(String[] args) {
int num1 = 1;
int num2 = 2;
System.out.println("Before swap method, num1 is " +
num1 + " and num2 is " + num2);
// 调用swap方法
swap(num1, num2);
System.out.println("After swap method, num1 is " +
num1 + " and num2 is " + num2);
}
/** 交换两个变量的方法 */
public static void swap(int n1, int n2) {
System.out.println("\tInside the swap method");
System.out.println("\t\tBefore swapping n1 is " + n1
+ " n2 is " + n2);
// 交换 n1 与 n2的值
int temp = n1;
n1 = n2;
n2 = temp;
System.out.println("\t\tAfter swapping n1 is " + n1
+ " n2 is " + n2);
}
}Les résultats de compilation et d'exécution de l'exemple ci-dessus sont les suivants :
Before swap method, num1 is 1 and num2 is 2 Inside the swap method Before swapping n1 is 1 n2 is 2 After swapping n1 is 2 n2 is 1 After swap method, num1 is 1 and num2 is 2
Passez deux paramètres pour appeler la méthode swap. Fait intéressant, les valeurs des paramètres réels ne changent pas après l'appel de la méthode.
Surcharge des méthodes
La méthode max utilisée ci-dessus n'est applicable qu'aux données de type int. Mais que se passe-t-il si vous souhaitez obtenir la valeur maximale de deux types de données à virgule flottante ?
La solution est de créer une autre méthode avec le même nom mais des paramètres différents, comme indiqué dans le code suivant :
public static double max(double num1, double num2) {
if (num1 > num2)
return num1;
else
return num2;
}Si vous passez des paramètres de type int lors de l'appel de la méthode max, alors tapez int La méthode max du paramètre sera appelée ;
Si un paramètre double est passé, le corps de la méthode max du type double sera appelé, ce qui est appelé surcharge de méthode
signifie une classe ; Les deux méthodes ont le même nom mais des listes de paramètres différentes.
Le compilateur Java détermine quelle méthode doit être appelée en fonction de la signature de la méthode.
La surcharge de méthodes peut rendre le programme plus clair et plus facile à lire. Les méthodes qui effectuent des tâches étroitement liées doivent utiliser le même nom.
Les méthodes surchargées doivent avoir des listes de paramètres différentes. Vous ne pouvez pas surcharger les méthodes basées uniquement sur des modificateurs ou des types de retour.
Portée de la variable
La portée d'une variable est la partie du programme où la variable peut être référencée.
Les variables définies dans une méthode sont appelées variables locales.
La portée d'une variable locale commence à sa déclaration et se termine à la fin du bloc qui la contient.
Les variables locales doivent être déclarées avant de pouvoir être utilisées.
La portée des paramètres de la méthode couvre l'ensemble de la méthode. Le paramètre est en fait une variable locale.
Les variables déclarées dans la partie initialisation de la boucle for ont une portée tout au long de la boucle.
Mais le champ d'application de la variable déclarée dans le corps de la boucle va de sa déclaration jusqu'à la fin du corps de la boucle. Il contient des déclarations de variables comme celle-ci :
Vous pouvez déclarer une variable locale du même nom plusieurs fois dans une méthode, dans différents blocs non imbriqués, mais vous ne pouvez pas déclarer deux fois une variable locale dans un bloc imbriqué.
Utilisation des paramètres de ligne de commande
Parfois, vous souhaitez transmettre un message à un programme avant de l'exécuter. Ceci est accompli en passant des arguments de ligne de commande à la fonction main().
Les paramètres de ligne de commande sont les informations qui suivent immédiatement le nom du programme lors de l'exécution du programme.
Exemple
Le programme suivant imprime tous les paramètres de ligne de commande :
public class CommandLine {
public static void main(String args[]){
for(int i=0; i<args.length; i++){
System.out.println("args[" + i + "]: " +
args[i]);
}
}
}Comme indiqué ci-dessous, exécutez ce programme :
java CommandLine this is a command line 200 -100
Les résultats sont les suivants :
args[0]: this args[1]: is args[2]: a args[3]: command args[4]: line args[5]: 200 args[6]: -100
Méthode constructeur
Lorsqu'un objet est créé, la méthode constructeur est utilisée pour initialiser l'objet. Le constructeur porte le même nom que la classe dans laquelle il se trouve, mais le constructeur n'a aucune valeur de retour.
Les constructeurs sont généralement utilisés pour attribuer des valeurs initiales aux variables d'instance d'une classe, ou pour effectuer d'autres étapes nécessaires pour créer un objet complet.
Que vous personnalisiez ou non le constructeur, toutes les classes ont des constructeurs, car Java fournit automatiquement un constructeur par défaut, qui initialise tous les membres à 0.
Une fois que vous avez défini votre propre constructeur, le constructeur par défaut devient invalide.
Instance
Voici un exemple d'utilisation de la méthode constructeur :
// 一个简单的构造函数
class MyClass {
int x;
// 以下是构造函数
MyClass() {
x = 10;
}
}Vous pouvez appeler la méthode constructeur pour initialiser un objet comme ceci :
public class ConsDemo {
public static void main(String args[]) {
MyClass t1 = new MyClass();
MyClass t2 = new MyClass();
System.out.println(t1.x + " " + t2.x);
}
}La plupart du temps, un constructeur avec des paramètres est nécessaire.
Instance
Voici un exemple d'utilisation du constructeur :
// 一个简单的构造函数
class MyClass {
int x;
// 以下是构造函数
MyClass(int i ) {
x = i;
}
}Vous pouvez appeler le constructeur pour initialiser un objet comme ceci :
public class ConsDemo {
public static void main(String args[]) {
MyClass t1 = new MyClass( 10 );
MyClass t2 = new MyClass( 20 );
System.out.println(t1.x + " " + t2.x);
}
}Exécuter le les résultats sont les suivants :
10 20
Paramètres variables
À partir du JDK 1.5, Java prend en charge la transmission de paramètres variables du même type à une méthode.
La déclaration des paramètres variables d'une méthode est la suivante :
typeName... parameterName
Dans la déclaration de la méthode, ajoutez des points de suspension (...) après avoir spécifié le type de paramètre.
Un seul paramètre variable peut être spécifié dans une méthode, et il doit s'agir du dernier paramètre de la méthode. Tous les paramètres ordinaires doivent être déclarés avant celui-ci.
Instance
public class VarargsDemo {
public static void main(String args[]) {
// 调用可变参数的方法
printMax(34, 3, 3, 2, 56.5);
printMax(new double[]{1, 2, 3});
}
public static void printMax( double... numbers) {
if (numbers.length == 0) {
System.out.println("No argument passed");
return;
}
double result = numbers[0];
for (int i = 1; i < numbers.length; i++)
if (numbers[i] > result)
result = numbers[i];
System.out.println("The max value is " + result);
}
}Les résultats de compilation et d'exécution de l'exemple ci-dessus sont les suivants :
The max value is 56.5 The max value is 3.0
méthode finalize()
Java permet la définition d'une telle méthode, qui est appelée avant que l'objet ne soit détruit (recyclé) par le garbage collector, cette méthode est appelée finalize(), qui est utilisée pour effacer l'objet recyclé.
Par exemple, vous pouvez utiliser finalize() pour vous assurer qu'un fichier ouvert par un objet est fermé.
Dans la méthode finalize(), vous devez préciser les opérations à effectuer lorsque l'objet est détruit. Le format général de
finalize() est :
protected void finalize()
{
// 在这里终结代码
}Le mot-clé protected est un qualificatif, qui garantit que la méthode finalize() ne sera pas appelée par du code en dehors de la classe.
Bien entendu, le recyclage de la mémoire Java peut être automatiquement effectué par la JVM. Si vous l'utilisez manuellement, vous pouvez utiliser la méthode ci-dessus.
Instance
public class FinalizationDemo {
public static void main(String[] args) {
Cake c1 = new Cake(1);
Cake c2 = new Cake(2);
Cake c3 = new Cake(3);
c2 = c3 = null;
System.gc(); //调用Java垃圾收集器
}
}
class Cake extends Object {
private int id;
public Cake(int id) {
this.id = id;
System.out.println("Cake Object " + id + "is created");
}
protected void finalize() throws java.lang.Throwable {
super.finalize();
System.out.println("Cake Object " + id + "is disposed");
}
}exécute le code ci-dessus et le résultat est le suivant :
C:>java FinalizationDemo Cake Object 1is created Cake Object 2is created Cake Object 3is created Cake Object 3is disposed Cake Object 2is disposed
