Analyse d'un exemple d'utilisation de la méthode Java

1. Le concept et l'utilisation des méthodes

1.1. Qu'est-ce qu'une méthode

Une méthode est un fragment de code Elle est similaire à une "fonction" en langage C. Les fonctions sont les suivantes :

1. Il peut organiser le code de manière modulaire (lorsque la taille du code est relativement complexe).

2. Rendre le code réutilisé, et un code peut être utilisé à plusieurs endroits. 3. Laissez Le code est plus facile à comprendre et plus simple

4. Appelez directement les méthodes existantes pour le développement sans réinventer la roue

1.2 Définition de la méthode

Format de définition :

Exemple : Écrivez une fonction dans. trouvez la factorielle du nombre de termes et

public class TeseDemo220424 {
//    计算某一个数的阶乘
    public static int func(int n){
        int ret = 1;
        for(int i = 1;i <= n;i++){
            ret *= i;
        }
        return ret;
    }
//    计算前多少项阶乘之和
    public static int func1(int k){
        int sum = 0;
        for(int i = 1;i <= k;i++){
            sum += func(i);
        }
        return sum;
    }
    public static void main(String[] args) {
//        写函数来求阶乘之和
        Scanner myscanner = new Scanner(System.in);
        System.out.println("请输入你想要求取前多少项的阶乘的和:");
        int num = myscanner.nextInt();
        int sum = func1(num);
        System.out.println("前 " + num + "项的阶乘和为" + sum);
    }
}

Remarque :

1. Modificateur : à ce stade, la combinaison fixe public static est directement utilisée (car la méthode principale est public static, donc seules les méthodes statiques peuvent y être appelées) .

2. Type de valeur de retour : Si la méthode a une valeur de retour, le type de valeur de retour doit être cohérent avec le type d'entité renvoyé. S'il n'y a pas de valeur de retour, elle doit être écrite comme void.

3. Nom de la méthode : utilisez un petit étui en forme de chameau pour nommer.

4. Liste des paramètres : Si la méthode n'a pas de paramètres, n'écrivez rien entre (). S'il y a des paramètres, le type de paramètre doit être spécifié. Utilisez des virgules pour séparer plusieurs paramètres.

5. Corps de la méthode : les instructions à exécuter à l'intérieur de la méthode.

6. En Java, les méthodes doivent être écrites en classes.

7. En Java, les méthodes ne peuvent pas être imbriquées.

8. En Java, il n'y a pas de déclaration de méthode. (La déclaration et la définition ne sont pas distinguées)

1.3. Processus d'exécution de l'appel de méthode

Processus d'appel :

Appeler la méthode—> Passer les paramètres—> Rechercher l'adresse de la méthode—> >Retour après la fin de la méthode appelée—>Retourner à la méthode appelante principale et continuer l'exécution

Image :

Remarque :

1. Lors de la définition d'une méthode, le code de la méthode ne sera pas exécuté. Elle ne sera exécutée que lorsqu'elle sera appelée.

2. Une méthode peut être appelée plusieurs fois

1.4. La relation entre les paramètres réels et les paramètres formels (important)

Tout le monde doit être familier avec la relation entre les paramètres formels et les paramètres réels. , alors Autrement dit, le paramètre formel est une copie temporaire du paramètre réel, ce qui signifie que les modifications apportées au paramètre formel n'affecteront pas le paramètre réel.

Illustration de la raison spécifique : (Parce que les problèmes spécifiques liés aux cadres de pile de fonctions sont plus compliqués, voici une brève explication)

Ainsi, à partir de l'image, nous pouvons savoir que lors de l'appel par valeur, le formel Le paramètre participe au paramètre réel Les valeurs ne sont pas du tout stockées dans le même espace, elles n'interféreront donc pas les unes avec les autres. En langage C, si vous souhaitez que le changement des paramètres formels affecte les paramètres réels, cela doit être un appel par adresse, mais cela n'existe pas en Java. La solution à cet argument est d'utiliser des références (qui seront présentées en détail plus tard).

2. Surcharge de méthode

2.1. Pourquoi la surcharge de méthode est nécessaire

public class TestDemo220426 {
    public static int addInt(int x,int y){
        return x + y;
    }
    public static double addDouble(double x,double y){
        return x + y;
    }
    public static void main(String[] args) {
        int a = 10;
        int b = 10;
        int ret = addInt(a,b);

        double c = 11.1;
        double d = 12.1;
        double ret1 = addDouble(c,d);
    }
}

