351递归概念和分类和主义事项352使用递归计算1-n之间的和

递归∶指在当前方法内调用自己的这种现象。

递归的分类:
　　递归分为两种，直接递归和间接递归。

　　直接递归称为方法自身调用自己

　　间接递归可以A方法调用B方法，B方法调用C方法，C方法调用A方法。

注意事项:

　　递归一定要有条件限定，保证递归能够停止下来，否则会发生栈内存溢出。

　　在递归中虽然有限定条件，但是递归次数不能太多。否则也会发生栈内存溢出。

　　构造方法,禁止递归

public static void main(String[] args) {
        a();
    }
    /*
        递归一定要有条件限定，保证递归能够停止下来，否则会发生栈内存溢出。
        Exception in thread "main" java.lang.stackOverflowError
     */
    private static void a(){
        System.out.println("a方法！");
        a();
    }

    /*
            在递归中虽然有限定条件，但是递归次数不能太多。否则也会发生栈内存溢出
            11157
            Exception in thread "main" java.Lang.stackOverflowError

     */
    private static void b(int i){
        System.out.println(i);
        if (i==10){
            return;
        }
        b(++i);
    }

   /*
     构造方法，禁止递归
        编译错误，构造方法是创建对象使用的，一直递归会导致内存中有无数多个对象，直接编译报错
   */
//    public Recuirson() {
//        Recuirson();
//    }

package com.learn.demo02.Recursion;
/*
    递归:方法自己调用自己
    - 递归的分类:
      - 递归分为两种，直接递归和间接递归。
      - 直接递归称为方法自身调用自己。
      - 间接递归可以A方法调用B方法，B方法调用C方法，C方法调用A方法。
    - 注意事项：
      - 递归一定要有条件限定，保证递归能够停止下来，否则会发生栈内存溢出。
      - 在递归中虽然有限定条件，但是递归次数不能太多。否则也会发生栈内存溢出。
      - 构造方法,禁止递归
    递归的使用前提:
        当调用方法的时候,方法的主体不变,每次调用方法的参数不同,可以使用递归
 */
public class Demo01Recurison {
    public static void main(String[] args) {
        //a();
        b(1);
    }
 
    /*
        构造方法,禁止递归
            编译报错:构造方法是创建对象使用的,一直递归会导致内存中有无数多个对象,直接编译报错
     */
    public Demo01Recurison() {
        //Demo01Recurison();
    }
 
    /*
            在递归中虽然有限定条件，但是递归次数不能太多。否则也会发生栈内存溢出。
            11157
                Exception in thread "main" java.lang.StackOverflowError
         */
    private static void b(int i) {
        System.out.println(i);
        if(i==20000){
            return; //结束方法
        }
        b(++i);
    }
 
    /*
        递归一定要有条件限定，保证递归能够停止下来，否则会发生栈内存溢出。
        Exception in thread "main" java.lang.StackOverflowError
     */
    private static void a() {
        System.out.println("a方法!");
        a();
    }
}

使用递归计算1-n之间的和

分析:num的累和=num+(mum-1购累和,所以可以把累和的操作定义成一个方法,递归调用。

package DiGui;
 
/*
    练习：
        使用递归计算1-n之间的和
 */
public class Demo01Sum {
    public static void main(String[] args) {
        int s = sum(3);
        System.out.println(s);
 
    }
 
    /*
        定义一个方法，使用递归计算1-n之间的和
        1+2+3+4+...+n
        n+(n-1)+(n-2)+(n-3)+...+1
        已知：
            最大值：n
            最小值：1
        使用递归必须明确：
            1.递归的结束条件
                获取到1的时候结束
            2.递归的目的
                获取下一个被加的数字(n-1)
     */
    public static int sum(int n){
        //获取到1的时候结束
        if (n == 1){
            return 1;
        }
 
        //获取下一个被加数字(n-1)
        return n + sum(n - 1);
    }
}

public static void main(String[] args) {
            int s = sum(100);
        System.out.println(s);
    }
    public static int sum(int n){
        //获取到1的时候结束
        if (n==1){
            return 1;
        }
        //获取下一个被加的数字
        return n+sum(n-1);
    }

标签：调用,递归,static,352,351,递归计算,方法,public,内存
来源： https://www.cnblogs.com/agzq/p/16460299.html