jgcs123

导航

 
day04-05(Debug、基础知识练习)

Debug

1. Debug

1.1 Debug概述

Debug:是供程序员使用的程序调试工具，它可以用于查看程序的执行流程，也可以用于追踪程序执行过程来调试程序。

1.2 Debug操作流程

Debug调试，又被称为断点调试，断点其实是一个标记，告诉我们从哪里开始查看

  1. 如何加断点

  2. 如何运行加了断点的程序

  3. 看哪里

  4. 点哪里

  5. 如何删除断点

 

1.2.1 如何加断点

选择要设置断点的代码行，在行号的区域后面单击鼠标左键即可。

1.2.2 如何运行加了断点的程序

在代码区域右键Debug执行

1.2.3 看哪里

看Debugger窗口

1.2.4 点哪里

点Step Into(F7)这个箭头，也可以直接按F7

要结束就点sotp

1.2.5 如何删除断点

选择要删除的断点，单击鼠标左键即可。

 

一次全部删除：

 

1.3 Debug的使用

package com.dongdong_01;
​
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);
    }
}

Debug可以清楚的看到代码执行的流程

 

1.4 Debug使用

  • 查看方法调用的执行流程

注意事项：

关于键盘录入参与断点调试的时候一定要记得录入数据！

 

 

基础知识练习

1. 案例：减肥计划

需求:输入星期数，显示今天的减肥活动

周一:跑步

周二:游泳

周三:慢走

周四:动感单车

周五:拳击

周六:爬山

周日:好好吃一顿

 

思路：

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

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

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

package com.dongdong;
​
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 (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 if (week == 7) {
            System.out.println("好好吃一顿");
        }
    }
​
}

 

 

案例：减肥计划(使用switch)

 

 

package com.dongdong;
​
​
import java.util.Scanner;
​
//导包：1. 手动导包 import java.util.Scanner;
//      2. 快捷键导包 Alt+Enter
//      3. 自动导包：
public class Test02 {
​
    public static void main(String[] args) {
​
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个星期数：");
​
        int week = sc.nextInt();
​
        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整除

    x%10== 7 x/10%10==7 x%7==0

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

package com.dongdong;
​
public class Test03 {
    public static void main(String[] args) {
        for (int x = 1; x < 100; x++) {
            if (x % 10 == 7 || x / 10 % 10 == 7 || x % 7 == 0) {
                System.out.println(x);
            }
        }
    }
}

 

3. 案例：不死神兔

需求:有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，

假如兔子都不死，问第二十个月的兔子对数为多少?

规律:

从第三个数据开始，每一个数据是前两个数据之和。第1个，第2个数据是已知的。

思路：

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

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

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

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

 

package com.dongdong;
​
public class Test04 {
    public static void main(String[] args) {
        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];
        }
        System.out.println("第二十个月的兔子对数为" + arr[19]);
    }
}

 

4. 百钱百鸡

案例：百钱百鸡

  • 需求:我国古代数学家张丘建在《算经》一书中提出的数学问题:鸡翁一值钱五，鸡母一值钱三，鸡雏三值钱一。

    百钱买百鸡，问鸡翁、鸡母、鸡雏各几何?

  • 分析:

  • 假设鸡翁x只，鸡母y只，鸡维z只，则下面的式子是成立的

    x + y+ z= 100;

    5x + 3y + z/3 = 100;

  • 如果单独只看一种鸡型，则下面的式子是成立的

    0<=x<=20

    0<=y<=33

    0<=z<=100

思路:

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

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

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

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

package com.dongdong;
​
​
/*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. 判断该元素是否满足条件，如果满足条件就累加

    arr[x]%10!=7 arr[x]/10%10 !=7 arr[x]%2== 0

  5. 输出求和变量的值

 

package com.dongdong;
​
public class Test06 {
​
    public static void main(String[] args) {
​
        int[] arr = {68, 27, 95, 88, 171, 996, 51, 210};
        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. 案例： 数组内容相同

 

需求：设计一个方法，用于比较两个数组的内容是否相同

package com.dongdong;
​
public class Test07 {
    public static void main(String[] args) {
        int[] arr = {11,22,33,44,55};
        int[] arr2 = {11,22,33,44,55};
​
        //调用方法，用变量接收
        boolean flag = compare(arr,arr2);
        System.out.println(flag);
    }
​
    public static boolean compare(int[] arr,int[] arr2){
​
        if (arr.length != arr2.length){
            return false;
        }
        for (int x = 0; x<arr.length; x++){
            if (arr[x] != arr2[x]){
                return false;
            }
        }
        return true;
    }
}

 

7. 案例：查找

需求:

已知一个数组arr = {19,28,37,46,50};键盘录入一个数据，查找该数据在数组中的索引，并在控制台输出找到的索引值。

 

分析:

键盘录入一个数据后，让这个数据和数组中的每一个元素进行比较，如果数据值相等，返回该数据值对应的索引即可。

但是，假如录入了一个数组中不存在的数据，这个时候，就没有任何内容输出了，很明显是有问题的，在实际开发中，如果对应的索引不存在，我们一般都是返回一个负数，而且经常用-1来表示。

 

思路:

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

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

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

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

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

  6. 输出索引变量

package com.dongdong;

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();
        
        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. 遍历数组

package com.dongdong;

public class Test09 {
    public static void main(String[] args) {
        int[] arr = {19, 28, 37, 46, 50};
        reveres(arr);
        printArray(arr);
    }
    /*两个明确:
            返回值类型: void
            参数: int[] arr*/
    public static void reveres(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;
        }
    }

    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. 输出平均分

package com.dongdong;

import java.util.Scanner;

public class Test10 {
    public static void main(String[] args) {
        int[] arr = new int[6];
        Scanner sc = new Scanner(System.in);

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

    }

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

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

}

 

 

posted on 2021-06-18 22:52  Dongdong98  阅读(165)  评论(0)    收藏  举报
 
博客园  ©  2004-2025
浙公网安备 33010602011771号 浙ICP备2021040463号-3