Regardez ce code, les deux méthodes addint et adddouble sont toutes deux conçues pour trouver la somme de deux nombres, mais vous devez définir deux fonctions différentes qui ont des valeurs différentes. noms de fonctions, mais parfois les nommer est un casse-tête. Donc, puisque les fonctions essentielles des méthodes sont les mêmes, mais que les paramètres peuvent être différents, pouvons-nous tous utiliser le même nom de fonction ?

La réponse est oui, et c'est ce qu'on appelle la surcharge de méthodes.

2.2. Définition de la surcharge de méthode

En Java, si plusieurs méthodes ont le même nom et des listes de paramètres différentes, elles sont dites surchargées. C'est-à-dire le même nom mais avec des significations différentes.

public class TestDemo220426 {
    public static int add(int x,int y){
        return x + y;
    }
    public static double add(double x,double y){
        return x + y;
    }
    public static void main(String[] args) {
        int a = 10;
        int b = 10;
        int ret = add(a,b);
        System.out.println(ret);
        double c = 11.1;
        double d = 12.1;
        double ret1 = add(c,d);
        System.out.println(ret1);
    }
}

Capture d'écran du programme en cours d'exécution :

Comme le montre le programme ci-dessus, ils implémentent tous les deux la fonction d'addition, mais deux implémentations de fonctions différentes sont définies, mais les noms de fonction sont les mêmes. . Le compilateur appellera la fonction correspondante en fonction des paramètres que vous transmettez.

Remarque :

1. Les noms des méthodes doivent être les mêmes.

2. La liste des paramètres doit être différente (le nombre de paramètres est différent, le type des paramètres est différent, l'ordre des types doit être différent) (doit être distingué par les paramètres)

3. à voir avec si le type de valeur de retour est le même

4. Ne peut pas être défini Deux fonctions qui ne se distinguent que par les valeurs de retour ne peuvent pas constituer une surcharge

5 Lorsque le compilateur compile le code, il en déduira les types de paramètres réels. et déterminez quelle méthode appeler en fonction des résultats de la déduction

2.3 Signature de la méthode

La signature de la méthode est : le nom final de la méthode après avoir été compilée et modifiée par le compilateur. La méthode spécifique est : le nom de chemin complet de la méthode + la liste des paramètres + le type de valeur de retour, qui constitue le nom complet de la méthode. Utilisé pour distinguer les fonctions surchargées

Comment afficher nos signatures de méthode :

1. Compilez d'abord le projet pour générer un fichier de bytecode .class

2 Entrez le .class que vous souhaitez afficher dans le répertoire de la console

3. : javap -v nom du fichier de bytecode

3. Récursion

3.1. Le concept de récursion

Définition : Une méthode qui s'appelle lors de l'exécution est appelée "récursion".

Conditions nécessaires à la récursion :

1. récursion

2. Condition de terminaison pour la récursivité.

3.2、递归过程分析

    public static  int func(int num){
        if(num == 1){
            return 1;
        }
        return num*func(num - 1);
    }
    public static void main(String[] args) {
//        递归求阶乘
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入一个数：");
        int num = scan.nextInt();
        int ret = func(num);
        System.out.println("阶乘为：" + ret);
    }
}

在这里我们以求一个数的阶乘的代码为例来分析一个递归的过程：

递归的过程其实不复杂，看成两个部分，一个是递出去，而是归回来，上面的蓝色箭头是递的过程，红色箭头是归的过程。

3.3、递归小练习

• 按顺序打印一个数字的每一位(例如 1234 打印出 1 2 3 4)

public class TestDemo220427 {
    public static void myprint(int num){
        if(num < 10){
            System.out.println(num%10);
            return;
        }
        myprint(num/10);
        System.out.println(num%10);
        return;
    }
    public static void main(String[] args) {
//        递归实现按顺序打印数字的每一位
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入一个数：");
        int num = scan.nextInt();
        myprint(num);
    }
}

• 求斐波那契数列的第 N 项

public class TestDemo220428 {
    public static int fib1(int n){
        int f1 = 1;
        int f2 = 1;
        int f3 = 1;
        for(int i = 3;i <= n;i++){
            f3 = f1 + f2;
            f1 = f2;
            f2 = f3;
        }
        return f3;
    }
    public static int fib(int n){
        if(n == 1 || n == 2){
            return 1;
        }
        return fib(n-1) + fib(n-2);
    }
    public static void main(String[] args) {
//        递归求斐波那契数列的第n项
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入您想要求取的项数：");
        int n = scan.nextInt();
        int ret = fib1(n);
        System.out.println("第" + n + "项为：" + ret);
    }
}

利用递归求斐波那契数列的第n项的话，其实是一个双路递归，不推荐这种求解的方法，因为会算很多重复的项，效率很低，一般都是选择循环迭代的方式来生成斐波那契数即可。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!