Java SE之基础篇(八)——IDEA中DeBug调试以及综合案例练习

前言

​​上篇文章​​我们给大家介绍了java中比较重要的一个知识点——​方法​的应用和使用。主要给大家介绍了方法的定义和使用，包括无参方法定义和使用、带参方法定义和使用、带返回值方法的定义和使用以及在使用方法的时候应该注意的一些事项以及我们把一般在定义方法的时候常用的一些格式。另外还介绍了方法的重载以及方法的参数传递。最后我们通过两个综合的案例给大家将所学的方法中的相关知识进行了相应的串联。最后通过一张思维导图将本文所学的方法中的相关知识进行了总结，给读者一个清晰的学习思路，并且也间接地教读者在学习一门新的编程语言的时候我们应该如何去总结相应的知识点，从而在读者脑海中形成一个知识框架，这点对于初学者来说是比较重要的。本文给大家介绍的就是在IDEA中通过DeBug来调试我们的代码，这个功能在我们日后的开发以及学习中是至关重要的，因为我们写的代码不可能一直是正确的，当代码处理问题之后，我们就可以通过这个模式很好的找出我们代码的问题所在。其实我们写的代码有两种错误，一种是编译错误，顾名思义就是连编译也无法通过的，比如常见的空指针异常、数组越界等典型的编译器可以识别的错误，这个时候我们编译器就会直接告诉我们具体的错误在哪里。但是还有一种错误就是功能错误，这种错误是最隐晦的，编译能通过，编译器也不报错，但是就是达不到我们功能所预实现的功能。这种是我们以后在写代码过程中反而经常遇见的，这个时候，我们就得通过DeBug模式进行调试了，看看每一行代码程序是怎么运行的，到底返回给了我们什么结果。因此，这个模式至关重要的，需要我们熟练掌握其用法。

  在IEDA中，我们执行程序有两种模式，一种是直接运行，也就是我们在前面直接给出的运行结果图，它不会给我们每行代码的运行结果，只给我们整个程序最终的运行结果。还有一种是DeBug模式，其实建议大家在今后的学习，最好用DeBug模式启动我们的程序，因为我们会清晰地看到程序在运行的整个过程，每一行代码做了什么事情，既能发现我们代码的错误，更重要的是能够帮助我们初学者学习java执行流程，对我们今后学习Java Virtual Machine(JVM)有很大的帮助，当然也对我们阅读别人的代码有较快的掌握。因此，这个模式是特别重要的，这也就是我为什么会花一整篇文章去给大家介绍这个功能的原因。在我们学习Java过程中，我们不仅要学习java相关知识，更要学习别人优秀的代码撰写，这点非常重要，只有经常阅读别人写的代码，才能让自己的代码写的更加的具有健壮性和鲁棒性。在刚开始的时候，我们在撰写代码只要能够实现相关需求的功能即可，当然这也是第一步，但是我们不能一直这么写，那样的话，我们只能是处于一种初级程序员的水准，我们一定要不断优化我们的代码，不断地向高级程序员进阶。其实不仅仅是java开发工程师，其他语言开发工程师也是一样的。另外还有一点就是，我们在阅读本文的时候，其实不仅仅要看DeBug工具是如何使用的，更重要的是理解代码是怎么看的，怎么分析问题所在的，当然这与我们写代码以及分析代码的能力相关，不是一蹴而就的，不过我们现在就要养成这种分析问题的能力。

  首先我们给大家介绍的就是DeBug模式的相关操作。

一、DeBug模式

  我们前面也介绍了，DeBug模式其实就是供程序员使用的程序调试工具，它可以用于查看程序的执行流程，也可以用于追踪程序执行过程来调试程序。我们接下来通过一个案例来详细教大家DeBug模式操作流程。首先我们给出测试的案例，具体实现如下：

public class DebugDemo {
    public static void main(String[] args) {
        //定义两个变量
        int i = 10;
        int j = 20;

        //求和
        int sum = i + j;

        //输出结果
        System.out.println("sum:" + sum);
    }
}

  首先我们给出其整体的运行结果，也就是我们经常说的​​run​​模式下的，具体的运行结果如下：

接下来我们详细给大家介绍针对这段代码我们是如何调试的。

首先我们要​​选择断点​​，选择要设置断点的代码行，在行号的区域后面单击鼠标左键即可。具体的操作及效果如下：

接着，我们就是​​​通过DeBug模式​​​来运行我们的这段代码，在代码区域右键Debug执行，具体的操作及效果图如下：

然后就是看​​​Debugger窗口​​​，具体看如图所示的内容：

同时也要看​​​Console窗口​​​，具体看的内容如下：

  接下来就是让debug进行执行我们相关的语句，点 ​​Step Into (F7)​​ 这个箭头，也可以直接按F7，具体效果如下：

最后就是​​​删除断点​​​了，我们如果是单一的断点的话，可以直接选择要删除的断点，单击鼠标左键即可，具体如下：

当然，如果我们代码比较长的话，不可能只有一个断点，如果断点比较多的话，那么我们删除起来就比较复杂，因此，我们可以一次性全部删除，具体操作步骤如下：

  这就是我们整个代码调试的过程，学起来很简单的，接下来就是需要大家不断地练习的一个过程，我们在今后的开发中一定会经常用到这个模式，所以希望大家定要好好掌握。我们在文章的开头也提到过，这个模式至关重要，我们关键要掌握如何通过这个模式分析我们把的代码，这就需要我们通过大量的练习以及分析代码的能力慢慢的积累了，不可能因为这一篇文章就会掌握，这篇文章只是一个入门，初步教大家如何去调试。为了方便大家练习，我们在给出两个测试案例供大家练习，案例都很简单，主要目的是为了让大家练习。

  ​案例一：​ 查看循环求偶数和的执行流程

  由于其实现比较简单，再说又是为了大家练习Debug模式，因此，这里就不阐述实现的思路，我们直接给出实现的代码，具体的实现内容如下：

public class DebugTest01 {
    public static void main(String[] args) {
        //定义求和变量
        int sum = 0;

        //循环求偶数和
        for (int i = 1; i <= 10; i++) {
            if (i % 2 == 0) {
                sum += i;
            }
        }

        //输出结果
        System.out.println("1-10之间的偶数和是：" + sum);
    }
}

  最后就是我们给出该代码执行的最后结果，具体如下：

​案例二​：查看方法调用的执行流程

  同理，我们也是只给出实现的过程，不阐述实现的思路，具体的实现过程如下：

import java.util.Scanner;

/*
    查看方法调用的执行流程
 */
public class DebugTest02 {
    public static void main(String[] args) {
        //创建对象
        Scanner sc = new Scanner(System.in);

        //接收数据
        System.out.println("请输入第一个整数：");
        int a = sc.nextInt();

        System.out.println("请输入第二个整数：");
        int b = sc.nextInt();

        //调用方法
        int max = getMax(a, b);

        //输出结果
        System.out.println("较大的值是：" + max);
    }

    //获取两个数的较大值
    public static int getMax(int a, int b) {
        if (a > b) {
            return a;
        } else {
            return b;
        }
    }
}

  最后的执行结果如下：

  这就是我们在IDEA中DeBug调试的全部内容，通过这两个案例，相信大家对DeBug的具体操作流程已经有一个相对清晰的认识，但是这两个是远远不够的，在今后代码的执行过程中，希望大家有意无意的可以通过DeBug模式去分析一些别人的代码，这样的话，你会对java内部的运行机制会很清晰，并且随着我们不断地分析代码，我们分析解决问题的能力也会得到很大的提升。接下来，就给大家介绍一些综合案例的练习。

二、综合案例

1、减肥计划

  ​案例一​：输入星期数，显示今天的减肥活动

- 周一：跑步

- 周二：游泳

- 周三：慢走

- 周四：动感单车

- 周五：拳击

- 周六：爬山

- 周日：好好吃一顿

  我们刚看到这个需求的时候，首先就是通过​​if---else if​​来解决，具体的思路如下：

  1:键盘录入一个星期数，用一个变量接收

2:对星期数进行判断，这里用 if 语句实现

   3:在对应的语句控制中输出对应的减肥活动

   根据以上的思路，我们给出以下的代码实现：

import java.util.Scanner;
public class Test01 {
    public static void main(String[] args) {
        //键盘录入一个星期数，用一个变量接收
        Scanner sc = new Scanner(System.in);

        System.out.println("请输入一个星期数：");
        int week = sc.nextInt();

        //对星期数进行判断，这里用 if 语句实现
        if (week < 1 || week > 7) {
            System.out.println("你输入的星期数有误");
        } else if (week == 1) {
            System.out.println("跑步");
        } else if (week == 2) {
            System.out.println("游泳");
        } else if (week == 3) {
            System.out.println("慢走");
        } else if (week == 4) {
            System.out.println("动感单车");
        } else if (week == 5) {
            System.out.println("拳击");
        } else if (week == 6) {
            System.out.println("爬山");
        } else {
            System.out.println("好好吃一顿");
        }
    }
}

  具体的实现结果如下：

  上面的代码已经实现我们的功能，但是很明显代码过于冗余，接下来，我们通过用switch语句将其实现，具体思路如下：

  1:键盘录入一个星期数，用一个变量接收

2:对星期数进行判断，这里用 switch 语句实现

   3:在对应的语句控制中输出对应的减肥活动

   这里，我们多次用到java的第三方包，因此需要我们导包，我们有两种方式进行导包。

  第一种就是​手动导包​​；​​import java.util.Scanner;​​

第二种就是​快捷键导包​​； ​​Alt+Enter​​

第三种就是​自动导包​

  通过以上思路的描述，我们对其进行代码实现，具体如下：

import java.util.Scanner;
public class Test02 {
    public static void main(String[] args) {
        //键盘录入一个星期数，用一个变量接收
        Scanner sc = new Scanner(System.in);

        System.out.println("请输入一个星期数：");
        int week = sc.nextInt();

        //对星期数进行判断，这里用 switch 语句实现
        switch (week) {
            case 1:
                System.out.println("跑步");
                break;
            case 2:
                System.out.println("游泳");
                break;
            case 3:
                System.out.println("慢走");
                break;
            case 4:
                System.out.println("动感单车");
                break;
            case 5:
                System.out.println("拳击");
                break;
            case 6:
                System.out.println("爬山");
                break;
            case 7:
                System.out.println("好好吃一顿");
                break;
            default:
                System.out.println("你输入的星期数有误");
        }

    }
}

  根据其代码，我们执行的结果如下：

2、逢七跳过

  ​案例二​：朋友聚会的时候可能会玩一个游戏：逢七过。

  ​规则​：从任意一个数字开始报数，当你要报的数字包含7或者是7的倍数时都要说：过。 为了帮助大家更好的玩这个游戏，这里我们直接在控制台打印出1-100之间的满足逢七必过规则的数据。 这样，大家将来在玩游戏的时候，就知道哪些数据要说：过。

  针对以上的题意，我们给出如下的思路：

  1:数据在1-100之间，用for循环实现数据的获取

2:根据规则，用if语句实现数据的判断：要么个位是7，要么十位是7，要么能够被7整除

   3:在控制台输出满足规则的数据

  根据该思路我们给出具体的代码实现，具体过程如下：

public class Test03 {
    public static void main(String[] args) {
        //数据在1-100之间，用for循环实现数据的获取
        for(int x=1; x<=100; x++) {
            //根据规则，用if语句实现数据的判断：要么个位是7，要么十位是7，要么能够被7整除
            if(x%10==7 || x/10%10==7 || x%7==0) {
                //在控制台输出满足规则的数据
                System.out.println(x);
            }
        }
    }
}

  具体执行的结果如下：

3、不死神兔

  ​案例三​：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问第二十个月的兔子对数为多少？

  根据该题意，我们给出相应的思路：

  1:为了存储多个月的兔子对数，定义一个数组，用动态初始化完成数组元素的初始化，长度为20

2:因为第1个月，第2个月兔子的对数是已知的，都是1，所以数组的第1个元素，第2个元素值也都是1

  3:用循环实现计算每个月的兔子对数

  4:输出数组中最后一个元素的值，就是第20个月的兔子对数

  我们根据思路给出相应的实现过程，具体代码如下：

public class Test04 {
    public static void main(String[] args) {
        //为了存储多个月的兔子对数，定义一个数组，用动态初始化完成数组元素的初始化，长度为20
        int[] arr = new int[20];

        //因为第1个月，第2个月兔子的对数是已知的，都是1，所以数组的第1个元素，第2个元素值也都是1
        arr[0] = 1;
        arr[1] = 1;

        //用循环实现计算每个月的兔子对数
        for(int x=2; x<arr.length; x++) {
            arr[x] = arr[x-2] + arr[x-1];
        }

        //输出数组中最后一个元素的值，就是第20个月的兔子对数
        System.out.println("第二十个月兔子的对数是：" + arr[19]);
    }
}

  我们给出了每一思路转换为代码的过程，具体的执行结果如下：

4、百钱白鸡

  ​案例四​：我国古代数学家张丘建在《算经》一书中提出的数学问题：鸡翁一值钱五，鸡母一值钱三，鸡雏三值钱一。百钱买百鸡，问鸡翁、鸡母、鸡雏各几何？

   我们根据题意给出相应的实现思路：

   1:第1层循环，用于表示鸡翁的范围，初始化表达式的变量定义为 x=0，判断条件是x<=20

2:第2层循环，用于表示鸡母的范围，初始化表达式的变量定义为 y=0，判断条件是y<=33

  3:这个时候，用于表示鸡雏的变量 z = 100 – x – y

  4:判断表达式 z%3==0 和表达式 5*x + 3*y + z/3 = 100 是否同时成立，如果成立，输出对应的 x，y，z 的值，就是对应的鸡翁，鸡母，鸡雏的值

  通过该思路我们将其转化为如下的代码：

public class Test05 {
    public static void main(String[] args) {
        //第1层循环，用于表示鸡翁的范围，初始化表达式的变量定义为 x=0，判断条件是x<=20
        for(int x=0; x<=20; x++) {
            //第2层循环，用于表示鸡母的范围，初始化表达式的变量定义为 y=0，判断条件是y<=33
            for(int y=0; y<=33; y++) {
                //这个时候，用于表示鸡雏的变量 z = 100 – x – y
                int z = 100 - x - y;

                //判断表达式 z%3==0 和表达式 5*x + 3*y + z/3 = 100 是否同时成立
                if(z%3==0 && 5*x+3*y+z/3==100) {
                    System.out.println(x+","+y+","+z);
                }
            }
        }
    }
}

  该案例最终执行的结果如下：

5、数组元素求和

  ​案例五​：有这样的一个数组，元素是{68,27,95,88,171,996,51,210}。求出该数组中满足要求的元素和， 要求是：求和的元素个位和十位都不能是7，并且只能是偶数。

  根据题意我们给出相应的实现思路：

  1:定义一个数组，用静态初始化完成数组元素的初始化

2:定义一个求和变量，初始值是0

  3:遍历数组，获取到数组中的每一个元素

  4:判断该元素是否满足条件，如果满足条件就累加

  5:输出求和变量的值

  我们根据该思路实现相应的代码，具体的实现如下：

public class Test06 {
    public static void main(String[] args) {
        //定义一个数组，用静态初始化完成数组元素的初始化
        int[] arr = {68, 27, 95, 88, 171, 996, 51, 210};

        //定义一个求和变量，初始值是0
        int sum = 0;

        //遍历数组，获取到数组中的每一个元素
        for(int x=0; x<arr.length; x++) {
            //判断该元素是否满足条件，如果满足条件就累加
            if(arr[x]%10!=7 && arr[x]/10%10!=7 && arr[x]%2==0) {
                sum += arr[x];
            }
        }

        //输出求和变量的值
        System.out.println("sum:" + sum);
    }
}

  该题最终的答案如下：

6、判断两个数组是否相同

  ​案例六​：定义一个方法，用于比较两个数组的内容是否相同

  根据题意我们给出以下的思路：

- 1:定义两个数组，分别使用静态初始化完成数组元素的初始化

- 2:定义一个方法，用于比较两个数组的内容是否相同

- 3:比较两个数组的内容是否相同，按照下面的步骤实现就可以了

  首先比较数组长度，如果长度不相同，数组内容肯定不相同，返回false

  其次遍历，比较两个数组中的每一个元素，只要有元素不相同，返回false

  最后循环遍历结束后，返回true

- 4:调用方法，用变量接收

- 5:输出结果

  根据其思路我们给出以下的实现代码，具体如下：

public class Test07 {
    public static void main(String[] args) {
        //定义两个数组，分别使用静态初始化完成数组元素的初始化
        int[] arr = {11, 22, 33, 44, 55};
        //int[] arr2 = {11, 22, 33, 44, 55};
        int[] arr2 = {11, 22, 33, 44, 5};


        //调用方法，用变量接收
        boolean flag = compare(arr,arr2);
        //输出结果
        System.out.println(flag);
    }

    //定义一个方法，用于比较两个数组的内容是否相同
    /*
        两个明确：
            返回值类型：boolean
            参数：int[] arr, int[] arr2
     */
    public static boolean compare(int[] arr, int[] arr2) {
        //首先比较数组长度，如果长度不相同，数组内容肯定不相同，返回false
        if(arr.length != arr2.length) {
            return false;
        }

        //其次遍历，比较两个数组中的每一个元素，只要有元素不相同，返回false
        for(int x=0; x<arr.length; x++) {
            if(arr[x] != arr2[x]) {
                return false;
            }
        }

        //最后循环遍历结束后，返回true
        return true;
    }
}

  我们首先给出了两个相同的数组，然后又给出了两个不同的数组来测试我们的代码，具体的执行结果如下：

  这里我们看得出在要改变两个数组的时候，必须通过手动来改​​arr1​​​和​​arr2​​才能做到，并且还得重新运行代码才能判断是否相等，过于繁杂。​​​现在给大家出两个个问题​​​：

​问题一​：在现已有代码的是基础上，我们如何通过在控制台输入两个数组，然后后台直接判断是否这两个代码相等

​问题二​​：在问题一的基础上，我随便输入n个数组，然后通过实现代码来找出哪些数组是相等的，一共有几组相等的，把​​​​不相等​​​​的数组打印在控制台上。

我们一直强调要多加练习，java光看是没用的，还需要我们要动手实践，可能我们看代码感觉很简单，会给我们造成一种“我上我也行”的错觉。但是，当我们真正去实现的时候就会感觉到其实没有那么简单。因此，这两个问题希望大家认真思考，自己通过代码将其实现，在这里就不给相应的答案了。其实我们在找工作很多面试题就是这么出的，给你一个简单问题，然后循序渐进，其实就是考察我们解决实际问题的能力以及知识迁移的能力。这个能力对于我们开发者来说是至关重要的。因此，我们在日常生活中就要有意的去培养。

7、查找元素在数组中出现的索引位置

  ​案例七​：已知一个数组 arr = {19, 28, 37, 46, 50}; 键盘录入一个数据，查找该数据在数组中的索引。并在控制台输出找到的索引值。如果没有查找到，则输出-1。

  根据其意义我们给出如下的思路：

  1:定义一个数组，用静态初始化完成数组元素的初始化

2:键盘录入要查找的数据，用一个变量接收

  3:定义一个索引变量，初始值为-1

  4:遍历数组，获取到数组中的每一个元素

  5:拿键盘录入的数据和数组中的每一个元素进行比较，如果值相同，就把该值对应的索引赋值给索引变量,并结束循环

  6:输出索引变量

  其实现的过程如下：

import java.util.Scanner;
public class Test08 {
    public static void main(String[] args) {
        //定义一个数组，用静态初始化完成数组元素的初始化
        int[] arr = {19, 28, 37, 46, 50};

        //键盘录入要查找的数据，用一个变量接收
        Scanner sc = new Scanner(System.in);

        System.out.println("请输入要查找的数据：");
        int number = sc.nextInt();

        /*
        //定义一个索引变量，初始值为-1
        int index = -1;

        //遍历数组，获取到数组中的每一个元素
        for(int x=0; x<arr.length; x++) {
            //拿键盘录入的数据和数组中的每一个元素进行比较，如果值相同，就把该值对应的索引赋值给索引变量,并结束循环
            if(arr[x] == number) {
                index = x;
                break;
            }
        }
        */

        //调用方法
        int index = getIndex(arr, number);

        //输出索引变量
        System.out.println("index: " + index);


    }

    //查找指定的数据在数组中的索引
    /*
        两个明确：
            返回值类型：int
            参数：int[] arr, int number
     */
    public static int getIndex(int[] arr, int number) {
        //定义一个索引变量，初始值为-1
        int index = -1;

        //遍历数组，获取到数组中的每一个元素
        for(int x=0; x<arr.length; x++) {
            //拿键盘录入的数据和数组中的每一个元素进行比较，如果值相同，就把该值对应的索引赋值给索引变量,并结束循环
            if(arr[x] == number) {
                index = x;
                break;
            }
        }

        //返回索引
        return index;
    }
}

  具体执行的结果如下：

8、数组元素反转

  ​案例八​：已知一个数组 arr = {19, 28, 37, 46, 50}; 用程序实现把数组中的元素值交换，交换后的数组 arr = {50, 46, 37, 28, 19}; 并在控制台输出交换后的数组元素。

  根据其需求我们给出相应的实现思路：

  1:定义一个数组，用静态初始化完成数组元素的初始化

2:循环遍历数组，这一次初始化语句定义两个索引变量，判断条件是开始索引小于等于结束索引

  3:变量交换

  4:遍历数组

  根据题意及实现的思路我们转化为如下的代码：

public class Test09 {
    public static void main(String[] args) {
        //定义一个数组，用静态初始化完成数组元素的初始化
        int[] arr = {19, 28, 37, 46, 50};

        //调用反转的方法
        reverse(arr);

        //遍历数组
        printArray(arr);
    }

    /*
        两个明确：
            返回值类型：void
            参数：int[] arr
     */
    public static void reverse(int[] arr) {
        //循环遍历数组，这一次初始化语句定义两个索引变量，判断条件是开始索引小于等于结束索引
        for (int start = 0, end = arr.length - 1; start <= end; start++, end--) {
            //变量交换
            int temp = arr[start];
            arr[start] = arr[end];
            arr[end] = temp;
        }
    }

    /*
        两个明确：
            返回值类型：void
            参数：int[] arr
     */
    public static void printArray(int[] arr) {
        System.out.print("[");

        for (int x = 0; x < arr.length; x++) {
            if (x == arr.length - 1) {
                System.out.print(arr[x]);
            } else {
                System.out.print(arr[x] + ", ");
            }
        }

        System.out.println("]");
    }
}

  具体执行的结果如下：

9、评委打分

  ​案例九​：在编程竞赛中，有6个评委为参赛的选手打分，分数为0-100的整数分，选手的最后得分为：去掉一个最高分和一个最低分后 的4个评委平均值 (不考虑小数部分)。

  根据题意我们给出以下的实现思路：

  1:定义一个数组，用动态初始化完成数组元素的初始化，长度为6

2:键盘录入评委分数

  3:由于是6个评委打分，所以，接收评委分数的操作，用循环改进

  4:定义方法实现获取数组中的最高分(数组最大值)，调用方法

  5:定义方法实现获取数组中的最低分(数组最小值) ，调用方法

  6:定义方法实现获取数组中的所有元素的和(数组元素求和) ，调用方法

  7:按照计算规则进行计算得到平均分

  8:输出平均分

  该思路对应实现的代码如下：

