Anidada y llamadas recursivas método Java

EDITORIAL: bloggers es unirse a la carrera de entrenamiento después de una experiencia de desarrollo de batalla "jabalíes", un apodo tomado de la película de animación "El Rey León" en el "Peng Peng", actitud siempre optimista y positiva hacia la rodea cosas. ruta técnica de mi-pila completa ingeniero de Java todo el camino hacia el desarrollo de grandes volúmenes de datos, minería de datos, y ahora por fin tener pequeños logros, está dispuesto a intercambiar 5012 adquirimos la primera, que desea aprender la forma de ayuda. Al mismo tiempo, los bloggers también quieren tratar de crear una biblioteca técnica completa, ninguno de los artículos relacionados con las excepciones de punto técnicos, error, las precauciones se enumeran al final, recepción para proporcionar material de varias maneras.

• De los errores que aparecen en el artículo por favor críticos señalaron, debe ser revisada.
• Tenga cualquier pregunta que usted quiere discutir y estudio puede ponerse en contacto conmigo: [email protected].
• Publicar el artículo debido a la columna-estilo específico, autónomo y deficiencias por favor, corríjanme.

Anidada y llamadas recursivas método Java

Este artículo Palabras clave: método, anidación, la recursividad, problemas clásicos

Un nido, el método

1. La interpretación del concepto

De hecho, el concepto de método anidado se entiende mejor, está en el proceso de la llamada al método se ha encontrado con la llamada a métodos, aunque lógicamente puede entender por qué el resultado es tal una carrera, pero para el código de proceso de ejecución se encuentra todavía en el inicio de contactos algunos por el tacto.

2. El método de la anidación

En la programación, el método más común es llamar anidación y métodos, ya que bajo circunstancias normales, se resuelve un problema no se basa en un método. Y si se proporciona un método tan poderoso, que se une a uno de la lista de código y la lógica argumento también se vuelven relativamente compleja, no es propicio para modificar y utilizar, por lo que esperamos que cada método es un poco más de vanguardia, con para resolver un problema en particular, para completar una función más compleja por medio de una combinación, como un cuchillo siete Rennes.

Por ejemplo, tenemos dos métodos: se utilizan para calcular el área de un círculo y calcular el área de un rectángulo, si ahora tenemos que calcular la superficie de un cilindro, también tenemos que reescribir todo el método de nuevo? Por supuesto no es necesario, ya que el cálculo de la superficie del cilindro sólo para la zona lateral (rectángulo) se obtiene por dos zona cilíndrica inferior (círculo), además de cilindro, que sólo necesita un razonables parámetros de entrada y los valores de retorno se pueden realizar.

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;
    }
}

Por lo tanto, todo el proceso de la puesta en práctica del método es lo que es? De hecho, sigue siendo una estructura secuencial, un método que se invoca cuando se aplique plenamente continuará en etapas posteriores, podemos describir este proceso de la siguiente manera:

3. la construcción del nido

En el artículo anterior ha sido introducir el constructor sobrecargado se puede aplicar a la cantidad de diferentes atributos para inicializar reloj Portal: Java Tools inicializar el objeto - constructora . Sin embargo, el uso nos encontramos con un problema, el propósito principal es el de asignación de propiedad constructor, pero se puede encontrar en el constructor sobrecargado, ya que no hay código redundante, no habrá tantos de la misma asignación como trastorno obsesivo-compulsivo pacientes con severa, esto no se puede tolerar, ver el siguiente ejemplo:

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;
}

En el ejemplo anterior hemos definido tres constructores, respectivamente, para satisfacer las diferentes necesidades de inicialización (por supuesto, también podemos definir más), pero se pueden encontrar una gran cantidad de tareas se repiten, podemos llamar a los demás por el constructor maneras de reducir la cantidad de código. En la actual llamada constructor de clase entre sí utilizando de esta manera () para completar, de relleno entre paréntesis los parámetros correspondientes, el código revisado es el siguiente.

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 se usa una de tres parámetro en el constructor de la clase de prueba inicializa un objeto Person: Persona persona = new Persona ( "Zhang" 25, "ingeniero"); realizar el procedimiento es como sigue:

Recursive En segundo lugar, el método de

1. La interpretación del concepto

La recursividad es un proceso de cálculo o método, es una similar a romper el problema en sub-problemas de enfoque para resolver el problema, entonces ¿cuál es el problema, entonces el mismo niño? Es un gran problema para el desmantelamiento, y el problema del niño es la misma regla, o el mismo tipo de operación, tales como el factorial más simple. Si tenemos que calcular el factorial de 4, escribir directamente matemáticamente es 4! = 4 x 3 x 2 x 1.
Entonces, ¿cómo resolver este problema en el ordenador que? Por supuesto, podemos usar el ciclo, a partir del número dado se ha multiplicado por hasta 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);
    }
}

Pero, de hecho, se puede resumir como una regla o descompuesto: n = nx (n - 1), n ​​≥ 2; n = 1, n = 1 !!!. Pues bien, este ciclo y qué diferencia hace? La diferencia es que cuando usamos el bucle, vamos a ser dueño de este proceso de cálculo se traduce íntegramente en código informático que puede ser leído y ejecutado directamente, pero no era el significado original, y en algunos casos, no todos los problemas se pueden estructura de bucle de lograr. Por otra parte, puede resultar cálculo recursivo del papel teórico puede sustituir por completo el ciclo, pero por razones de rendimiento, no se usa específicamente para reemplazar un bucle recursivo, y prefieren utilizar la recursividad para resolver un determinado tipo de problema.

2. pensamiento recursivo

Se puede ver en la descripción anterior, esperamos que al pensar de forma recursiva cerca del original como sea posible descripción del problema, y así podemos resolver el problema. Desde el punto de vista del código, el método recursivo se resume en una frase: a sí mismo . ¿Por qué dice? Debido a que todo el proceso se realiza lograrse mediante la repetición de una etapa de generación de un resultado para cada paso se derivan de la etapa anterior o antes de la etapa. La pregunta entonces llega, y cuando la cabeza de ella? Esto conduce a un concepto: exportaciones recursivas .
Al igual que la circulación necesidad de tener como condición de terminación, las llamadas constantemente de forma recursiva, para obtener los resultados que necesitan, es también tener una condición de terminación, las condiciones determinadas por lo general son más evidentes, y que es conseguir un resultado exacto cuando, no es necesario que sea una llamada recursiva, esta vez directamente a resultados concretos devueltos pueden ser, por ejemplo, utilizamos un factorial recursiva para lograr:

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);
        }
    }
}

Cuando tuvimos que crear una fórmula o una descripción de la ley, podemos tratar de pensar de acuerdo con las siguientes ideas:

• En primer lugar necesidad de determinar la recursivo de salida, que es la condición que es generalmente de salida: valor de determinación de parámetros de entrada puede ser obtenida cuando el valor de
• El siguiente paso es determinar el contenido de las exportaciones, es decir, cuando el juicio en línea con las condiciones, determinar el valor de la resultante
• La última parte es la llamada recursiva, de acuerdo con las leyes resume en la expresión expresión a cabo

3. ejecución

Si usted entiende este proceso de descomposición, entonces hemos logrado a partir del código de esta descripción, cuando n = 1, se puede obtener directamente el resultado de la determinación: 1, con n ≥ 2, mediante llamadas recursivas (llamadas en sí), el n - 1 como un parámetro, en nombre de los que desee obtener n - 1 es el valor de la recursividad, el n - 1 después de pasado, si el resultado no puede ser determinado, que seguirá pidiendo, entonces todo el proceso de la operación por la siguiente carta para representar:

4. problema clásico

• número de Fibonacci

columna de Fibonacci es una serie clásica, el primer término es 1, el segundo término es 1, desde el comienzo de la tercera plazo, el valor de cada elemento son los dos primeros y, forma matemáticamente ordenado es : cuando n = 1 o n = 2, f (n) = 1; cuando n ≥ 3, f (n) = f (n - 1) + f (n - 2). Acuerdo con los pasos anteriores, se puede determinar la exportación n = 1 o n = 2, se determina para obtener un valor de: 1, es la porción de la llamada recursiva: f (n - 1) + f (n - 2), por lo que la escritura el programa:

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);
        }
    }
}

• El triángulo de Pascal

El triángulo de Pascal es un gráfico muy interesantes, una composición piramidal valor fijo, superior y los lados es 1, entonces lo que debe esperar? Sí, recurrente exportaciones! Otras porciones de la capa superior es con sus dos valores más cercanos y añadido, tales como: de arriba hacia abajo (cuarta capa, tercera columna), su valor (nivel 3, columna 2) + (capa 3, columna 3).

Si utilizamos la variable i representa capa, j representa la columna de esta capa, a continuación, (i, j) valor (i - 1, j - 1 ) + (i - 1, j), que es lo que? Sí, la ley de la descripción! Por último, sólo tenemos que conseguir una determinación recursiva de las condiciones de exportación, todo está hecho! Sabemos de la composición anterior, el número de elementos de cada capa, esta capa no supere el número de capas, y de la misma manera, para que sepa cómo la parte superior y los lados lo describen?

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 esto termine? ¿De qué manera! Desde conocido hasta unos gráficos, sin imprime cómo el programa puede eliminar el picor en mi corazón! Y obtener un único valor es diferente cuando se requiere la impresión de entrar en el número de capas que desea visualizar, a continuación, vamos a utilizar un doble para el ciclo para construir la totalidad de los gráficos 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);
        }
    }
}

Los resultados son los siguientes: