Emboîtée et les appels de méthode Java récursives

EDITORIAL: les blogueurs est de se joindre à la carrière de formation après l'expérience du combat développement « sangliers », un surnom tiré du film d'animation « Le Roi Lion » dans le « Peng Peng », toujours l'attitude optimiste et positive envers les environs les choses. Itinéraire technique de mon plein pile ingénieur Java tout le chemin vers le développement des grandes données, l'exploration de données, et enfin avoir de petites réalisations, est prêt à échanger 5012 nous avons acquis l'ancien, vous voulez apprendre la voie de l'aide. En même temps, les blogueurs veulent aussi essayer de créer une bibliothèque technique complète, tous les articles relatifs aux exceptions ponctuelles techniques, des erreurs, des précautions sont énumérées à la fin, bienvenue pour fournir du matériel de différentes façons.

• Pour toute erreur qui apparaissent dans l'article critique vous plaît souligné, doit être révisé.
• Vous avez des questions que vous voulez discuter et étude peut me contacter: [email protected].
• Publier l'article à cause du style spécifique colonne, autonome et insuffisances Veuillez me corriger.

Emboîtée et les appels de méthode Java récursives

Cet article Mots-clés: méthode, imbrication, récursivité, problèmes classiques

Un nid, le procédé

1. interprétation du concept

En fait, le concept de la méthode imbriquée est mieux comprise, est en train d'appeler la méthode a rencontré l'appel de méthodes, bien que logiquement peut comprendre pourquoi le résultat est une course, mais pour le processus d'exécution du code est encore au début de contacts certains se sentent autour.

2. La méthode d'imbrication

Dans la programmation, la méthode la plus courante consiste à appeler la nidification et les méthodes, parce que dans des circonstances normales, nous résolvons un problème ne pas se fier à une méthode. Et si une méthode est fournie si puissant, il est lié à une de la liste logique de code et des arguments aussi devenir relativement complexe, il est peu propice à modifier et à utiliser, donc nous espérons que chaque méthode est un peu plus fine pointe, avec pour résoudre un problème particulier, à remplir une fonction plus complexe au moyen d'une combinaison, comme un couteau sept Rennes.

Par exemple, nous avons deux méthodes: sont utilisées pour calculer l'aire d'un cercle et calculer l'aire d'un rectangle, si nous avons besoin maintenant de calculer la surface d'un cylindre, nous avons aussi besoin de réécrire à nouveau l' ensemble de la méthode? Bien sûr que non nécessaire, parce que le calcul de la surface du cylindre juste la zone latérale (rectangle) est obtenu par deux zones de fond cylindrique (cercle) plus cylindre, nous avons seulement besoin d' un des paramètres entrants raisonnables et les valeurs de retour peuvent être réalisées.

public class Test{
    public static void main(String[] args){
        // 计算一个圆柱的面积，已知底面半径和高
        int radius = 5;
        int height = 10;
        // 调用计算圆柱表面积
        double area = getColumnArea(radius,height);
        // 输出结果
        System.out.println("圆柱的表面积为：" + area);
    }
    public static double getCircleArea(double radius){
        // 根据圆的半径计算面积后返回
        return Math.PI * Math.pow(radius,2);
    }
    public static double getRectangleArea(double width,double height){
        // 根据宽和高计算面积后返回
        return width * height;
    }
    public static double getColumnArea(double radius,double height){
        // 计算得到底面积 -> 刚好是侧面积的宽
        double baseArea = getCircleArea(radius);
        // 计算得到侧面积
        double lateralArea = getRectangleArea(baseArea,height);
        // 根据底面积及侧面积计算后返回
        return baseArea * 2 + lateralArea;
    }
}

Ainsi, le processus de la mise en œuvre de la méthode est ce qui est? En fait, encore une structure séquentielle, une méthode est appelée lorsque pleinement mis en œuvre se poursuivra dans les étapes suivantes, nous pouvons décrire ce processus comme suit:

3. la construction du nid

Dans l'article précédent a été d'introduire le constructeur surchargé peut être appliqué au nombre d'attributs différents pour initialiser Portal Watch: Outils Java initialiser l'objet - constructeur . Cependant, l'usage que nous trouvons un problème, le but principal est de cession de la propriété du constructeur, mais se trouve dans le constructeur surchargé, car il y a du code redondant, il y aura autant de la même affectation que le trouble obsessionnel-compulsif les patients souffrant de graves, cela ne peut être toléré, voir l'exemple suivant:

public class Person{
    // 一参构造器
    public Person(String name){
        this.name = name;
    }
    // 两参构造器，可以给name和age属性赋值
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }
    // 三参构造器，可以给name、age和job属性赋值
    public Person(String name,int age,String job){
        this.name = name;
        this.age = age;
        this.job = job;
    }
    public String name;
    public int age;
    public String job;
}