import java.util.Scanner;

public class Test10 {
    public static void main(String[] args) {
        //定义一个数组，用动态初始化完成数组元素的初始化，长度为6
        int[] arr = new int[6];

        //键盘录入评委分数
        Scanner sc = new Scanner(System.in);

        //由于是6个评委打分，所以，接收评委分数的操作，用循环改进
        for(int x=0; x<arr.length; x++) {
            System.out.println("请输入第" + (x + 1) + "个评委的打分：");
            arr[x] = sc.nextInt();
        }

        //定义方法实现获取数组中的最高分(数组最大值)，调用方法
        int max = getMax(arr);

        //定义方法实现获取数组中的最低分(数组最小值) ，调用方法
        int min = getMin(arr);

        //定义方法实现获取数组中的所有元素的和(数组元素求和) ，调用方法
        int sum = getSum(arr);

        //按照计算规则进行计算得到平均分
        int avg = (sum - max - min) / (arr.length - 2);

        //输出平均分
        System.out.println("选手的最终得分是：" + avg);

    }

    /*
        两个明确：
            返回值类型：int
            参数：int[] arr
     */
    public static int getSum(int[] arr) {
        int sum = 0;

        for(int x=0; x<arr.length; x++) {
            sum += arr[x];
        }

        return sum;
    }

    /*
        两个明确：
            返回值类型：int
            参数：int[] arr
     */
    public static int getMin(int[] arr) {
        int min = arr[0];

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

        return min;
    }

    /*
        两个明确：
            返回值类型：int
            参数：int[] arr
     */
    public static int getMax(int[] arr) {
        int max = arr[0];

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

        return max;
    }

    //遍历数组
    public static void printArray(int[] arr) {
        System.out.print("[");

        for (int x = 0; x < arr.length; x++) {
            if (x == arr.length - 1) {
                System.out.print(arr[x]);
            } else {
                System.out.print(arr[x] + ", ");
            }
        }

        System.out.println("]");
    }
}

  具体执行结果如下：

  以上就是全部的案例，我们给出了思路以及相应的实现过程以及实现过程，通过这些案例的练习，相信大家对java中的基本语法有了比较清晰的认识，当然，这些案例对于正在找java工程师开发面试或者笔试都很适用，因此，希望大家认真的学习，全部要搞懂，当然我们读者也可以通过Debug模式进行调试，从而对其进行一个更加熟练的掌握。当然，光有这些练习远远不够，还需要大家更加多的练习，不过这些是很基础的，足以让大家入门。

三、知识汇总

  文章最后，我们将本文介绍的所有知识点通过xmind做一个总结；具体知识点总结如下：

总结

  ​​上篇文章​​我们给大家介绍了java中比较重要的一个知识点——​方法​的应用和使用。主要给大家介绍了方法的定义和使用，包括无参方法定义和使用、带参方法定义和使用、带返回值方法的定义和使用以及在使用方法的时候应该注意的一些事项以及我们把一般在定义方法的时候常用的一些格式。另外还介绍了方法的重载以及方法的参数传递。最后我们通过两个综合的案例给大家将所学的方法中的相关知识进行了相应的串联。最后通过一张思维导图将本文所学的方法中的相关知识进行了总结。本文给大家详细介绍的就是在IDEA中通过DeBug来调试我们的代码，并且为大家准备了两个案例供大家自行调试。另外还通过九个案例让大家属性了java编写代码，并且还留了两个问题供读者去解决，充分让读者在看文章的同时要思考，给读者练习的机会，这一点是很重要的。现在的java发展的如火如荼，在开发这块占据着举足轻重的地位。因此，作为计算机行业的一名开发人员，学习java是很有必要的。让我们一起在java的海洋里遨游吧！！！生命不息，奋斗不止，我们每天努力，好好学习，不断提高自己的能力，相信自己一定会学有所获。正如经典所说：“人不负青山，青山定不负人。”让我们一起向未来！加油！！！