JAVA零基础入门笔记(十)-重载回顾&数组练习

1，回顾

方法在什么时候构成重载：

• 必须在同一个类中
• 方法名必须一致
• 参数必须不一样（参数的个数不一样，参数的类型不一样，类型的顺序不一样）
• 跟返回值没有任何关系

第一个条件，第二个条件，第三个条件必须同时满足，才算方法的重载。

有了方法的重载，会有什么好处呢？

• 针对于方法的定义者：

  ​ 会把同一种功能的方法，他的方法名定义为一样的。就不需要起那么多不同名字的方法了。

• 针对于方法的调用者：

  ​ 就不需要记忆那么多方法名了，同种功能的方法，只要记一个就可以了。

方法的参数传递：

• 调用方法的时候，传递的是基本数据类型

  ​ 在调用方法的时候，传递的都是变量记录的东西，基本数据类型，记录的是真实的值。

  ​ 传递的是值。

• 调用方法的时候，传递的是引用数据类型

  ​ 在调用方法的时候，传递的也是变量记录的东西，引用数据类型，记录的是地址值。

  ​ 传递的是地址值。

Debug（会使用即可）

功能：

​ 可以看代码一步一步是怎么运行的。

• 打断点

  • 如果要看所有的代码

    每一个方法的第一行有效语句前面打上断点。一个方法只要打一个就可以了。

  • 如果要看局部的代码

    哪里不会点哪里

• 运行debug模式

  ​ 右键空白处，点击debug

• 看哪里

  ​ 看下面debugger界面，还有控制台界面。

  ​ debugger界面：方法的运行情况。

  ​ 方法中变量记录值的情况。

  ​ 控制台界面：输出语句的输出情况

  ​ 如果有键盘录入，也需要在控制台录入，否则，debug无法进入到下一步。

• 点击下一步，让debug一步一步的运行起来。

  点击快捷键 F7

  或者用鼠标点击 step into

• 停止debug

  点击控制台左边，红色的方块。（运行指示灯）

• 取消断点

  断点比较少：直接手动点击取消。

  断点比较多：点击控制台左边，多个红色方块重叠的按钮。

2，求和

题目：

有这样的一个数组，元素是{68,27,95,88,171,996,51,210}。

求出该数组中满足要求的元素和，

要求是：求和的元素个位和十位都不能是7，并且只能是偶数

步骤：

1，定义一个数组

2，循环遍历数组得到每一个元素

3，判断每一个元素是否满足条件

4，将满足条件的数字进行累加（此时需要回到循环外面再定义一个求和变量）

5，循环结束输出结果

解答：

public class Test1 {
    public static void main(String[] args) {
       /* 有这样的一个数组，元素是{68,27,95,88,171,996,51,210}。
        求出该数组中满足要求的元素和，
        要求是：求和的元素个位和十位都不能是7，并且只能是偶数*/


        //分析
        //1.定义一个数组
        int[] arr = {68, 27, 95, 88, 171, 996, 51, 210};
        int sum = 0;
        //2.循环遍历数组得到每一个元素
        for (int i = 0; i < arr.length; i++) {
            //i      --- 依次表示数组中的每一个索引
            //arr[i] --- 依次表示数组中的每一个元素
            //3.判断每一个元素是否符合条件
            if ((arr[i] % 10 != 7) && (arr[i] / 10 % 10 != 7) && (arr[i] % 2 == 0)) {
                //4。如果符合条件，就累加求和，否则不管。
                sum = sum + arr[i];//sum += arr[i];   ---  sum = (int)(sum + arr[i])
                System.out.println(arr[i]);
            }
        }
        System.out.println("求和为" + sum);

    }
}

3，统计

题目：

有这样的一个数组，元素是{68,27,95,88,171,996,51,210}。
统计符合条件的数字有多少个？
要求是：求和的元素个位和十位都不能是7，并且只能是偶数

步骤：

1，定义一个数组

2，循环遍历数组得到每一个元素

3，判断每一个元素是否满足条件

4，将满足条件的数字进行累加（此时需要回到循环外面再定义一个求和变量）

5，循环结束输出结果

解答：

public class Test2 {
    public static void main(String[] args) {
        /* 有这样的一个数组，元素是{68,27,95,88,171,996,51,210}。
        统计符合条件的数字有多少个？
        要求是：求和的元素个位和十位都不能是7，并且只能是偶数*/

        //技巧：
        //一旦你在题目当中，看到要数数了。 （数有几个）
        //那么一定是用到计数器思想。
        //定义一个变量，初始化值为0
        //在符合条件的时候变量自增一次即可。


        //分析
        //1.定义一个数组
        int[] arr = {68, 27, 95, 88, 171, 996, 51, 210};
        //定义一个计数器，实际上就是一个变量而已
        int count = 0;
        //2.循环遍历数组得到每一个元素
        for (int i = 0; i < arr.length; i++) {
            //i      --- 依次表示数组中的每一个索引
            //arr[i] --- 依次表示数组中的每一个元素
            //3.判断每一个元素是否符合条件
            if ((arr[i] % 10 != 7) && (arr[i] / 10 % 10 != 7) && (arr[i] % 2 == 0)) {
                //4。如果符合条件，那么计数器就自增。
                count++;
            }
        }
        System.out.println("符合条件的数字有" + count + "个");
    }
}

4，查找元素

题目：

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

并在控制台输出找到的索引值。如果没有查找到，则输出-1

步骤：

1，定义一个数组

2，键盘录入一个数字准备跟数组中的数字进行比较

3，定义一个计数器，表示记录当前数字在数组中出现了几次

4，循环遍历数组，依次得到每一元素。

5，拿着键盘录入的数字跟数组中的元素进行比较。

6，如果满足条件，则打印当前索引。计数器++

7，对计数器进行判断，如果为0，表示数字没有在数组中存在过，打印-1

解答：

public class Test3 {
    public static void main(String[] args) {
        //注释代码的快捷键
        //1.选中要注释的代码
        //2.按下快捷键 ctrl + /              单行注释
        //            ctrl + shift + /      多行注释


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

        //分析：
        //1.定义一个数组arr = {19, 28, 37, 46, 50};
        int [] arr = {19, 28, 37, 46, 50};

        //2、键盘录入一个数字
        Scanner sc = new Scanner(System.in);
        System.out.println("请录入一个数字");
        int number = sc.nextInt();//快速生成方法的左边的接受变量----ctrl + alt + v
        //3.查找录入的数字number，在arr中所处的索引。如果不存在则返回-1.
        //问：在什么情况下，才能认为键盘录入的数字，在数组中是不存在的？
        //灵活运行计数器思想。数一下，number在数组中出现了多少次？
        int count = 0;
        for (int i = 0; i < arr.length; i++) {
            //判断键盘录入的数字，跟当前遍历到的数组是否相等。
            if(arr[i] == number){
                //如果相等，则打印索引
                System.out.println(i);
                //表示键盘录入的数字，出现了一次。
                count++;
            }
        }
        //当循环结束之后，count的值就表示，键盘录入的数字，在数组中出现了几次。
        //因为只有循环结束之后，才能叫做数组里面所有的元素都找完，此时才能打印-1
        if(count == 0){
            //如果count为0，表示键盘录入的数字，是不存在的。
            System.out.println(-1);
        }
    }
}

5，满足条件的数字存入数组

题目：

​ 将 10 – 20 之间能被5整除的数存入到数组当中，要求存入的位置是随机的，最后遍历这个数组。

步骤：

​ 1，先确定符合条件的数字有多少个？

​ 2，利用个数，来创建数组。

​ 3，把这个范围中符合条件数字，再次遍历出来，并存入到数组当中。

​ 4，存入之后随机位置。

​ 5，最后遍历。

解答：

public class Test4 {
    public static void main(String[] args) {
        int count = 0;
        for (int i = 10; i <= 20; i++) {
            if (i % 5 == 0) {
                count++;
            }
        }
        //循环结束之后，count的值，其实就是数组的长度
        System.out.println(count);
        //2.创建数组
        //自己定义一个变量去表示当前应存入数字的索引
        int index = 0;
        int [] arr = new int[count];
        //3，可以把符合条件的数字，存入到数组当中。
        for (int i = 10; i <= 20; i++) {
            if (i % 5 == 0) {
                //存入到数组当中。
                //格式：
                arr[index] = i;
                index++;
            }
        }
        //3.遍历数组
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

再次，打乱数组里面的数字顺序。

public class Test5 {
    public static void main(String[] args) {
        //打乱数组中数字的顺序
        //在上一题做完之后，数组中数字就是下面这个样子了。
        int[] arr = {10, 15, 20};

        Random r = new Random();
        //遍历数组
        for (int i = 0; i < arr.length; i++) {
            //获取一个随机索引。 (0 1 2)
            int randomIndex = r.nextInt(arr.length);
            //把i索引 跟 随机索引上的数字进行交换
            int temp  = arr[i];
            arr[i] = arr[randomIndex];
            arr[randomIndex] = temp;
        }

        //遍历数组
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

6,获取随机字符

题目：

​ 创建一个字符数组，数组中存入A-Z，a-z。并从该数组中获取一个随机字符

步骤：

1，定义一个长度为52的数组。用来存储A-Z，a-z

2，将A-Z存入数组当中

3，将a-z存入数组当中

4，从数组中随机获取一个元素

解答：

public class Test6 {
    public static void main(String[] args) {
//        创建一个字符数组，数组中存入A-Z，a-z。
//        并从该数组中获取一个随机字符

        //因为数组当中，要存入A-Z。a-z。所以，数组的长度为52
        char [] charArr = new char[52];
        //把A-Z  a-z存入到数组当中。
        //ASCII码表

        int index = 0;
        for (int i = 'a' ; i <= 'z'; i++) {
            //i表示什么？ 依次表示 字符a~字符z之间的每一个字符，在ASCII码表中对应的数字
            charArr[index] =(char)i;
            index++;
        }
        //当循环结束之后，就表示小写的a~小写的z就已经存入到数组当中了

        for (int i = 'A' ; i <= 'Z'; i++) {
            //i表示什么？ 依次表示 字符A~字符Z之间的每一个字符，在ASCII码表中对应的数字
            charArr[index] =(char)i;
            index++;
        }
        //当循环结束之后，就表示大写的A-Z，和小写的a-z就已经存入到数组当中了。

       //在数组当中获取一个随机字符
        //因为数组中的内容，我无法确定。
        //所以如果要随机获取数组中的元素。
        //1，获取随机索引。
        //2，通过索引再获取元素。
        Random r = new Random();
        //获取一个随机的索引
        int randomIndex = r.nextInt(charArr.length);
        //通过索引来获取元素
        char c = charArr[randomIndex];
        //输出得到的元素
        System.out.println(c);

    }
}

7，验证码

题目：

生成一个5位数的验证码

验证码由 4个 （A-Z a-z） 和1个 （0-9）的字符组成

数字固定在最后一位即可- 例如：gAgZ6

步骤：

1，创建了一个长度为52的数组。

​ 因为大写字符 + 小写字符一共有52个，所以数组长度为52.

2，把大写的A字符到大写的Z字符，存入到数组当中。

3，把小写的a字符到小写的z字符，存入到数组当中。

4，从数组中获取一个随机的元素。

• 先获取一个随机的索引
• 根据随机索引获取元素

5，把第4步重复4次即可。

6，获取一个0-9之间的数字。

解答：

public class Test8 {
    public static void main(String[] args) {
        //生成一个5位数的验证码
        //验证码由 4个 （A-Z a-z） 和1个 （0-9）的字符组成
        //数字固定在最后一位即可- 例如：gAgZ6

        //1.要把A-Z   a-z 添加到一个字符数组当中。
        char [] charArray = new char[52];

        //index表示当前要操作的那个索引
        int index = 0;
        for (int i = 'A'; i <= 'Z'; i++) {
            //i 表示 ‘A’ ~ ‘Z’ 之间的字符所对应的数字
            //System.out.println(i);
            //System.out.println((char) i);
            charArray[index] = (char) i;
            index++;
        }
        //当循环结束之后，就表示数组中已经存了A-Z

        for (int i = 'a'; i <= 'z'; i++) {
            //i 表示 ‘A’ ~ ‘Z’ 之间的字符所对应的数字
            //System.out.println(i);
            //System.out.println((char) i);
            charArray[index] = (char) i;
            index++;
        }

        //遍历
        for (int i = 0; i < charArray.length; i++) {
            System.out.print(charArray[i] + " ");
        }
        System.out.println();


        Random r = new Random();
        //上面的动作重复4次。
        for (int i = 0; i < 4; i++) {
            //从数组中获取一个随机字符
            //获取一个随机索引
            int randomIndex = r.nextInt(charArray.length);
            //根据随机索引获取对应的元素
            char randomChar = charArray[randomIndex];
            System.out.print(randomChar);
        }

        //4.再生成一个0-9之间的随机数。
        int randomNumber = r.nextInt(10);
        System.out.print(randomNumber);
    }
}

8，点名器

题目：

键盘录入班级人数, 根据班级人数录入班级学员姓名

从录入的学员姓名中, 随机取出一个, 并打印在控制台

步骤：

1，键盘录入班级人数

2，根据键盘录入的人数创建数组

3，将学生的名字存入到数组当中

4，获取一个数组的随机索引

5，通过随机索引获取名字

6，输出名字

解答：

public class Test9 {
    public static void main(String[] args) {
//        键盘录入班级人数,  根据班级人数录入班级学员姓名
//        从录入的学员姓名中, 随机取出一个, 并打印在控制台

        //1,键盘录入班级的人数
        Scanner sc = new Scanner(System.in);
        System.out.println("请录入班级的人数");
        int studentCount = sc.nextInt();
        //2，根据人数来创建数组。
            //因为人数就是数组的长度。
        String [] arr = new String[studentCount];
        //3.键盘录入给数组赋值
        for (int i = 0; i < arr.length; i++) {
            System.out.println("请录入班级学生的姓名");
            String name = sc.next();
            arr[i] = name;
        }
        System.out.println("-----------------------");

        //4.从数组中随机获取一个学生的名字
        //先获取一个随机的索引
        //然后通过这个随机的索引获取元素
        Random r = new Random();
        int randomIndex = r.nextInt(arr.length);// 在小括号中写arr.length就表示是随机获取数组中的任意一个索引
                                                //因为这个范围已经将数组中，所有的索引都包括了。
        //根据获取的随机索引来获取元素
        String randomName = arr[randomIndex];
        //输出这个随机的名字
        System.out.println(randomName);


    }
}

9，评委打分

题目：

在编程竞赛中，有6个评委为参赛的选手打分，分数均为整数。

选手的最后得分为：去掉一个最高分和一个最低分后 的4个评委平均值 (不考虑小数部分)。

步骤：

1，创建一个长度为6的数组。用来存6个评委的分数。

2，键盘录入评委的打分，并存入到数组当中。

3，求6个评委的总分。

4，求最大值

5，求最小值

6，求平均分 （总分 - 最大 - 最小） / 4

解答：

public class Test11 {
    public static void main(String[] args) {
        //在编程竞赛中，有6个评委为参赛的选手打分，分数均为整数。
        //选手的最后得分为：去掉一个最高分和一个最低分后 的4个评委平均值 (不考虑小数部分)。


        //1,创建一个长度为6的数组。
        int[] arr = new int[6];
        //2.键盘录入评委的打分，并把打分存入到数组当中
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < arr.length; i++) {
            System.out.println("请录入评委的打分");
            int score = sc.nextInt();
            //把键盘录入的分数，存入到数组当中
            arr[i] = score;
        }
        //当循环结束之后，表示数组中，已经存满了评委的打分
        //3.求数组当中所有数字的和
        int sum = getSum(arr);
        //4.求最大值
        int max = getMax(arr);
        //5.求最小智
        int min = getMin(arr);

        //6.求平均值
        int avg = (sum - max - min) / (arr.length - 2);

        System.out.println("该选手最终得分为" + avg);

    }

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

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


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

​