5.Java语言基础(数组)(递归)

1.数组概述和定义格式说明

1.为什么要有数组
    现在需要统计某公司员工的工资情况，例如计算平均工资、找到最高工资等。假设该公司有80名员工，
    用前面所学的知识，程序首先需要声明80个变量来分别记住每位员工的工资，然后在进行操作，这样做会显得很麻烦。
    为了解决这种问题，Java就提供了数组供我们使用
    结论：
        数组是存储多个变量(元素)的东西(容器)
        这多个变量的数据类型要一致    
2.数组概念
    数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。
    数组既可以存储基本数据类型，也可以存储引用数据类型
3.数组定义格式
    格式1： 数据类型[] 数组名；
    格式2： 数据类型   数组名[];
举例：
    int[] a；     定义了一个int类型的数组a；
    int a[];    定义了一个int类型的a数组；
    推荐使用第一种定义方式。

2.数组的初始化动态初始化

1.什么是数组的初始化
    Java中的数组必须先初始化,然后才能使用。
    所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。
2.初始化的分类：
    a:动态初始化:    只指定长度，由系统给出初始化值
    b:静态初始化:    给出初始化值，由系统决定长度    
    注意事项： 这两种方式，只能使用一种，不能进行动静结合    
3.动态初始化的格式：
    数据类型[] 数组名 = new 数据类型[数组长度];
    数组长度其实就是数组中元素的个数。
    举例： int[] arr = new int[3];    定义了一个int类型的数组arr，这个数组可以存放3个int类型的值。
4.案例演示    
    输出数组名称和数组元素

3.Java中的内存分配以及栈和堆的区别

Java虚拟机在执行Java程序的过程中会把它管理的内存划分成若干个不同的数据区域

1.栈: 存放的是局部变量
    局部变量：在方法定义中或者方法声明上的变量都是局部变量。
2.堆: 存放的是所有new出来的东西
    特点：
        a: 每一个new出来的东西都会为其分配一个地址值。
        b: 每一个变量都有一个默认的值
            byte，short，int，long  -- 0
            float，double                -- 0.0
            char                       -- 'u0000'
            boolean                 -- false
            引用数据类型     -- null        
        c: 使用完毕就变成了垃圾，等待垃圾回收器对其回收
3.方法区:(面向对象部分讲解)  
4.本地方法区:(和系统相关) 
5.寄存器:(cpu使用)

Java虚拟机在执行Java程序的过程中会将其管理的内存划分为若干个不同的数据区域，这些区域有各自
的用途、创建和销毁的时间，有些区域随虚拟机进程的启动而存在，有些区域则是依赖用户线程的启动和
结束来建立和销毁。Java虚拟机所管理的内存包括以下几个运行时数据区域，如图： 

4.数组的内存图解1一个数组

1.定义一个数组，输出数组名称和数组中的元素值，给数组赋值，再次输出数组名称和数组中的元素值

 

5.数组的内存图解2二个数组

1.定义两个数组，分别输出数组名称和数组中的元素值，分别给两个数组赋值，再次输出数组名称和数组中的元素值

public class MyDemo2 {
    public static void main(String[] args) {
        int[] arr1 = new int[3];
        arr1[0] = 10;
        arr1[1] = 20;
        arr1[2] = 30;
        System.out.println(arr1); //打印数组的地址值
        System.out.println(arr1[0]);
        System.out.println(arr1[1]);
        System.out.println(arr1[2]);

        System.out.println("=======================================");
        //每 new 一次 都会在堆内存开辟新的空间
        int[] arr2 = new int[3];
        System.out.println(arr2); //打印数组的地址值
        arr2[0] = 100;
        arr2[1] = 200;
        arr2[2] = 300;

        System.out.println(arr2[0]);
        System.out.println(arr2[1]);
        System.out.println(arr2[2]);
    }
}

  

6.数组的内存图解3三个引用2个数组

1. 定义第一个数组,定义完毕后，给数组元素赋值。赋值完毕后，再输出数组名称和元素。
    定义第二个数组,定义完毕后，给数组元素赋值。赋值完毕后，再输出数组名称和元素。
    定义第三个数组,把第一个数组的地址值赋值给它。(注意类型一致)，通过第三个数组的名称去把元素重新赋值。
    最后，再次输出第一个数组数组名称和元素。  

package org.westos.demo3;
public class MyTest {
    public static void main(String[] args) {
        int[] arr = new int[2];
        arr[0] = 25;
        arr[1] = 30;

        int[] arr1 = new int[2];
        arr1[0] = 96;
        arr1[1] = 66;

        int[] arr2 = arr;
        arr2[0] = 630;
        arr2[1] = 99;

        System.out.println(arr[0]);

        System.out.println(arr[1]);

        System.out.println("===============================");
        System.out.println(arr1[0]);
        System.out.println(arr1[1]);

        System.out.println("=====================");
        System.out.println(arr2[0]);
        System.out.println(arr2[1]);
        //打印数组的地址值。
        System.out.println(arr);
        System.out.println(arr1);
        System.out.println(arr2);


        //判断两个数组的地址值，是否相等
        System.out.println(arr == arr1); //false
        System.out.println(arr == arr2); //true
    }
}

 

7.数组的初始化静态初始化及内存图

1.静态初始化的格式：
    格式：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
        举例： int[] arr = new int[]{1,2,3};
    简化格式：
        数据类型[] 数组名 = {元素1,元素2,…};
        举例： int[] arr = {1,2,3};
2.画图演示
    a：定义一个数组，输出数组名称和数组中的元素值

package org.westos.demo;
public class MyTest2 {
    public static void main(String[] args) {
        int[] arr = new int[]{10, 20, 30};
        System.out.println(arr); //打印数组的地址值 1b6d3586
        arr[0] = 100;
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);

    }
}

1.可以动态的获取数组的长度      2.数组中最后一个元素的索引=数组长度-1

package org.westos.demo;
public class MyTest3 {
    public static void main(String[] args) {
        int[] arr = new int[]{10, 20, 30, 20, 300, 30, 90, 30, 999};
        //数组有一个length属性，可以动态的获取数组的长度
        int len = arr.length;
        System.out.println(len);

        //获取数组最后一个元素的值  alt+enter 万能纠错键
        int num = arr[4];
        System.out.println(num);
        //数组中最后一个元素的索引=数组长度-1
        int index = arr.length - 1;
        System.out.println(arr[index]);
        int i = arr[arr.length - 1];
        System.out.println(i);

    }
}

8.数组操作的两个常见小问题越界和空指针

1.案例演示
    a:ArrayIndexOutOfBoundsException:数组索引越界异常
        原因：你访问了不存在的索引。
    b:NullPointerException:空指针异常
        原因：数组已经不在指向堆内存了。而你还用数组名去访问元素。

空指针异常例子：

package org.westos.demo2;
public class MyTest {
    public static void main(String[] args) {
        //你使用数组时，经常会遇到，数组角标越界异常
        int[] arr = new int[]{20, 200, 30};
        System.out.println(arr);
        arr = null; //人为置null
        System.out.println(arr.length);//NullPointerException 空指针异常

        //取元素的时候，角标不对 ArrayIndexOutOfBoundsException 数组索引越界异常
        //System.out.println(arr[3]);
        // arr[4] = 2000; ArrayIndexOutOfBoundsException 数组索引越界异常
    }
}

 

9.数组的操作1遍历

1. 数组遍历：就是依次输出数组中的每一个元素。

package org.westos.demo2;
public class MyTest2 {
    public static void main(String[] args) {
        int[] arr = new int[]{10, 20, 30, 40, 50, 60};

        

        //数组的遍历
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        System.out.println("=====================================");
        //数组的反向遍历  60 50 40 30 20 10

        for (int i = arr.length - 1; i >= 0; i--) {
            System.out.println(arr[i]);
        }

    }
}

10.数组的操作2获取最值

A: 数组获取最值(获取数组中的最大值或者最小值)

package org.westos.demo2;
public class MyTest4 {
    public static void main(String[] args) {
        int[] arr = {10, 20, 6000, 300, 50, 15000, 96, 63};
        int max = getMax(arr);//alt+enter 自动补全
        System.out.println("最大值是：" + max);


        int[] arr2 = {0, -10, 10, 20, 6000, 300, 50, 15000, 96, 63};
        int min = getMin(arr2);
        System.out.println("最小值是：" + min);


    }

    public static int getMax(int[] arr) {
        //获取数组中的最大值
        //定义一个参照的元素

        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }

        return max;
    }


    public static int getMin(int[] arr) {
        //获取数组中的最大值
        //定义一个参照的元素

        int min = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] < min) {
                min = arr[i];
            }
        }

        return min;
    }
}

11.数组的操作3反转

1. 数组元素反转(就是把元素对调)

package org.westos.demo3;
public class MyTest {
    public static void main(String[] args) {
        // A:
        // 案例演示:
        // 数组元素反转(就是把元素对调)
        //思路：首尾元素，交换值（采用中间变量来交换）遍历一半
        int[] arr = {10, 20, 30, 40, 50, 60}; //{60，50,40,30,20,10}

        for (int i = 0; i < arr.length / 2; i++) {
            int t = arr[i];
            arr[i] = arr[arr.length - 1 - i];
            arr[arr.length - 1 - i] = t;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

 

package org.westos.demo3;
public class MyTest2 {
    public static void main(String[] args) {
        int[] arr = {10, 20, 30, 40, 50, 60, 70, 80, 90}; //{60，50,40,30,20,10}

        for (int i = 0, j = arr.length - 1; i < j; i++, j--) {
            int t = arr[i];
            arr[i] = arr[j];
            arr[j] = t;
        }

        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

12.数组的操作4查表法

1.数组查表法(根据键盘录入索引,查找对应星期)

import java.util.Scanner;
public class MyTest {
    public static void main(String[] args) {
        // 案例演示:    数组查表法(根据键盘录入索引,查找对应星期) 根据索引找元素
        //定义字符串数组
        String[] week = {"星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期天"};

        Scanner sc = new Scanner(System.in);

        System.out.println("请输入索引 0--6");
        int index = sc.nextInt();

        String yuansu = getEle(index, week);

        System.out.println(yuansu);


    }

    public static String getEle(int index, String[] week) {
        if ( index >= 0 && index <= 6) {
            String yuansu = week[index];
            return yuansu;
        } else {
            return "你查找的元素不存在，请检查你的索引是否输入正确";
        }
    }
}

13.数组的操作5基本查找

1.数组元素查找(查找指定元素第一次在数组中出现的索引)

import java.util.Scanner;
public class MyTest2 {
    public static void main(String[] args) {
        //定义字符串数组
        //根据元素查索引
        String[] week = {"星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期天"};
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入星期");
        // nextLine();录入的是字符串
        String s = sc.nextLine();
        int index = getIndexByEle(s, week);

        System.out.println("该元素的索引是：" + index);

    }

    
    public static int getIndexByEle(String ele, String[] arr) {
        for (int i = 0; i < arr.length; i++) {
            //判断两个字符串，字面上的内容是否一样，不要用 == 号 ，用 equals()方法来判断
            if (arr[i].equals(ele)) {  //星期一 == 星期一  判断字面上内容是否相同，判别不出来，要调用 equals()方法来判断
                return i;
            }
        }

        return -1; //-1 约定俗成 -1 表示没找到
    }
}

 

14.二维数组概述和格式1的讲解

1.二维数组概述
    我们学校的Java基础班每个班有很多个学生，所以，可以用数组来存储，而我们又同时有很多个Java基础班。
    这个也应该用一个数组来存储。如何来表示这样的数据呢?Java就提供了二维数组供我们使用
    由此可见：其实二维数组其实就是每一个元素为一维数组的数组。
2.二维数组格式1
    数据类型[][] 变量名 = new 数据类型[m][n];
    m表示这个二维数组有多少个一维数组 必须写上
    n表示每一个一维数组的元素个数 可选
    举例:
        int[][] arr = new int[3][2];
        定义了一个二维数组arr
        这个二维数组有3个一维数组，名称是arr[0],arr[1],arr[2]
        每个一维数组有2个元素，可以通过arr[m][n]来获取
            表示获取第m+1个一维数组的第n+1个元素
3.注意事项
    A:以下格式也可以表示二维数组
        a:数据类型 数组名[][] = new 数据类型[m][n];
        b:数据类型[] 数组名[] = new 数据类型[m][n];
        这两种格式不推荐使用
    B:注意下面定义的区别
        int x,y;
        int[] x,y[];    
        
        区别是:
         int[] x,y[];//定义了两个数组 一个是一维数组x 一个是二维数组y
          x=new int[3];    
                y=new int[3][];
                
4.案例演示
    定义二维数组，输出二维数组名称，输出每一个一维数组名称，输出二维数组的2个元素

public class MyTest {
    public static void main(String[] args) {
        //二维数组：元素为一维数组的数组。就是的元素他是一维数组，那么这个数组我们叫做二维数组。
        //二维数组的动态初始化语法

        // 2 表示二维数组的长度是 2
        // 3 表示二维数组中一维数组的长度，那么3这个参数，写与不写还是有区别的。
        int[][] arr = new int[2][3];

        //其他的写法
        int arr2[][] = new int[2][3];

        int[] arr3[] = new int[2][3];

    }
}

15.二维数组格式1的内存图解

对上边的操作画内存图

public class MyTest2 {
    public static void main(String[] args) {
        //二维数组：元素为一维数组的数组。就是的元素他是一维数组，那么这个数组我们叫做二维数组。
        //二维数组的动态初始化语法

        // 2 表示二维数组的长度是 2
        // 3 表示二维数组中一维数组的长度，那么3这个参数，写与不写还是有区别的。
        int[][] arr = new int[2][3];
        System.out.println(arr[0]); //取的是二维数组中的第一个一维数组
        System.out.println(arr[1]); //取的是二维数组中的第二个一维数组

        arr[0][0] = 20;
        arr[0][1] = 30;
        arr[0][2] = 40;
        System.out.println(arr[0][0]);
        System.out.println(arr[0][1]);
        System.out.println(arr[0][2]);

        arr[1][0] = 90;
        arr[1][1] = 100;
        arr[1][2] = 600;
        System.out.println(arr[1][0]);
        System.out.println(arr[1][1]);
        System.out.println(arr[1][2]);

        //引用数据类型：数组，类，接口，都属于引用数据类型， 简单些，需要new的都属于引用数据类型。


    }
}

 

16.二维数组格式2的讲解及其内存图解

1.二维数组格式2
    数据类型[][] 变量名 = new 数据类型[m][];
        m表示这个二维数组有多少个一维数组
        这一次没有直接给出一维数组的元素个数，可以动态的给出。
    举例：
        int[][] arr = new int[3][];
        arr[0] = new int[2];
        arr[1] = new int[3];
        arr[2] = new int[1];
2.案例演示
    定义一个二维数组,输出二维数组的名称和二维数组的的每一个一维数组,然后动态给二维数组赋值一维数组
    再次输出二维数组中的每一个一维数组,给二维数组中的元素赋值,输出对应的元素值

public class MyTest3 {
    public static void main(String[] args) {
        //二维数组：元素为一维数组的数组。就是的元素他是一维数组，那么这个数组我们叫做二维数组。
        //二维数组的动态初始化语法

        // 2 表示二维数组的长度是 2
        // 3 表示二维数组中一维数组的长度 如果不指定，那么就不会帮你初始化二维数组中的一维数组。。
        int[][] arr = new int[2][];
        System.out.println(arr[0]); //取的是二维数组中的第一个一维数组
        System.out.println(arr[1]); //取的是二维数组中的第二个一维数组
        int[] aa = new int[2];
        aa[0] = 100;
        aa[1] = 200;
        arr[0] = aa;

        int[] bb = new int[2];
        bb[0] = 30;
        bb[1] = 50;
        arr[1] = bb;

        System.out.println(arr[0]); //取的是二维数组中的第一个一维数组
        System.out.println(arr[1]); //取的是二维数组中的第二个一维数组

        arr[0][0] = 20;
        arr[0][1] = 30;
        arr[1][0] = 50;
        arr[1][1] = 60;
        int a = arr[0][0];
        int b = arr[0][1];
        int c = arr[1][0];
        int d = arr[1][1];
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        System.out.println(d);
    }
}

17.二维数组格式3的讲解及其内存图解

1.二维数组格式3
        数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}...};
    简化版:
        数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};
    这个格式属于静态初始化:由我们指定具体的元素值,由系统给分配长度
        举例: 
            int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
            int[][] arr = {{1,2,3},{5,6},{7}};
2.案例演示
    定义一个二维数组,打印每一个二维数组中的一维数组,在打印每一个二维数组中的元素

public class MyTest {
    public static void main(String[] args) {
        //二维数组的静态初始化
        int[][] arr = new int[][]{{20, 30}, {50, 30}, {2, 5, 3, 5, 9}};

        //简写

        int[][] arr2 = {{20, 30}, {50, 30}, {2, 5, 3}};

        int length = arr.length;
        System.out.println(length); //3

        System.out.println(arr[0].length); //2

        int length1 = arr[arr.length - 1].length;

        System.out.println(length1); //5
    }
}

二维数组中三个数组图解 

public class MyTest {
    public static void main(String[] args) {
        int[][] arr1 = new int[2][2];
        arr1[0][0] = 20;
        arr1[0][1] = 200;

        int[][] arr2 = new int[2][2];
        arr2[0][0] = 120;
        arr2[0][1] = 36;

        int[][] arr3 = arr1;
        arr3[0][0] = 88;


        System.out.println(arr1[0][0]); //88
        System.out.println(arr1[0][1]); // 200
        System.out.println(arr2[0][0]); // 120
        System.out.println(arr2[0][1]); // 36
        System.out.println(arr3[0][0]); // 88
        System.out.println(arr3[0][1]); // 200

    }
}

18.二维数组练习1遍历

1.
    需求：二维数组遍历
    外循环控制的是二维数组的长度，其实就是一维数组的个数。
    内循环控制的是一维数组的长度。

public class MyTest {
    public static void main(String[] args) {
        int[][] arr = new int[][]{{20, 30}, {50, 30, 39, 36}, {2, 5, 3, 5, 9}};


        //二维数组的遍历

        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
            for (int j = 0; j < arr[i].length; j++) {
                System.out.println(arr[i][j]);
            }
        }

    }
}

19.二维数组练习2求和

1.案例演示
    需求：公司年销售额求和
    某公司按照季度和月份统计的数据如下：单位(万元)
    第一季度：22,66,44
    第二季度：77,33,88
    第三季度：25,45,65
    第四季度：11,66,99

public class MyTest3 {
    public static void main(String[] args) {

        //ctrl+shift+/ 多行注释
       


        int[][] arr = new int[4][3];
        //ctrl+ / 单行注释
        // arr[0][0] = 22;
        // arr[0][1] = 66;
        // arr[0][2] = 44;
        arr[0] = new int[]{22, 66, 44};
        arr[1] = new int[]{77, 33, 88};
        arr[2] = new int[]{25, 45, 65};
        arr[3] = new int[]{11, 66, 99};

        //遍历求和
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                sum = sum + arr[i][j];
            }
        }


        System.out.println("总销售额是：" + sum + "万元");


        System.out.println("================================");

        int[][] arr2 = {{22, 66, 44}, {77, 33, 88}, {25, 45, 65}, {11, 66, 99}};


        //int x, y; //定义了两个int 类型的变量，一个x 一个y

        //定义了两个数组，一个是一维数组x  一个是二维数组y
        int[] x, y[];
        x = new int[2];
        y = new int[2][3];

    }
}

2.需求：打印杨辉三角形(行数可以键盘录入)

        1
        1 1    
        1 2 1
        1 3 3 1
        1 4 6 4 1 
        1 5 10 10 5 1

分析：看这种图像的规律
    A:任何一行的第一列和最后一列都是1
    B:从第三行开始，每一个数据是它上一行的前一列和它上一行的本列之和。

步骤：
    A:首先定义一个二维数组。行数如果是n，我们把列数也先定义为n。
      这个n的数据来自于键盘录入。
    B:给这个二维数组任何一行的第一列和最后一列赋值为1
    C:按照规律给其他元素赋值
        从第三行开始，每一个数据是它上一行的前一列和它上一行的本列之和。
    D:遍历这个二维数组。

import java.util.Scanner;
public class MyTest {
    public static void main(String[] args) {
        

        Scanner sc = new Scanner(System.in);
        System.out.println("请输入行数");
        int n = sc.nextInt();
        //定义二维数组，让行数和列数一样
        int[][] arr = new int[n][n];
        //1.首尾元素为1
        for (int i = 0; i < arr.length; i++) {
            arr[i][0] = 1;
            //arr[i][arr.length - 1] = 1;
            arr[i][i] = 1;

        }
        //设置中间元素
        //从第三行开始，第二列开始，中间的数字，等于他上一行的前一列和上一行的本列之和
        for (int i = 2; i < arr.length; i++) {
            for (int j = 1; j <= i - 1; j++) {
                arr[i][j] = arr[i - 1][j - 1] + arr[i - 1][j];
            }
        }

        //3.打印三角形
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j <= i; j++) {
                System.out.print(arr[i][j] + "t");
            }
            System.out.println();
        }

    }
}

20.思考题Java中的参数传递问题及图解

案例演示
    看程序写结果，并画内存图解释
    public static void main(String[] args) {

        int a = 10;
        int b = 20;
        System.out.println("a: " + a + ",b: " + b);
        change(a,b);
        System.out.println("a: " + a + ",b: " + b);

        int[] arr = {1,2,3,4,5};
        change(arr);
        System.out.println(arr[1]);
    }

    public static void change(int a,int b)  {

        System.out.println("a: " + a + ",b: " + b);
        a = b;
        b = a + b;
        System.out.println("a: " + a + ",b: " + b);
    }

    public static void change(int[] arr){
        for(int x = 0 ; x < arr.length ; x++){
            if(arr[x]%2 == 0){
                arr[x] *= 2;
            }
        }
    }

递归 递归的概念

1.递归概述: 方法定义中调用方法本身的现象
2.递归注意事项
    要有出口，否则就是死递归
    次数不能太多，否则就内存溢出
3.递归举例:    我们学编程…

 

递归解决问题的思想及图解

画图演示:递归解决问题的思想及图解(5!)

public class MyTest {
    public static void main(String[] args) {
        //递归：java中，在方法中，调用方法本身的一种现象。
        //递归的注意事项：
        // 1.递归要有出口，不然就是死递归。死递归就会栈溢出。  StackOverflowError
        // 2. 递归的次数不宜过多，过多会造成栈溢出。
        //3. 递归所体现的思想，是一种拆分合并的思想。
        diGui(10);
    }

    public static void diGui(int num) {
        num--;
        if (num <= 0) {
            return; //结束方法
        }
        System.out.println("方法调用了");

        diGui(num);
    }

}

递归求阶乘的代码实现及内存图解

1.案例演示
    需求：求5的阶乘
    循环实现
    递归实现
2.画图演示:    递归实现求5的阶乘的内存图 

用循环求5！        

public class MyTest {
    public static void main(String[] args) {
        //5的阶乘  5*4*3*2*1

        int num = 1;


        for (int i = 5; i >= 1; i--) {
            num = num * i;
        }

        System.out.println(num);

    }
}

用递归求5！

public class MyTest2 {
    public static void main(String[] args) {
        //用递归的思想：来解决 5的阶乘

        int r = jieCheng(5);
        System.out.println(r);
    }

    public static int jieCheng(int num) {
        if (num == 1) {
            return 1;
        } else {
            return num * jieCheng(num - 1);
        }
    }
}

不死神兔问题

1.案例演示:    需求：兔子问题(斐波那契数列)
    有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问第二十个月的兔子对数为多少？
    由此可见兔子对象的数据是：1 , 1 , 2 , 3 , 5 , 8 ...

public class MyTest {
    public static void main(String[] args) {
        int r = num(20);
        System.out.println(r);
    }
     public static int num(int m){
        if(m==1||m==2){
         return 1;
        }else {
         return num(m-1)+num(m-2);
        }
    }
}