Dans l'exemple ci-dessus, nous avons défini trois constructeurs, respectivement, pour répondre aux différents besoins d'initialisation (bien sûr, on peut aussi définir plus), mais vous pouvez trouver beaucoup de tâches sont répétées, on peut appeler par constructeur des moyens de réduire la quantité de code. Dans le constructeur de la classe actuelle appel autre à l'aide de cette () façon de compléter, remplir entre parenthèses les paramètres correspondants, le code révisé suit comme.

public class Person{
    // 一参构造器
    public Person(String name){
        this.name = name;
    }
    // 两参构造器，可以给name和age属性赋值
    public Person(String name,int age){
        this(name);
        this.age = age;
    }
    // 三参构造器，可以给name、age和job属性赋值
    public Person(String name,int age,String job){
        this(name,age);
        this.job = job;
    }
    public String name;
    public int age;
    public String job;
}

Si vous utilisez un trois paramètres dans le constructeur de la classe de test initialise un objet Personne: Personne personne = new Person ( « Zhang » 25, « ingénieur »), effectuer la procédure est la suivante:

Récursive En second lieu, la méthode de

1. interprétation du concept

Récursion est un processus de calcul ou d'une méthode, est similaire à briser le problème en sous-problèmes approche pour résoudre le problème, alors quel est le problème, le même enfant? Il est un gros problème pour le démantèlement et le problème de l'enfant est la même règle, ou le même genre d'opération, comme le factoriel simple. Si nous devons calculer le factoriel de 4, écrire directement mathématiquement est 4! = 4 x 3 x 2 x 1.
Alors , comment pouvons-nous résoudre ce problème avec l'ordinateur , il? Bien sûr, nous pouvons utiliser le cycle, à partir du nombre donné a été multiplié par jusqu'à 1:

public class Test{
    public static void main(String[] args){
        int n = 4;
        int result = 1;
        for(int i = n;i <= 1;i--){
            result *= i;
        }
        System.out.println(result);
    }
}

Mais en fait, il peut se résumer en règle ou décomposée: n = nx (n - 1), n ​​≥ 2; n = 1, n = 1 !!!. Eh bien, ce cycle et quelle différence y at-il? La différence est que lorsque nous utilisons la boucle, nous possédons ce processus de calcul est entièrement traduit en code informatique qui peut être lu et exécuté directement, mais n'a pas été le sens d'origine, et dans certains cas, tous les problèmes peuvent être la structure en boucle à réaliser. D'autre part, il peut prouver le calcul récursif du rôle théorique peut remplacer complètement le cycle, mais pour des raisons de performance, nous ne délibérément utilisé pour remplacer une boucle récursive, et préfèrent utiliser la récursivité pour résoudre un type particulier de problème.

2. pensée récursive

Peut être vu de la description ci - dessus, nous espérons que par la pensée récursive proche de l'original que la description possible du problème, et peut résoudre bien le problème. Du point de vue du code, la méthode récursive est résumée en une phrase: à lui - même . Pourquoi dites - vous? Parce que l'ensemble du processus est réalisée obtenu en répétant une étape consistant à générer un résultat pour chaque étape sont issus de l'étape précédente ou avant l' étape. La question est alors, et quand la tête de celui - ci? Cela conduit à un concept: les exportations récursives .
Comme la circulation besoin d'avoir comme condition de terminaison, en permanence appelle lui - même récursive, pour obtenir les résultats dont ils ont besoin, il est aussi d'avoir une condition de cessation d' emploi, les conditions fixées sont généralement plus évidents, et ce qui est d'obtenir un résultat exact quand, ne pas besoin d'être un appel récursif, cette fois directement à des résultats concrets de retour peuvent être, par exemple, nous utilisons un factoriel récursif pour obtenir:

public class Test{
    public static void main(String[] args){
        int n = 4;
        int result = getFactorial(n);
        System.out.println(result);
    }
    // 定义一个方法，用于计算n的阶乘，不考虑n < 0的情况
    public static int getFactorial(int n){
        // 递归的出口
        // 描述当n = 1时，阶乘的结果为1，直接返回确定的结果
        if(n == 1){
            return 1;
        }else{
            // 根据规律，此时应该先获取到n - 1的阶乘的结果
            // 描述当n ≥ 2时，n! = n x (n - 1)!
            return n * getFactorial(n - 1);
        }
    }
}

Lorsque nous mettons ensemble une formule ou une description de la loi, nous pouvons essayer de penser selon les idées suivantes:

• Tout d'abord besoin de déterminer la récursif de sortie, qui est la condition qui est généralement prise: valeur de détermination des paramètres entrant peut être obtenu lorsque la valeur de
• L'étape suivante consiste à déterminer le contenu des exportations, qui est, lorsque l'arrêt en conformité avec les conditions, déterminer la valeur de la résultante
• La dernière partie est l'appel récursif, selon les lois résumées par l'expression expression sur

3. exécution

Si vous comprenez ce processus de décomposition, nous avons réalisé à partir du code de cette description, lorsque n = 1, peut obtenir directement le résultat de la détermination: 1; lorsque n ≥ 2, par des appels récursifs (appels lui-même), n - 1 en tant que paramètre, au nom du besoin d'obtenir n - 1 est la valeur de récursion, le n - 1 après son adoption, si le résultat ne peut être déterminé, il continuera à appeler, le processus d'ensemble de l'opération par le tableau suivant pour représenter:

4. problème classique

• numéro fibonacci

colonne Fibonacci est une série classique, le premier terme est égal à 1, le deuxième terme est égal à 1, à partir du début de la troisième période, la valeur de chaque élément sont les deux premiers et, mathématiquement manière bien rangée est : lorsque n = 1 ou n = 2, f (n) = 1, lorsque n ≥ 3, f (n) = f (n - 1) + f (n - 2). Conformément aux étapes précédentes, on peut déterminer l'exportation n = 1 ou n = 2, est déterminé pour obtenir une valeur de: 1, est la partie de l'appel récursif: f (n - 1) + f (n - 2), moyennant quoi la radiation le programme:

public class Test{
    public static void main(String[] args){
        int n = 5;// 自定义一个正整数n
        int result = f(n);
        System.out.println(result);
    }
    public static int f(int n){
        // 递归出口：当n = 1或n = 2时终止调用，得到确定的值
        if(n == 1 || n == 2){
            return 1;
        }else{
            // 自第三项开始，结果为前两项的加和
            return f(n - 1) + f(n - 2);
        }
    }
}

• Triangle de Pascal

Triangle de Pascal est un graphisme très intéressant, une composition de pyramide de valeur fixe, haut et les côtés est 1, alors ce que vous attendez? Oui, récursives exportations! D' autres parties de la couche supérieure est , avec ses deux valeurs et ajoutées les plus proches, par exemple: de haut en bas (quatrième couche, la troisième colonne), la valeur (niveau 3, colonne 2) + (couche 3, colonne 3).

Si nous utilisons la variable i représente la couche, j représente la colonne de cette couche, puis (i, j) valeur (i - 1, j - 1 ) + (i - 1, j), ce qui est quoi? Oui, la loi de la description! Enfin, nous avons juste besoin d'obtenir une détermination récursive des conditions d'exportation, tout est fait! Nous savons de la composition ci - dessus, le nombre d'éléments de chaque couche, cette couche ne dépasse pas le nombre de couches, et la même chose, vous savez comment le dessus et les côtés décrivent?

public class Test{
    public static void main(String[] args){
        int i = 4;// 定义一个正整数i
        int j = 3;// 定义一个正整数j,大小不能超过i
        int result = getN(i,j);
        System.out.println(result);
    }
    public static int getN(int i,int j){
        // 第1层和第1列的值固定为1，最后一列的值也固定为1
        if(i == 1 || j == 1 || j == i){
            return 1;
        }else{
            // 使用表达式描述规律
            return getN(i - 1,j - 1) + getN(i - 1,j);
        }
    }
}

Que ce soit là-dessus? De quelle façon! Depuis rencontré si beaux graphismes, pas imprimé comment le programme peut éliminer les démangeaisons dans mon cœur! Et obtenir une seule valeur est différente lorsque l'impression est nécessaire d'entrer le nombre de couches que vous souhaitez afficher, nous utiliserons un double pour le cycle de construire sur l'ensemble des graphiques de:

public class Test{
    public static void main(String[] args){
        int n = 5;// 定义一个正整数n
        print(n);
    }
    public static void print(int n){
        for(int i = 1;i <= n;i ++){
            // 在每行前插入空格，空格数量与目标层数相关
            for (int j = i;j <= n;j++){
                System.out.print(" ");
            }
            for (int j = 1;j <= i;j++){
                // 输出后进行留空
                System.out.print(getN(i,j) + " ");
            }
            // 打印一层后换行
            System.out.println();
        }
    }
    public static int getN(int i,int j){
        // 第1层和第1列的值固定为1，最后一列的值也固定为1
        if(i == 1 || j == 1 || j == i){
            return 1;
        }else{
            // 使用表达式描述规律
            return getN(i - 1,j - 1) + getN(i - 1,j);
        }
    }
}

Les résultats sont les suivants: