• 11-JavaSE基础巩固练习：面向对象综合训练（文字版格斗游戏、对象数组练习）

    面向对象综合训练

    编程技巧

    • 先理解需求逻辑
    • 再开始书写代码

    一、文字版格斗游戏

    1、需求
    • 每个游戏角色的姓名、血量，都不相同，在选定人物的时候（new对象的时候），这些信息就应该被确定下来。
      • 比如角色如下：
        • 姓名为：乔峰，血量为：100
        • 姓名为：鸠摩智，血量为：100
      • 规则如下：
        • 回合制：
          • 乔峰打了鸠摩智一下，造成了XX点伤害，鸠摩智还剩下XXX点血量；
          • 鸠摩智打了乔峰一下，造成了XX点伤害，乔峰还剩下XXX点血量；
          • …
          • 乔峰K.O.了鸠摩智。
    2、分析
    • 面向对象编程思路：
      • 创建角色类，定义角色的属性：姓名、血量
      • 提供有参和无参构造器
      • 提供全套的getXXX和setXXX方法，暴露其角色属性的取值和赋值
      • 定义角色的攻击行为方法
      • 创建游戏测试类，使用死循环，回合制的让双方不断互相攻击，直至有一方血量清零方可结束游戏。
    3、简单的实现

    • 1、角色类：

      package com.app.demo14_Object_oriented_cases01;

import java.util.Random;

/*
    定义角色类
 */
public class Role {
    /*
        1、定义角色的属性：
            姓名、血量
     */
    private String name;
    private int blood;


    /*
        2、提供有参和无参构造器
     */
    public Role() {

    }

    public Role(String name, int blood) {
        this.name = name;
        this.blood = blood;
    }


    /*
        3、提供全套的getXXX和setXXX方法，暴露其角色属性的取值和赋值
     */
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getBlood() {
        return blood;
    }

    public void setBlood(int blood) {
        this.blood = blood;
    }


    /**
     * 4、定义角色的攻击行为
     * 思考：谁攻击谁？
     * 角色1：Role r1 = new Role();
     * 角色2：Role r2 = new Role();
     * 攻击：r1.攻击(r2);
     *
     * @param role 被攻击的角色对象
     */
    public void attack(Role role) {
        // a.随机一个攻击伤害: 比如角色的一次攻击伤害范围是 1~20
        Random rd = new Random();
        int hurt = rd.nextInt(20) + 1;

        // b.计算被攻击后的对方的剩余血量
        int remainingBlood = role.getBlood() - hurt;

        // c.判断对方的剩余血量：
        // 如果对方的剩余血量 小于 攻击伤害 时，此时剩余血量会变成负数，因此将剩余血量修改为0
        // 如果对方的剩余血量 大于 攻击伤害 时，剩余血量就不需要修改
        remainingBlood = remainingBlood < 0 ? 0 : remainingBlood;

        // d.修改对方的血量为计算后的剩余血量
        // 对方角色对象.setBlood(剩余的血量);
        role.setBlood(remainingBlood);

        // e.显示对战信息
        // 举例：乔峰用飞踢踢中了鸠摩智，造成了XX点伤害，鸠摩智还剩下XXX点血量
        // this: 表示自己
        System.out.println(this.getName() + "用飞踢踢中了" + role.getName()
                + "，造成了" + hurt + "点伤害，"
                + role.getName() + "还剩下" + remainingBlood + "点血量~");
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      • 37
      • 38
      • 39
      • 40
      • 41
      • 42
      • 43
      • 44
      • 45
      • 46
      • 47
      • 48
      • 49
      • 50
      • 51
      • 52
      • 53
      • 54
      • 55
      • 56
      • 57
      • 58
      • 59
      • 60
      • 61
      • 62
      • 63
      • 64
      • 65
      • 66
      • 67
      • 68
      • 69
      • 70
      • 71
      • 72
      • 73
      • 74
      • 75
      • 76
      • 77
      • 78
      • 79
      • 80
      • 81
      • 82
      • 83

    • 2、游戏测试类：

      package com.app.demo14_Object_oriented_cases01;

/*
    定义游戏测试类
 */
public class GameTest {
    public static void main(String[] args) {
        // 1、创建两个游戏角色
        Role r1 = new Role("张飞", 100);
        Role r2 = new Role("刘备", 100);

        // 2、使用死循环让两个角色进行回合制战斗
        System.out.println("---------------" + r1.getName() + " VS " + r2.getName() + "---------------");
        while (true) {
            // 角色1 开始攻击 角色2
            r1.attack(r2);
            // 如果角色2血量为0时，说明角色2被角色1 K.O.了
            if (r2.getBlood() == 0) {
                System.out.println(r1.getName() + "K.O.了" + r2.getName());
                // 角色2被角色1KO了，游戏结束，跳出死循环
                break;
            }

            // 角色2 反击 角色2
            r2.attack(r1);
            // 如果角色1血量为0时，说明角色1被角色2 K.O.了
            if (r1.getBlood() == 0) {
                System.out.println(r2.getName() + "K.O.了" + r1.getName());
                // 角色1被角色2KO了，游戏结束，跳出死循环
                break;
            }
        }
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34

    • 3、测试结果：

      ---------------张飞 VS 刘备---------------
张飞用飞踢踢中了刘备，造成了13点伤害，刘备还剩下87点血量~
刘备用飞踢踢中了张飞，造成了3点伤害，张飞还剩下97点血量~
张飞用飞踢踢中了刘备，造成了16点伤害，刘备还剩下71点血量~
刘备用飞踢踢中了张飞，造成了3点伤害，张飞还剩下94点血量~
张飞用飞踢踢中了刘备，造成了4点伤害，刘备还剩下67点血量~
刘备用飞踢踢中了张飞，造成了12点伤害，张飞还剩下82点血量~
张飞用飞踢踢中了刘备，造成了20点伤害，刘备还剩下47点血量~
刘备用飞踢踢中了张飞，造成了6点伤害，张飞还剩下76点血量~
张飞用飞踢踢中了刘备，造成了1点伤害，刘备还剩下46点血量~
刘备用飞踢踢中了张飞，造成了4点伤害，张飞还剩下72点血量~
张飞用飞踢踢中了刘备，造成了12点伤害，刘备还剩下34点血量~
刘备用飞踢踢中了张飞，造成了19点伤害，张飞还剩下53点血量~
张飞用飞踢踢中了刘备，造成了19点伤害，刘备还剩下15点血量~
刘备用飞踢踢中了张飞，造成了12点伤害，张飞还剩下41点血量~
张飞用飞踢踢中了刘备，造成了6点伤害，刘备还剩下9点血量~
刘备用飞踢踢中了张飞，造成了2点伤害，张飞还剩下39点血量~
张飞用飞踢踢中了刘备，造成了6点伤害，刘备还剩下3点血量~
刘备用飞踢踢中了张飞，造成了3点伤害，张飞还剩下36点血量~
张飞用飞踢踢中了刘备，造成了18点伤害，刘备还剩下0点血量~
张飞K.O.了刘备

Process finished with exit code 0


      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
    4、丰富的实现

    • 给角色加两个属性：性别、长相（随机的）

    • 加四个个数组：

      • 女性长相数组、男性长相数组、功夫招式数组、受伤描述数组

    • 角色类

      package com.app.demo14_Object_oriented_cases01_Plus;

import java.util.Random;

public class Role {
    // 角色属性：姓名、血量、性别、颜值
    private String name;
    private int blood;
    private char gender;
    private String faceScore;

    // 四个数组：女性颜值数组、男性颜值数组、功夫招式数组、受伤描述数组
    String[] girlFaceScoreArr = {"美艳绝伦", "沉鱼落雁", "亭亭玉立", "身材姣好", "相貌平平", "相貌简陋", "惨不忍睹"};
    String[] boyFaceScoreArr = {"风刘俊雅", "气宇轩昂", "相貌英俊", "五官端正", "相貌平平", "一塌糊涂", "面目狰狞"};

    String[] kungFuArr = {
            "%s使出了一招 [降龙十八掌]，打向%s。",
            "%s使出了一招 [黑虎掏心]，飞身自半空中变掌为爪锁向%s。",
            "%s大喝一声，身形下伏，一招 [猴子偷桃]，抓向了%s。",
            "%s运气于掌，一瞬间掌心变得血红，一招 [掌心雷]，推向%s。",
            "%s阴手翻起阳手跟进，一招 [没遮拦]，结结实实的锤向%s。"
    };

    String[] injuryDescribeArr = {
            "结果%s退了半步，毫发无伤！",
            "结果给%s造成了一处淤伤！",
            "结果一击命中，%s痛得弯下了腰！",
            "结果%s脸色一下变得惨白，连退了好几步！",
            "结果 [轰] 的一声，%s口中鲜血狂喷而出！",
            "结果%s一声惨叫，像摊烂泥一样塌了下去！"
    };

    // 有参、无参构造器
    public Role() {

    }

    public Role(String name, int blood, char gender) {
        this.name = name;
        this.blood = blood;
        this.gender = gender;
        // 根据角色性别随机设定长相颜值
        setFaceScore(gender);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getBlood() {
        return blood;
    }

    public void setBlood(int blood) {
        this.blood = blood;
    }

    public char getGender() {
        return gender;
    }

    public void setGender(char gender) {
        this.gender = gender;
    }

    public String getFaceScore() {
        return faceScore;
    }

    /**
     * 根据角色的性别设定随机的长相颜值
     *
     * @param gender 角色性别
     */
    public void setFaceScore(char gender) {
        Random rd = new Random();
        if (gender == '男') {
            int index = rd.nextInt(boyFaceScoreArr.length);
            this.faceScore = boyFaceScoreArr[index];
        } else if (gender == '女') {
            int index = rd.nextInt(girlFaceScoreArr.length);
            this.faceScore = girlFaceScoreArr[index];
        } else {
            // 默认值
            this.faceScore = "惨不忍睹";
        }
    }

    /**
     * 定义角色的攻击行为
     *
     * @param role
     */
    public void attack(Role role) {
        // 给角色随机一个功夫招式
        Random rd = new Random();
        int index = rd.nextInt(kungFuArr.length);
        String kungFu = kungFuArr[index];

        // 显示一个角色攻击对方的效果
        // 例如：
        //      "%s使出了一招 [降龙十八掌]，打向%s。"
        //      "张三使出了一招 [降龙十八掌]，打向李四。"
        // 参数一(%s)：我方；参数二(%s)：对方
        System.out.printf(kungFu, this.getName(), role.getName());
        // System.out.printf：是不带换行的，因此攻击完，打印一个换行
        System.out.println();

        // 给角色随机一个伤害值: 1~30
        int hurt = rd.nextInt(30) + 1;
        // 计算对方剩余的血量
        int remainBlood = role.getBlood() - hurt;

        /*
            如果对方剩余的血量 小于 攻击伤害值，此时，对方的剩余血量为负数，将剩余的血量值修改为0
            如果对方剩余的血量 大于 攻击伤害值，此时，对方的剩余血量不需要修改
         */
        remainBlood = remainBlood < 0 ? 0 : remainBlood;

        // 每攻击完对方一次，更新对方的剩余血量
        role.setBlood(remainBlood);


        // 根据对方的剩余血量来显示受伤描述
        /*
            80~100的剩余血量，0索引的描述
            70~80的剩余血量，1索引的描述
            50~70的剩余血量，2索引的描述
            30~50的剩余血量，3索引的描述
            1~30的剩余血量，4索引的描述
            0的剩余血量，5索引的描述
         */
        if (remainBlood > 80 && remainBlood < 100) {
            System.out.printf(injuryDescribeArr[0], role.getName());
            System.out.print(this.getName() + "打出了" + hurt + "点伤害，" + role.getName() + "剩余" + remainBlood + "点血量~");

        } else if (remainBlood > 70 && remainBlood <= 80) {
            System.out.printf(injuryDescribeArr[1], role.getName());
            System.out.print(this.getName() + "打出了" + hurt + "点伤害，" + role.getName() + "剩余" + remainBlood + "点血量~");

        } else if (remainBlood > 50 && remainBlood <= 70) {
            System.out.printf(injuryDescribeArr[2], role.getName());
            System.out.print(this.getName() + "打出了" + hurt + "点伤害，" + role.getName() + "剩余" + remainBlood + "点血量~");

        } else if (remainBlood > 30 && remainBlood <= 50) {
            System.out.printf(injuryDescribeArr[3], role.getName());
            System.out.print(this.getName() + "打出了" + hurt + "点伤害，" + role.getName() + "剩余" + remainBlood + "点血量~");

        } else if (remainBlood > 1 && remainBlood <= 30) {
            System.out.printf(injuryDescribeArr[4], role.getName());
            System.out.print(this.getName() + "打出了" + hurt + "点伤害，" + role.getName() + "剩余" + remainBlood + "点血量~");

        } else if (remainBlood == 0) {
            System.out.printf(injuryDescribeArr[5], role.getName());
            System.out.print(this.getName() + "打出了" + hurt + "点伤害，" + role.getName() + "剩余" + remainBlood + "点血量~");
        }

        // 每显示一次受伤描述后，因为System.out.printf()无法换行，因此一个打印换行
        System.out.println();
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      • 37
      • 38
      • 39
      • 40
      • 41
      • 42
      • 43
      • 44
      • 45
      • 46
      • 47
      • 48
      • 49
      • 50
      • 51
      • 52
      • 53
      • 54
      • 55
      • 56
      • 57
      • 58
      • 59
      • 60
      • 61
      • 62
      • 63
      • 64
      • 65
      • 66
      • 67
      • 68
      • 69
      • 70
      • 71
      • 72
      • 73
      • 74
      • 75
      • 76
      • 77
      • 78
      • 79
      • 80
      • 81
      • 82
      • 83
      • 84
      • 85
      • 86
      • 87
      • 88
      • 89
      • 90
      • 91
      • 92
      • 93
      • 94
      • 95
      • 96
      • 97
      • 98
      • 99
      • 100
      • 101
      • 102
      • 103
      • 104
      • 105
      • 106
      • 107
      • 108
      • 109
      • 110
      • 111
      • 112
      • 113
      • 114
      • 115
      • 116
      • 117
      • 118
      • 119
      • 120
      • 121
      • 122
      • 123
      • 124
      • 125
      • 126
      • 127
      • 128
      • 129
      • 130
      • 131
      • 132
      • 133
      • 134
      • 135
      • 136
      • 137
      • 138
      • 139
      • 140
      • 141
      • 142
      • 143
      • 144
      • 145
      • 146
      • 147
      • 148
      • 149
      • 150
      • 151
      • 152
      • 153
      • 154
      • 155
      • 156
      • 157
      • 158
      • 159
      • 160
      • 161
      • 162
      • 163
      • 164
      • 165

    • 测试类

      package com.app.demo14_Object_oriented_cases01_Plus;

import java.util.Scanner;

public class GameTest {
    public static void main(String[] args) {
        // 1、创建角色
        System.out.println("---------------请选择我方英雄---------------");
        Role r1 = createRole();
        System.out.println("---------------请选择敌方英雄---------------");
        Role r2 = createRole();

        // 2、查看创建好的角色信息
        System.out.println("我方英雄信息：");
        queryRoleInfo(r1);
        System.out.println("敌方英雄信息：");
        queryRoleInfo(r2);

        // 3、我方 VS 敌方英雄
        myRoleVSHeRole(r1, r2);
    }


    /**
     * 英雄对战
     * @param myRole    我方英雄
     * @param heRole    敌方英雄
     */
    public static void myRoleVSHeRole(Role myRole, Role heRole) {
        int count = 0;  // 记录回合数
        System.out.println("----------------对战中----------------");
        while (true) {  // 回合制
            System.out.println("第" + (count + 1) + "回合：");

            // 我方 先攻击 敌方
            myRole.attack(heRole);
            // 判断敌方血量是否为0
            if (heRole.getBlood() == 0) {
                System.out.println(myRole.getName() + "K.O.了" + heRole.getName());
                break;
            }

            // 敌方 反击 我方
            heRole.attack(myRole);
            count++;
            // 判断我方血量是否为0
            if (myRole.getBlood() == 0) {
                System.out.println(heRole.getName() + "K.O.了" + myRole.getName());
                break;
            }

            // 每打完一个回合，打印换行
            System.out.println();
        }
    }


    /**
     * 查看角色信息
     *
     * @param role 角色对象
     */
    public static void queryRoleInfo(Role role) {
        System.out.println("姓名：" + role.getName()
                + "\n血量：" + role.getBlood()
                + "\n性别：" + role.getGender()
                + "\n长相：" + role.getFaceScore()
        );
        System.out.println();
    }


    /**
     * 用户创建游戏角色
     *
     * @return 返回创建好的游戏角色
     */
    public static Role createRole() {
        // 创建键盘录入对象，用于从键盘录入英雄信息
        Scanner sc = new Scanner(System.in);

        // 创建一个空角色对象变量，用于接收英雄信息，封装成一个对象
        Role role;

        System.out.println("请输入角色姓名：");
        String name = sc.nextLine();

        while (true) {
            System.out.println("请输入角色性别(男/女)：");
            String genders = sc.nextLine();

            if (genders.equals("男")) {
                char gender = genders.charAt(0);
                role = new Role(name, 100, gender);
                break;
            } else if (genders.equals("女")) {
                char gender = genders.charAt(0);
                role = new Role(name, 100, gender);
                break;
            } else {
                System.out.println("您输入的性别有误！请重新输入~");
            }
        }

        // 创建完一个角色，打印换行
        System.out.println();

        // 角色创建完毕，返回创建好的角色对象
        return role;
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      • 37
      • 38
      • 39
      • 40
      • 41
      • 42
      • 43
      • 44
      • 45
      • 46
      • 47
      • 48
      • 49
      • 50
      • 51
      • 52
      • 53
      • 54
      • 55
      • 56
      • 57
      • 58
      • 59
      • 60
      • 61
      • 62
      • 63
      • 64
      • 65
      • 66
      • 67
      • 68
      • 69
      • 70
      • 71
      • 72
      • 73
      • 74
      • 75
      • 76
      • 77
      • 78
      • 79
      • 80
      • 81
      • 82
      • 83
      • 84
      • 85
      • 86
      • 87
      • 88
      • 89
      • 90
      • 91
      • 92
      • 93
      • 94
      • 95
      • 96
      • 97
      • 98
      • 99
      • 100
      • 101
      • 102
      • 103
      • 104
      • 105
      • 106
      • 107
      • 108
      • 109
      • 110
      • 111

    • 测试结果

      ---------------请选择我方英雄---------------
请输入角色姓名：
乔峰
请输入角色性别(男/女)：
那地方
您输入的性别有误！请重新输入~
请输入角色性别(男/女)：
dfd
您输入的性别有误！请重新输入~
请输入角色性别(男/女)：
分
您输入的性别有误！请重新输入~
请输入角色性别(男/女)：
男

---------------请选择敌方英雄---------------
请输入角色姓名：
鸠摩智
请输入角色性别(男/女)：
男

我方英雄信息：
姓名：乔峰
血量：100
性别：男
长相：五官端正

敌方英雄信息：
姓名：鸠摩智
血量：100
性别：男
长相：相貌平平

----------------对战中----------------
第1回合：
乔峰使出了一招 [降龙十八掌]，打向鸠摩智。
结果给鸠摩智造成了一处淤伤！乔峰打出了20点伤害，鸠摩智剩余80点血量~
鸠摩智运气于掌，一瞬间掌心变得血红，一招 [掌心雷]，推向乔峰。
结果乔峰退了半步，毫发无伤！鸠摩智打出了7点伤害，乔峰剩余93点血量~

第2回合：
乔峰使出了一招 [降龙十八掌]，打向鸠摩智。
结果一击命中，鸠摩智痛得弯下了腰！乔峰打出了18点伤害，鸠摩智剩余62点血量~
鸠摩智运气于掌，一瞬间掌心变得血红，一招 [掌心雷]，推向乔峰。
结果一击命中，乔峰痛得弯下了腰！鸠摩智打出了26点伤害，乔峰剩余67点血量~

第3回合：
乔峰阴手翻起阳手跟进，一招 [没遮拦]，结结实实的锤向鸠摩智。
结果鸠摩智脸色一下变得惨白，连退了好几步！乔峰打出了16点伤害，鸠摩智剩余46点血量~
鸠摩智运气于掌，一瞬间掌心变得血红，一招 [掌心雷]，推向乔峰。
结果乔峰脸色一下变得惨白，连退了好几步！鸠摩智打出了18点伤害，乔峰剩余49点血量~

第4回合：
乔峰使出了一招 [降龙十八掌]，打向鸠摩智。
结果鸠摩智脸色一下变得惨白，连退了好几步！乔峰打出了12点伤害，鸠摩智剩余34点血量~
鸠摩智大喝一声，身形下伏，一招 [猴子偷桃]，抓向了乔峰。
结果乔峰脸色一下变得惨白，连退了好几步！鸠摩智打出了14点伤害，乔峰剩余35点血量~

第5回合：
乔峰阴手翻起阳手跟进，一招 [没遮拦]，结结实实的锤向鸠摩智。
结果 [轰] 的一声，鸠摩智口中鲜血狂喷而出！乔峰打出了23点伤害，鸠摩智剩余11点血量~
鸠摩智使出了一招 [黑虎掏心]，飞身自半空中变掌为爪锁向乔峰。
结果 [轰] 的一声，乔峰口中鲜血狂喷而出！鸠摩智打出了10点伤害，乔峰剩余25点血量~

第6回合：
乔峰使出了一招 [降龙十八掌]，打向鸠摩智。
结果鸠摩智一声惨叫，像摊烂泥一样塌了下去！乔峰打出了22点伤害，鸠摩智剩余0点血量~
乔峰K.O.了鸠摩智

Process finished with exit code 0


      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      • 37
      • 38
      • 39
      • 40
      • 41
      • 42
      • 43
      • 44
      • 45
      • 46
      • 47
      • 48
      • 49
      • 50
      • 51
      • 52
      • 53
      • 54
      • 55
      • 56
      • 57
      • 58
      • 59
      • 60
      • 61
      • 62
      • 63
      • 64
      • 65
      • 66
      • 67
      • 68
      • 69
      • 70
      • 71

    二、对象数组练习

    1、对象数组练习1

    • 需求：

      • 定义数组存储3个商品对象。
      • 商品的属性：商品的id、名字、价格、库存
      • 创建三个商品对象，并把商品对象存入到数组当中。

    • 分析：

      • 需要一个商品类，用于将商品的信息封装成商品对象
      • 需要一个长度为3的对象数组，用于存储3个商品对象
      • 需要一个测试类，创建3个商品对象，存入数组中

    • 实现：

      • 商品类

        package com.app.demo16_object_array1;

/*
    商品类
 */
public class Commodity {
    // 商品属性：id、名字、价格、库存
    private String id;
    private String commodityName;
    private double price;
    private int inventory;

    // 无参构造器
    public Commodity() {

    }

    // 有参构造器
    public Commodity(String id, String commodityName, double price, int inventory) {
        this.id = id;
        this.commodityName = commodityName;
        this.price = price;
        this.inventory = inventory;
    }

    /*
        生成全套的getXXX和setXXX方法，暴露其对象属性的取值和赋值
     */
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getCommodityName() {
        return commodityName;
    }

    public void setCommodityName(String commodityName) {
        this.commodityName = commodityName;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public int getInventory() {
        return inventory;
    }

    public void setInventory(int inventory) {
        this.inventory = inventory;
    }
}

        • 1
        • 2
        • 3
        • 4
        • 5
        • 6
        • 7
        • 8
        • 9
        • 10
        • 11
        • 12
        • 13
        • 14
        • 15
        • 16
        • 17
        • 18
        • 19
        • 20
        • 21
        • 22
        • 23
        • 24
        • 25
        • 26
        • 27
        • 28
        • 29
        • 30
        • 31
        • 32
        • 33
        • 34
        • 35
        • 36
        • 37
        • 38
        • 39
        • 40
        • 41
        • 42
        • 43
        • 44
        • 45
        • 46
        • 47
        • 48
        • 49
        • 50
        • 51
        • 52
        • 53
        • 54
        • 55
        • 56
        • 57
        • 58
        • 59
        • 60

      • 测试类

        package com.app.demo16_object_array1;

/*
    面向对象综合训练：对象数组练习1
        需求：
            定义数组存储3个商品对象。
            商品的属性：商品的id、名字、价格、库存
            创建三个商品对象，并把商品对象存入到数组当中。
 */
public class ObjectArrayDemo1 {
    public static void main(String[] args) {
        // 1、定义长度为3的对象数组，用于存储3个商品对象
        Commodity[] commodities = new Commodity[3];

        // 2、创建3个商品对象，存入对象数组中
        commodities[0] = new Commodity("001", "宇智波鼬手办", 1000, 30);
        commodities[1] = new Commodity("002", "华为nova7", 2350.5, 200);
        commodities[2] = new Commodity("003", "机械键盘", 399.9, 3);

        // 3、遍历对象数组，查看商品信息
        System.out.println("所有商品信息：");
        for (Commodity commodity : commodities) {
            System.out.println("编号: " + commodity.getId() +
                    ", 商品名称: " + commodity.getCommodityName() +
                    ", 商品价格: " + commodity.getPrice() +
                    ", 库存数量: " + commodity.getInventory());
        }
    }
}

        • 1
        • 2
        • 3
        • 4
        • 5
        • 6
        • 7
        • 8
        • 9
        • 10
        • 11
        • 12
        • 13
        • 14
        • 15
        • 16
        • 17
        • 18
        • 19
        • 20
        • 21
        • 22
        • 23
        • 24
        • 25
        • 26
        • 27
        • 28
        • 29

      • 测试结果：

        所有商品信息：
编号: 001, 商品名称: 宇智波鼬手办, 商品价格: 1000.0, 库存数量: 30
编号: 002, 商品名称: 华为nova7, 商品价格: 2350.5, 库存数量: 200
编号: 003, 商品名称: 机械键盘, 商品价格: 399.9, 库存数量: 3

Process finished with exit code 0


        • 1
        • 2
        • 3
        • 4
        • 5
        • 6
        • 7
    2、对象数组练习2

    • 需求：

      • 定义数组存储3部汽车对象。
      • 汽车的属性：品牌、价格、颜色。
      • 创建3个汽车对象，数据通过键盘录入之后将其存入数组当中。

    • 分析：

      • 需求一个汽车类，用于将汽车的信息封装成汽车对象
      • 需要一个对象数组，长度为3，用于存储3部汽车对象
      • 需求从键盘录入汽车对象的信息，将其封装成一个汽车对象，动态存入对象数组中

    • 实现：

      • 汽车类

        package com.app.demo17_object_array2;

/*
    汽车类
 */
public class Car {
    // 汽车的属性：品牌、价格、颜色
    private String brand;
    private double price;
    private String colour;

    /*
        有参、无参构造器
     */
    public Car() {

    }

    public Car(String brand, double price, String colour) {
        this.brand = brand;
        this.price = price;
        this.colour = colour;
    }


    /*
        生成全套的get和set方法，暴露其对象属性的取值和赋值
     */
    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public String getColour() {
        return colour;
    }

    public void setColour(String colour) {
        this.colour = colour;
    }
}

        • 1
        • 2
        • 3
        • 4
        • 5
        • 6
        • 7
        • 8
        • 9
        • 10
        • 11
        • 12
        • 13
        • 14
        • 15
        • 16
        • 17
        • 18
        • 19
        • 20
        • 21
        • 22
        • 23
        • 24
        • 25
        • 26
        • 27
        • 28
        • 29
        • 30
        • 31
        • 32
        • 33
        • 34
        • 35
        • 36
        • 37
        • 38
        • 39
        • 40
        • 41
        • 42
        • 43
        • 44
        • 45
        • 46
        • 47
        • 48
        • 49
        • 50
        • 51
        • 52

      • 测试类

        package com.app.demo17_object_array2;

import java.util.Scanner;

/*
    面向对象综合训练：对象数组2
    需求：
        定义数组存储3部汽车对象。
        汽车的属性：品牌、价格、颜色。
        创建3个汽车对象，数据通过键盘录入之后将其存入数组当中。
 */
public class CarTest {
    public static void main(String[] args) {
        // 键盘录入汽车信息，参数length: 数组的长度，表示可以存储多少部汽车对象
        Car[] cars = createCars(3);

        // 查看所有汽车的信息
        System.out.println("\n所有汽车信息如下：");
        showCars(cars);
    }

    /**
     * 查看所有汽车的信息
     *
     * @param cars 接收一个汽车对象数组
     */
    public static void showCars(Car[] cars) {
        // 循环遍历汽车对象数组，查看所有汽车的信息
        for (Car car : cars) {
            System.out.println("汽车品牌：" + car.getBrand() +
                    ", 汽车价格：" + car.getPrice() + "万元" +
                    ", 汽车颜色：" + car.getColour());
        }
    }


    /**
     * 创建汽车对象存入对象数组
     *
     * @param length 接收一个对象数组的长度：表示可以存储多少部汽车对象
     * @return 将存储有汽车对象的对象数组返回给调用处
     */
    public static Car[] createCars(int length) {
        // 1、定义对象数组，长度为length，用于存储length部汽车对象
        Car[] cars = new Car[length];

        // 2、创建键盘录入对象，用于从键盘录入汽车的信息
        Scanner sc = new Scanner(System.in);

        // 3、遍历数组，依次得到数组的每个元素索引位置
        for (int i = 0; i < cars.length; i++) {
            // i: 依次表示数组的索引位置
            // cars[i]: 依次表示数组的每个元素
            // a: 每循环一次，创建一个汽车对象，用于将从键盘录入的汽车信息封装成一个汽车对象
            Car car = new Car();

            // b: 开始录入汽车的信息
            System.out.println("--------录入第" + (i + 1) + "部汽车的信息--------");
            System.out.println("请您录入汽车的品牌：");
            String brand = sc.next();
            System.out.println("请您录入汽车的价格(万元)：");
            double price = sc.nextDouble();
            System.out.println("请您录入汽车的颜色：");
            String colour = sc.next();

            // c: 封装汽车的信息成一个汽车对象
            car.setBrand(brand);
            car.setPrice(price);
            car.setColour(colour);

            // d: 将封装好的汽车对象，存入对象数组中
            cars[i] = car;
        }

        // 5、存储工作完成，返回满载而归的对象数组
        return cars;
    }
}

        • 1
        • 2
        • 3
        • 4
        • 5
        • 6
        • 7
        • 8
        • 9
        • 10
        • 11
        • 12
        • 13
        • 14
        • 15
        • 16
        • 17
        • 18
        • 19
        • 20
        • 21
        • 22
        • 23
        • 24
        • 25
        • 26
        • 27
        • 28
        • 29
        • 30
        • 31
        • 32
        • 33
        • 34
        • 35
        • 36
        • 37
        • 38
        • 39
        • 40
        • 41
        • 42
        • 43
        • 44
        • 45
        • 46
        • 47
        • 48
        • 49
        • 50
        • 51
        • 52
        • 53
        • 54
        • 55
        • 56
        • 57
        • 58
        • 59
        • 60
        • 61
        • 62
        • 63
        • 64
        • 65
        • 66
        • 67
        • 68
        • 69
        • 70
        • 71
        • 72
        • 73
        • 74
        • 75
        • 76
        • 77
        • 78

      • 测试结果：

        --------录入第1部汽车的信息--------
请您录入汽车的品牌：
劳斯莱斯
请您录入汽车的价格(万元)：
1900
请您录入汽车的颜色：
黑白
--------录入第2部汽车的信息--------
请您录入汽车的品牌：
宝马
请您录入汽车的价格(万元)：
400
请您录入汽车的颜色：
蓝白
--------录入第3部汽车的信息--------
请您录入汽车的品牌：
梅赛德斯
请您录入汽车的价格(万元)：
450.5
请您录入汽车的颜色：
七彩色

所有汽车信息如下：
汽车品牌：劳斯莱斯, 汽车价格：1900.0万元, 汽车颜色：黑白
汽车品牌：宝马, 汽车价格：400.0万元, 汽车颜色：蓝白
汽车品牌：梅赛德斯, 汽车价格：450.5万元, 汽车颜色：七彩色

Process finished with exit code 0


        • 1
        • 2
        • 3
        • 4
        • 5
        • 6
        • 7
        • 8
        • 9
        • 10
        • 11
        • 12
        • 13
        • 14
        • 15
        • 16
        • 17
        • 18
        • 19
        • 20
        • 21
        • 22
        • 23
        • 24
        • 25
        • 26
        • 27
        • 28
        • 29
    3、对象数组练习3

    • 需求：

      • 定义数组存储3部手机对象。
      • 手机的属性：品牌、价格、颜色。
      • 要求计算出3部手机的平均价格。

    • 分析：

      • 需要一个手机类，用于将1部手机信息封装成一个手机对象。
      • 需要一个数组，用于存储3部手机对象。
      • 需要得到所有手机的价格，计算出3部手机的平均值。

    • 实现：

      • 手机类

        package com.app.demo18_object_array3;

/*
    手机类
 */
public class MobilePhone {
    /*
        定义手机的属性：品牌、价格、颜色
     */
    private String brand;
    private double price;
    private String colour;

    /*
        提供有参和无参构造器
     */
    public MobilePhone() {

    }

    public MobilePhone(String brand, double price, String colour) {
        this.brand = brand;
        this.price = price;
        this.colour = colour;
    }


    /*
        提供全套的getXXX和setXXX方法，
        暴露其属性的取值和赋值。
     */
    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public String getColour() {
        return colour;
    }

    public void setColour(String colour) {
        this.colour = colour;
    }
}

        • 1
        • 2
        • 3
        • 4
        • 5
        • 6
        • 7
        • 8
        • 9
        • 10
        • 11
        • 12
        • 13
        • 14
        • 15
        • 16
        • 17
        • 18
        • 19
        • 20
        • 21
        • 22
        • 23
        • 24
        • 25
        • 26
        • 27
        • 28
        • 29
        • 30
        • 31
        • 32
        • 33
        • 34
        • 35
        • 36
        • 37
        • 38
        • 39
        • 40
        • 41
        • 42
        • 43
        • 44
        • 45
        • 46
        • 47
        • 48
        • 49
        • 50
        • 51
        • 52
        • 53
        • 54
        • 55

      • 测试类

        package com.app.demo18_object_array3;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.Scanner;

/*
    测试类：
        面向对象综合训练：对象数组练习3
        需求：
            定义数组存储3部手机对象。
            手机的属性：品牌、价格、颜色。
            要求计算出3部手机的平均价格。
 */
public class MobilePhoneTest {
    public static void main(String[] args) {
        // 1、创建手机对象
        MobilePhone[] mobilePhones = createMobilePhones(3);
        if (mobilePhones == null) {
            System.out.println("数组长度不能为0~");
        } else {
            // 2、查看所有手机的信息
            showMobilePhones(mobilePhones);

            // 3、计算出所有手机的平均价格
            BigDecimal averagePrice = mobilePhonesAveragePrice(mobilePhones);
            System.out.println("\n所有手机的平均价格为：" + averagePrice + "元~");
        }
    }


    /**
     * 计算所有手机的平均价格
     *
     * @param mobilePhones  所有手机对象的数组
     * @return              返回所有手机的平均价格
     */
    public static BigDecimal mobilePhonesAveragePrice(MobilePhone[] mobilePhones) {
        // 1、定义数组，用于记录所有手机的价格
        double[] prices = new double[mobilePhones.length];

        // 2、遍历mobilePhones数组，依次得到每个手机对象
        for (int i = 0; i < mobilePhones.length;) {
            // mobilePhones[i]: 依次表示数组中的每个手机对象

            // a.依次得到每个手机的价格，存入prices数组中
            for (int j = 0; j < prices.length; j++) {
                // prices[j]: 依次表示每个手机的价格
                // 依次将每个手机的价格存入prices数组中
                prices[j] = mobilePhones[i].getPrice();
                // 每存储成功一个手机的价格，让i自增，继续得到下一个手机对象
                i++;
            }
        }

        // 3、定义变量，分别表示手机的最高价格、最低价格、总价格、平均价格
        double maxPrice = prices[0];
        double minPrice = prices[0];
        double sumPrice = 0;
        BigDecimal averagePrice;

        // 4、遍历prices数组，依次得到每个手机的价格
        for (int i = 0; i < prices.length; i++) {
            // a.求所有手机的最高价格
            if (i >= 1 && prices[i] > maxPrice) {
                // 如果当前这个手机的价格 大于 首个手机的价格，
                // 则maxPrice替换成当前这个手机的价格。
                maxPrice = prices[i];
            }

            // b.求所有手机的最低价格
            if (i >= 1 && prices[i] < minPrice) {
                // 如果当前这个手机的价格 小于 首个手机的价格，
                // 则minPrice替换成当前这个手机的价格
                minPrice = prices[i];
            }

            // c.统计所有手机的价格，求总价格
            sumPrice += prices[i];
        }

        // 5、循环结束，说明手机的最高、最低价格、总价格已全部求出
        // 将double类型的总价格转换成BigDecimal类型
        BigDecimal sum = BigDecimal.valueOf(sumPrice);
        // 将double类型的最高价格转换成BigDecimal类型
        BigDecimal max = BigDecimal.valueOf(maxPrice);
        // 将double类型的最低价格转换成BigDecimal类型
        BigDecimal min = BigDecimal.valueOf(minPrice);
        // 将数组长度、2都转换成BigDecimal类型后，再做相减操作
        // 以下代码等价于: prices.length - 2
        BigDecimal number = BigDecimal.valueOf(prices.length).subtract(BigDecimal.valueOf(2));

        /*System.out.println("总价格：" + sum);
        System.out.println("最高价格：" + max);
        System.out.println("最低价格：" + min);*/

        // averagePrice = (sumPrice - maxPrice - minPrice) / (prices.length - 2);
        /*
            6、计算平均价格，四舍五入后并保留1位小数
            以下代码等价于: (总价格 - 最高价格 - 最低价格) / 个数(prices.length-2)
            divide(number, 2, RoundingMode.DOWN):
                参数一：除数；参数二：保留多少位小数；参数三：舍入模式
        */
        averagePrice = (sum.subtract(max).subtract(min)).divide(number, 1, RoundingMode.HALF_DOWN);

        // 计算完成，返回所有手机的平均价格
        return averagePrice;
    }


    /**
     * 查看所有手机的信息
     *
     * @param mobilePhones 手机对象数组
     */
    public static void showMobilePhones(MobilePhone[] mobilePhones) {
        // 1、判断手机对象数组是否为null
        if (mobilePhones == null) {
            // 为null
            System.out.println("您的手机对象数组不能为null~");
        } else {
            // 不为null：遍历手机对象的数组，依次得到数组中每个手机对象
            System.out.println("\n所有手机信息如下：");
            for (MobilePhone mobilePhone : mobilePhones) {
                System.out.println("手机品牌：" + mobilePhone.getBrand() +
                        "，手机价格：" + mobilePhone.getPrice() + "元" +
                        "，手机颜色：" + mobilePhone.getColour());
            }
        }
    }


    /**
     * 创建手机对象
     *
     * @param length 数组的长度：表示可以存储多少部手机对象
     * @return 返回对象数组
     */
    public static MobilePhone[] createMobilePhones(int length) {
        // 1、数组的长度不能为0，否则返回null
        if (length == 0) {
            return null;
        }

        // 2、定义数组，用于存储手机对象，长度为length
        MobilePhone[] mobilePhones = new MobilePhone[length];

        // 3、创建键盘录入对象，用于录入手机信息
        Scanner sc = new Scanner(System.in);

        // 4、遍历数组，依次得到每个元素的索引位置
        for (int i = 0; i < mobilePhones.length; i++) {
            // i: 依次表示数组中每个元素的索引位置
            // mobilePhones[i]: 依次表示数组中的每个元素
            // a. 每循环一次，创建一个空的新手机对象，用于将录入的手机信息封装成一个手机对象
            MobilePhone mobilePhone = new MobilePhone();

            // b. 开始录入手机信息
            System.out.println("---------录入第" + (i + 1) + "部手机的信息---------");
            System.out.println("请您输入手机的品牌：");
            String brand = sc.next();
            mobilePhone.setBrand(brand);

            System.out.println("请您输入手机的价格：");
            double price = sc.nextDouble();
            mobilePhone.setPrice(price);

            // 选择手机的颜色
            selectMobilePhone(mobilePhone, sc);

            // c. 将手机信息封装成对象依次存入数组中
            mobilePhones[i] = mobilePhone;
        }

        // 循环结束，存储工作完成，返回对象数组
        return mobilePhones;
    }


    /**
     * 选择手机的颜色
     *
     * @param mobilePhone 空的手机对象
     * @param sc          键盘录入对象
     */
    public static void selectMobilePhone(MobilePhone mobilePhone, Scanner sc) {
        while (true) {
            System.out.println("请您选择手机的颜色：");
            System.out.println("1.深海蓝\n2.茉莉绿\n3.珍珠白\n4.靓丽粉\n5.朱砂黑");
            String colour = sc.next();
            switch (colour) {
                case "1":
                    mobilePhone.setColour("深海蓝");
                    return;
                case "2":
                    mobilePhone.setColour("茉莉绿");
                    return;
                case "3":
                    mobilePhone.setColour("珍珠白");
                    return;
                case "4":
                    mobilePhone.setColour("靓丽粉");
                    return;
                case "5":
                    mobilePhone.setColour("朱砂黑");
                    return;
                default:
                    System.out.println("该颜色的手机还没有开发出来哦~ 请敬请等候~");
                    break;
            }
        }
    }
}

        • 1
        • 2
        • 3
        • 4
        • 5
        • 6
        • 7
        • 8
        • 9
        • 10
        • 11
        • 12
        • 13
        • 14
        • 15
        • 16
        • 17
        • 18
        • 19
        • 20
        • 21
        • 22
        • 23
        • 24
        • 25
        • 26
        • 27
        • 28
        • 29
        • 30
        • 31
        • 32
        • 33
        • 34
        • 35
        • 36
        • 37
        • 38
        • 39
        • 40
        • 41
        • 42
        • 43
        • 44
        • 45
        • 46
        • 47
        • 48
        • 49
        • 50
        • 51
        • 52
        • 53
        • 54
        • 55
        • 56
        • 57
        • 58
        • 59
        • 60
        • 61
        • 62
        • 63
        • 64
        • 65
        • 66
        • 67
        • 68
        • 69
        • 70
        • 71
        • 72
        • 73
        • 74
        • 75
        • 76
        • 77
        • 78
        • 79
        • 80
        • 81
        • 82
        • 83
        • 84
        • 85
        • 86
        • 87
        • 88
        • 89
        • 90
        • 91
        • 92
        • 93
        • 94
        • 95
        • 96
        • 97
        • 98
        • 99
        • 100
        • 101
        • 102
        • 103
        • 104
        • 105
        • 106
        • 107
        • 108
        • 109
        • 110
        • 111
        • 112
        • 113
        • 114
        • 115
        • 116
        • 117
        • 118
        • 119
        • 120
        • 121
        • 122
        • 123
        • 124
        • 125
        • 126
        • 127
        • 128
        • 129
        • 130
        • 131
        • 132
        • 133
        • 134
        • 135
        • 136
        • 137
        • 138
        • 139
        • 140
        • 141
        • 142
        • 143
        • 144
        • 145
        • 146
        • 147
        • 148
        • 149
        • 150
        • 151
        • 152
        • 153
        • 154
        • 155
        • 156
        • 157
        • 158
        • 159
        • 160
        • 161
        • 162
        • 163
        • 164
        • 165
        • 166
        • 167
        • 168
        • 169
        • 170
        • 171
        • 172
        • 173
        • 174
        • 175
        • 176
        • 177
        • 178
        • 179
        • 180
        • 181
        • 182
        • 183
        • 184
        • 185
        • 186
        • 187
        • 188
        • 189
        • 190
        • 191
        • 192
        • 193
        • 194
        • 195
        • 196
        • 197
        • 198
        • 199
        • 200
        • 201
        • 202
        • 203
        • 204
        • 205
        • 206
        • 207
        • 208
        • 209
        • 210
        • 211
        • 212
        • 213

      • 测试结果：

        ---------录入第1部手机的信息---------
请您输入手机的品牌：
华为nova7
请您输入手机的价格：
3999.9
请您选择手机的颜色：
1.深海蓝
2.茉莉绿
3.珍珠白
4.靓丽粉
5.朱砂黑
3
---------录入第2部手机的信息---------
请您输入手机的品牌：
iphone14_plus
请您输入手机的价格：
8999
请您选择手机的颜色：
1.深海蓝
2.茉莉绿
3.珍珠白
4.靓丽粉
5.朱砂黑
4
---------录入第3部手机的信息---------
请您输入手机的品牌：
vivo
请您输入手机的价格：
5666
请您选择手机的颜色：
1.深海蓝
2.茉莉绿
3.珍珠白
4.靓丽粉
5.朱砂黑
1

所有手机信息如下：
手机品牌：华为nova7，手机价格：3999.9元，手机颜色：珍珠白
手机品牌：iphone14_plus，手机价格：8999.0元，手机颜色：靓丽粉
手机品牌：vivo，手机价格：5666.0元，手机颜色：深海蓝

所有手机的平均价格为：5666.0元~

Process finished with exit code 0


        • 1
        • 2
        • 3
        • 4
        • 5
        • 6
        • 7
        • 8
        • 9
        • 10
        • 11
        • 12
        • 13
        • 14
        • 15
        • 16
        • 17
        • 18
        • 19
        • 20
        • 21
        • 22
        • 23
        • 24
        • 25
        • 26
        • 27
        • 28
        • 29
        • 30
        • 31
        • 32
        • 33
        • 34
        • 35
        • 36
        • 37
        • 38
        • 39
        • 40
        • 41
        • 42
        • 43
        • 44
        • 45
        • 46
    4、对象数组练习4

    • 需求：

      • 定义数组存储4个女朋友的对象。
      • 女朋友的属性：姓名、年龄、性别、爱好。
      • 要求：
        • 计算出所有女朋友的平均年龄。
        • 统计年龄比平均值低的女朋友有几个？并把他们的所有信息打印出来。

    • 分析：

      • 需要一个女朋友类，用于将女朋友的信息封装成一个女朋友对象
      • 需要一个数组存储所有女朋友对象。
      • 需要求出最高年龄、最低年龄、总年龄，然后平均年龄 == (总年龄 - 最高年龄 - 最低年龄) / (个数)
      • 需要一个变量统计比平均年龄低的女朋友有几个
      • 需要打印出比平均年龄低的女朋友的信息

    • 实现：

      • 女朋友类

        package com.app.demo19_object_array4;

/*
    女朋友类
 */
public class GirlFriend {
    /*
        定义女朋友的属性：
            姓名、年龄、性别、爱好
     */
    private String name;
    private int age;
    private char gender;
    private String hobby;

    /*
        有参、无参构造器
     */
    public GirlFriend() {

    }

    public GirlFriend(String name, int age, char gender, String happy) {
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.hobby = happy;
    }

    /*
        提供全套的getXXX和setXXX方法，
        暴露其属性的取值和赋值
     */
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public char getGender() {
        return gender;
    }

    public void setGender(char gender) {
        this.gender = gender;
    }

    public String getHobby() {
        return hobby;
    }

    public void setHobby(String hobby) {
        this.hobby = hobby;
    }
}

        • 1
        • 2
        • 3
        • 4
        • 5
        • 6
        • 7
        • 8
        • 9
        • 10
        • 11
        • 12
        • 13
        • 14
        • 15
        • 16
        • 17
        • 18
        • 19
        • 20
        • 21
        • 22
        • 23
        • 24
        • 25
        • 26
        • 27
        • 28
        • 29
        • 30
        • 31
        • 32
        • 33
        • 34
        • 35
        • 36
        • 37
        • 38
        • 39
        • 40
        • 41
        • 42
        • 43
        • 44
        • 45
        • 46
        • 47
        • 48
        • 49
        • 50
        • 51
        • 52
        • 53
        • 54
        • 55
        • 56
        • 57
        • 58
        • 59
        • 60
        • 61
        • 62
        • 63
        • 64
        • 65

      • 测试类

        package com.app.demo19_object_array4;

import java.util.Scanner;

/*
    面向对象综合训练：对象数组练习4
    需求：
        - 定义数组存储4个女朋友的对象。
        - 女朋友的属性：姓名、年龄、性别、爱好。
        - 要求：
          - 1、计算出所有女朋友的平均年龄。
          - 2、统计年龄比平均值低的女朋友有几个？并把他们的所有信息打印出来。
 */
public class GirlFriendTest {
    public static void main(String[] args) {
        // 1、创建一个女朋友对象的数组，用于存储多个女朋友对象
        GirlFriend[] girlFriends = createGirlFriends(4);

        // 2、查看所有女朋友的信息
        showGirlFriends(girlFriends);

        // 3、计算出所有女朋友的平均年龄
        int averageAge = girlFriendsAverAgeAge(girlFriends);
        System.out.println("所有女朋友的平均年龄为：" + averageAge + "岁");

        // 4、统计年龄比平均年龄低的女朋友有几个？并把这些女朋友的信息打印出来
        underAverAgeAgeGirlFriends(girlFriends, averageAge);
    }


    /**
     * 统计年龄比平均年龄低的女朋友个数
     *
     * @param girlFriends 所有女朋友年龄的数组
     * @param averageAge  所有女朋友的平均年龄
     */
    public static void underAverAgeAgeGirlFriends(GirlFriend[] girlFriends, int averageAge) {
        // 1、判断数组参数是否为null
        if (girlFriends == null) {
            // 为null
            System.out.println("您的数组不能为null~");
            return; // 结束方法
        }

        // 2、定义计数器，用于记录比平均年龄低的女朋友有多少个
        int count = 0;

        // 3、遍历数组，依次得到每个女朋友对象
        System.out.println("\n低于平均年龄的女朋友信息如下：");
        for (int i = 0; i < girlFriends.length; i++) {
            // a.判断当前女朋友的年龄 是否小于 平均年龄
            if (girlFriends[i].getAge() < averageAge) {
                // 小于，开始计数
                count++;
                // 打印当前这个女朋友的信息
                System.out.println("姓名：" + girlFriends[i].getName() +
                        "，年龄：" + girlFriends[i].getAge() + "岁" +
                        "，性别：" + girlFriends[i].getGender() +
                        "，爱好：" + girlFriends[i].getHobby());
            }
        }

        // 4、循环结束，低于平均年龄的女朋友统计完成，输出个数
        System.out.println("\n低于平均年龄的女朋友有" + count + "个。");
    }


    /**
     * 计算所有女朋友的平均年龄
     *
     * @param girlFriends 所有女朋友对象的数组
     * @return 返回所有女朋友的平均年龄
     */
    public static int girlFriendsAverAgeAge(GirlFriend[] girlFriends) {
        // 1、判断数组是否为null
        if (girlFriends == null) {
            System.out.println("您的数组不能为null~");
            return 0;
        }

        // 2、定义数组，用于存储所有女朋友的年龄
        int[] ages = new int[girlFriends.length];

        // 3、遍历girlFriends数组，依次得到每个女朋友对象
        for (int i = 0; i < girlFriends.length; ) {
            // girlFriends[i]: 依次表示每个女朋友对象

            // 4、遍历ages数组，依次存入每个女朋友的年龄
            for (int j = 0; j < ages.length; j++) {
                // 依次存入年龄
                ages[j] = girlFriends[i].getAge();
                // 存入成功后，让i自增，继续得到下一个女朋友的对象
                i++;
            }
        }

        // 5、定义变量，分别表示：最高年龄、最低年龄、总年龄
        int maxAge = ages[0];
        int minAge = ages[0];
        int sumAge = 0;

        // 6、遍历ages数组，依次得到每个女朋友的年龄
        for (int age : ages) {
            // 求所有女朋友的最高年龄
            if (age > maxAge) {
                maxAge = age;
            }

            // 求所有女朋友的最低年龄
            if (age < minAge) {
                minAge = age;
            }

            // 求所有女朋友的总年龄
            sumAge += age;
        }

        System.out.println("最高年龄：" + maxAge + "岁");
        System.out.println("最低年龄：" + minAge + "岁");
        System.out.println("总年龄：" + sumAge + "岁");

        // 7、计算平均年龄后返回给调用处
        return (sumAge - maxAge - minAge) / (ages.length - 2);
    }


    /**
     * 查看所有女朋友的信息
     *
     * @param girlFriends 女朋友对象的数组
     */
    public static void showGirlFriends(GirlFriend[] girlFriends) {
        // 1、判断数组是否为null
        if (girlFriends == null) {
            System.out.println("您的数组不能为null~");
            return;
        }

        // 2、遍历数组，依次得到每个女朋友对象
        System.out.println("\n所有女朋友的信息如下：");
        for (GirlFriend girlFriend : girlFriends) {
            // 输出信息
            System.out.println("姓名：" + girlFriend.getName() +
                    "，年龄：" + girlFriend.getAge() + "岁" +
                    "，性别：" + girlFriend.getGender() +
                    "，爱好：" + girlFriend.getHobby());
        }
    }


    /**
     * 创建女朋友对象
     *
     * @param length 数组的长度：表示可以存储多少个女朋友对象
     * @return 返回存储有女朋友对象的数组
     */
    public static GirlFriend[] createGirlFriends(int length) {
        // 1、数组的长度不能为0
        if (length == 0) {
            System.out.println("您的数组长度不能为0~");
            return null;
        }

        // 2、定义数组，用于存储女朋友对象，长度为length
        GirlFriend[] girlFriends = new GirlFriend[length];
        // [0, 1, 2, 4]

        // 3、创建键盘录入对象，用于录入女朋友的信息
        Scanner sc = new Scanner(System.in);

        // 4、录入女朋友的信息
        // 遍历数组，依次得到每个元素的索引位置
        for (int i = 0; i < girlFriends.length; i++) {
            // a.创建一个空的女朋友对象，用于封装录入的女朋友信息
            GirlFriend girlFriend = new GirlFriend();

            System.out.println("-----开始录入第" + (i + 1) + "个女朋友的信息-----");
            // 录入姓名
            System.out.println("请输入女朋友的姓名：");
            String name = sc.next();
            girlFriend.setName(name);

            // 录入年龄
            try {
                while (true) {
                    System.out.println("请输入女朋友的年龄：");
                    int age = sc.nextInt();

                    // 判断输入的年龄是否为负数 或 大于200岁
                    if (age < 0 || age > 200) {
                        // 是负数 或 大于200岁
                        System.out.println("您输入的年龄是非法的~ 请重新输入！");
                    } else if (age < 200){
                        // 年龄合法，录入年龄
                        girlFriend.setAge(age);
                        break;
                    }
                }
            } catch (Exception e) {
                System.out.println("您输入的年龄数据有误~ 该女朋友的年龄将设为默认值：0岁");
            }


            // 录入性别
            while (true) {
                System.out.println("请输入女朋友的性别：");
                String gender = sc.next();

                // 判断录入的性别是否为 女
                if (gender.equals("女")) {
                    // 是，则提取性别封装进女朋友对象
                    char newGender = gender.charAt(0);
                    girlFriend.setGender(newGender);
                    // 封装完成，跳出循环
                    break;
                } else {
                    // 不是，则循环让用户重新录入性别
                    System.out.println("您输入的性别有误~ 请重新输入！");
                }
            }

            // 录入爱好
            System.out.println("请输入女朋友的爱好：");
            String happy = sc.next();
            girlFriend.setHobby(happy);

            // 将封装好的女朋友对象，依次存入数组中
            girlFriends[i] = girlFriend;
        }

        // 5、循环结束，返回存储有女朋友对象的数组
        return girlFriends;
    }
}

        • 1
        • 2
        • 3
        • 4
        • 5
        • 6
        • 7
        • 8
        • 9
        • 10
        • 11
        • 12
        • 13
        • 14
        • 15
        • 16
        • 17
        • 18
        • 19
        • 20
        • 21
        • 22
        • 23
        • 24
        • 25
        • 26
        • 27
        • 28
        • 29
        • 30
        • 31
        • 32
        • 33
        • 34
        • 35
        • 36
        • 37
        • 38
        • 39
        • 40
        • 41
        • 42
        • 43
        • 44
        • 45
        • 46
        • 47
        • 48
        • 49
        • 50
        • 51
        • 52
        • 53
        • 54
        • 55
        • 56
        • 57
        • 58
        • 59
        • 60
        • 61
        • 62
        • 63
        • 64
        • 65
        • 66
        • 67
        • 68
        • 69
        • 70
        • 71
        • 72
        • 73
        • 74
        • 75
        • 76
        • 77
        • 78
        • 79
        • 80
        • 81
        • 82
        • 83
        • 84
        • 85
        • 86
        • 87
        • 88
        • 89
        • 90
        • 91
        • 92
        • 93
        • 94
        • 95
        • 96
        • 97
        • 98
        • 99
        • 100
        • 101
        • 102
        • 103
        • 104
        • 105
        • 106
        • 107
        • 108
        • 109
        • 110
        • 111
        • 112
        • 113
        • 114
        • 115
        • 116
        • 117
        • 118
        • 119
        • 120
        • 121
        • 122
        • 123
        • 124
        • 125
        • 126
        • 127
        • 128
        • 129
        • 130
        • 131
        • 132
        • 133
        • 134
        • 135
        • 136
        • 137
        • 138
        • 139
        • 140
        • 141
        • 142
        • 143
        • 144
        • 145
        • 146
        • 147
        • 148
        • 149
        • 150
        • 151
        • 152
        • 153
        • 154
        • 155
        • 156
        • 157
        • 158
        • 159
        • 160
        • 161
        • 162
        • 163
        • 164
        • 165
        • 166
        • 167
        • 168
        • 169
        • 170
        • 171
        • 172
        • 173
        • 174
        • 175
        • 176
        • 177
        • 178
        • 179
        • 180
        • 181
        • 182
        • 183
        • 184
        • 185
        • 186
        • 187
        • 188
        • 189
        • 190
        • 191
        • 192
        • 193
        • 194
        • 195
        • 196
        • 197
        • 198
        • 199
        • 200
        • 201
        • 202
        • 203
        • 204
        • 205
        • 206
        • 207
        • 208
        • 209
        • 210
        • 211
        • 212
        • 213
        • 214
        • 215
        • 216
        • 217
        • 218
        • 219
        • 220
        • 221
        • 222
        • 223
        • 224
        • 225
        • 226
        • 227
        • 228
        • 229
        • 230
        • 231
        • 232
        • 233
        • 234

      • 测试结果

        -----开始录入第1个女朋友的信息-----
请输入女朋友的姓名：
张靓颖
请输入女朋友的年龄：
19
请输入女朋友的性别：
男
您输入的性别有误~ 请重新输入！
请输入女朋友的性别：
大家
您输入的性别有误~ 请重新输入！
请输入女朋友的性别：
女
请输入女朋友的爱好：
唱歌、跳舞、服装
-----开始录入第2个女朋友的信息-----
请输入女朋友的姓名：
刘亦菲
请输入女朋友的年龄：
20
请输入女朋友的性别：
女
请输入女朋友的爱好：
打游戏、演戏、唱歌
-----开始录入第3个女朋友的信息-----
请输入女朋友的姓名：
杨幂
请输入女朋友的年龄：
28
请输入女朋友的性别：
女
请输入女朋友的爱好：
美食、旅游、逛街
-----开始录入第4个女朋友的信息-----
请输入女朋友的姓名：
田馥甄
请输入女朋友的年龄：
22
请输入女朋友的性别：
女
请输入女朋友的爱好：
爱唱小幸运

所有女朋友的信息如下：
姓名：张靓颖，年龄：19岁，性别：女，爱好：唱歌、跳舞、服装
姓名：刘亦菲，年龄：20岁，性别：女，爱好：打游戏、演戏、唱歌
姓名：杨幂，年龄：28岁，性别：女，爱好：美食、旅游、逛街
姓名：田馥甄，年龄：22岁，性别：女，爱好：爱唱小幸运
最高年龄：28岁
最低年龄：19岁
总年龄：89岁
所有女朋友的平均年龄为：21岁

低于平均年龄的女朋友信息如下：
姓名：张靓颖，年龄：19岁，性别：女，爱好：唱歌、跳舞、服装
姓名：刘亦菲，年龄：20岁，性别：女，爱好：打游戏、演戏、唱歌

低于平均年龄的女朋友有2个。

Process finished with exit code 0


        • 1
        • 2
        • 3
        • 4
        • 5
        • 6
        • 7
        • 8
        • 9
        • 10
        • 11
        • 12
        • 13
        • 14
        • 15
        • 16
        • 17
        • 18
        • 19
        • 20
        • 21
        • 22
        • 23
        • 24
        • 25
        • 26
        • 27
        • 28
        • 29
        • 30
        • 31
        • 32
        • 33
        • 34
        • 35
        • 36
        • 37
        • 38
        • 39
        • 40
        • 41
        • 42
        • 43
        • 44
        • 45
        • 46
        • 47
        • 48
        • 49
        • 50
        • 51
        • 52
        • 53
        • 54
        • 55
        • 56
        • 57
        • 58
        • 59
        • 60
        • 61
    5、对象数组练习5

    • 需求：

      • 定义长度为3的数组，数组存储1~3名学生对象作为初始数据，学生对象的学号，姓名各不相同。

      • 学生的属性：学号、姓名、年龄。

      • 要求：

        • 1、再次添加一个学生对象，并在添加的时候进行学号的唯一性判断。
        • 2、添加完毕之后，遍历所有学生信息。
        • 3、通过id删除学生信息：存在则删除、不存在提示该学生不存在，删除失败。
        • 4、删除完毕之后，遍历所有学生信息。
        • 5、查询数组id为 “112” 的学生，如果存在，则将他的年龄+1岁。

      • 分析：

        • 1、需要定义一个学生类，用于将学生信息封装成一个学生对象。
        • 2、需要定义一个数组，长度为3，用于存储学生对象。
        • 3、需要初始化几个学生对象存入数组。
        • 4、需要实现添加学生的功能：
          • 4-1、录入学生学号：
            • 判断学号的唯一性：
              • 如果存在，则提示：“该学生学号已存在！”，重新录入学号；
              • 如果不存在，则判断数组是否已存满：
                • 如果已存满，则创建一个新数组，长度是老数组长度+1，还需将老数组的全部学生对象拷贝到新数组中
                  • 然后继续录入学生信息：
                  • 录入学生姓名
                  • 录入学生年龄：
                    • 判断年龄合法性：年龄要求大于等于0岁，并小于等于200岁。
                  • 将学生对象添加进数组。
                • 如果未存满，则继续录入学生信息：
                  • 录入学生姓名
                  • 录入学生年龄：
                    • 判断年龄合法性：年龄要求大于等于0岁，并小于等于200岁。
                  • 将学生对象添加进数组。
        • 5、需要实现查看所有学生信息的功能：
          • 5-1、判断当前学生对象是否不为null：
            • 不为null，则打印该学生的信息
            • 为null，则继续查看下一个
        • 6、需要实现根据学号删除学生信息的功能：
          • 6-1、判断当前学生对象是否不为null：
            • 不为null，则判断学号是否一样：
              • 一样，则返回该学生在数组中的索引位置
              • 不一样，则继续判断下一个学生
          • 6-2、循环结束，说明该学生不存在，返回-1
          • 6-3、判断返回结果是否大于等于0：
            • 是，则说明该学生存在，将该学生对象删除
            • 不是，则提示：”该学生不存在，删除失败！“
        • 7、需要实现根据学号查询学生信息的功能：
          • 7-1、判断当前学生对象是否不为null：
            • 不为null，则判断学号是否一样：
              • 一样，则返回该学生在数组中的索引位置
              • 不一样，则继续判断下一个学生
          • 7-2、循环结束，说明该学生不存在，返回-1
          • 7-3、判断返回结束是否大于等于0：
            • 是，则说明该学生存在，则拿出该学生的年龄+1岁，再将+1岁后的年龄塞回去。
            • 不是，则说明该学生不存在，修改失败！

      • 实现：

        • 学生类：

          package com.app.demo20_object_array5;

/*
    1、需要定义一个学生类，用于将学生信息封装成一个学生对象。
 */
public class Student {
    // 学生属性：学号、姓名、年龄
    private String id;
    private String name;
    private int age;

    public Student() {

    }

    public Student(String id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

          • 1
          • 2
          • 3
          • 4
          • 5
          • 6
          • 7
          • 8
          • 9
          • 10
          • 11
          • 12
          • 13
          • 14
          • 15
          • 16
          • 17
          • 18
          • 19
          • 20
          • 21
          • 22
          • 23
          • 24
          • 25
          • 26
          • 27
          • 28
          • 29
          • 30
          • 31
          • 32
          • 33
          • 34
          • 35
          • 36
          • 37
          • 38
          • 39
          • 40
          • 41
          • 42
          • 43
          • 44
          • 45

        • 测试类：

          package com.app.demo20_object_array5;

import java.util.Scanner;

/*
    测试类
 */
public class Test {
    public static void main(String[] args) {
        // 2、需要定义一个数组，长度为3，用于存储学生对象。
        Student[] students = new Student[3];

        // 3、需要初始化几个学生对象存入数组。
        students[0] = new Student("jj01", "张飞", 34);
        students[1] = new Student("jj02", "关羽", 12);

        // 主页面
        homePage(students);
    }


    /**
     * 主界面
     *
     * @param students 学生对象数组
     */
    public static void homePage(Student[] students) {
        // 1、创建键盘录入对象
        Scanner sc = new Scanner(System.in);

        while (true) {
            System.out.println("------学生管理界面------");
            System.out.println("1、添加学生信息");
            System.out.println("2、根据学号删除学生信息");
            System.out.println("3、根据学号修改学生年龄(+1岁)");
            System.out.println("4、查看所有学生的信息");
            System.out.println("5、退出界面");
            System.out.println("请您选择：");
            String command = sc.next();
            switch (command) {
                case "1":
                    // 4、需要实现添加学生的功能
                    students = addStudent(students, sc);
                    break;
                case "2":
                    // 根据学号删除学生信息
                    deleteByStudentId(students, sc);
                    break;
                case "3":
                    // 根据学号修改学生年龄+1岁
                    updateByStudentId(students, sc);
                    break;
                case "4":
                    // 查看所有学生的信息
                    showStudents(students);
                    break;
                case "5":
                    System.out.println("成功退出学生管理界面~");
                    return;
                default:
                    System.out.println("该功能未开发！请敬请等候~~");
            }
        }
    }


    /**
     * 实现根据学号修改学生信息的功能
     * @param students      学生对象数组
     * @param sc            键盘录入对象
     */
    public static void updateByStudentId(Student[] students, Scanner sc) {
        if (students == null || sc == null) {
            System.out.println("您的学生对象数组或键盘录入对象不能为null~");
            return;
        }

        System.out.println("-------根据学号修改学生年龄-------");

        // 1、输入要修改的学生的学号
        System.out.println("请您输入要修改的学生的学号：");
        String id = sc.next();

        // 2、获取该学生对象在数组中的索引位置
        int index = getStudentIndex(students, id);
        // 判断该学生对象的索引是否大于等于0
        if (index >= 0) {
            // 是，则说明学生存在
            // 得到该学生对象，接收一下
            Student student = students[index];
            // 原本的年龄
            System.out.println("学生" + student.getName() + "的原年龄为：" + student.getAge() + "岁");

            // 拿出该学生的年龄属性，+1岁
            int age = students[index].getAge() + 1;
            // 再将新的年龄塞回去
            students[index].setAge(age);
            System.out.println("学号为" + id + "的学生年龄修改成功~");
            System.out.println("学生" + students[index].getName() + "修改后的年龄为：" + student.getAge() + "岁");
        }else {
            // 不是，则说明该学生不存在，修改失败
            System.out.println("您要修改的学生不存在！修改失败~");
        }
    }


    /**
     * 实现根据学号删除学生信息的功能
     * @param students      学生对象数组
     * @param sc            键盘录入对象
     */
    public static void deleteByStudentId(Student[] students, Scanner sc) {
        if (students == null || sc == null) {
            System.out.println("您的学生数组或键盘录入对象不能为null~");
            return;
        }

        System.out.println("-------根据学号删除学生信息-------");

        // 1、录入要删除的学生学号
        System.out.println("请您输入要删除的学生的学号：");
        String id = sc.next();

        // 2、获取该学生对象在数组中的索引位置
        int index = getStudentIndex(students, id);
        // 判断该学生对象索引是否大于等于0
        if (index >= 0) {
            // 是，则删除该学生对象：将该元素赋值为null
            students[index] = null;
            System.out.println("学号为" + id + "的学生已成功删除~");
        }else {
            // 不是，则说明该学生不存在，删除失败！
            System.out.println("您要删除的学生不存在！删除失败~");
        }
    }


    /**
     * 实现获取指定学号的学生对象在数组中的索引位置
     * @param students      学生对象数组
     * @param id            学生学号
     * @return              返回学生对象在数组中的索引位置
     */
    public static int getStudentIndex(Student[] students, String id) {
        if (students == null || id == null) {
            System.out.println("您的学生数组或学生学号不能为null~");
            return 0;
        }

        // 1、遍历学生对象数组，依次获取每个学生对象
        for (int i = 0; i < students.length; i++) {
            // 每获取到一个学生对象，接收一下
            Student student = students[i];

            // 判断当前学生对象是否不为null：
            if (student != null) {
                // 不为null，拿到当前学生对象的学号
                String stuId = student.getId();
                // 判断学号是否一样：
                if (id.equals(stuId)) {
                    // 一样，则返回该学生在数组中的索引位置
                    return i;
                }

                // 不一样，则继续判断下一个学生
            }
        }

        // 2、遍历结束，说明仍然找不到要删除的学生，返回-1
        return -1;
    }


    /**
     * 实现查看所有学生信息的功能
     *
     * @param students 学生对象数组
     */
    public static void showStudents(Student[] students) {
        if (students == null) {
            System.out.println("您的学生对象数组不能为null~");
            return;
        }

        System.out.println("-------查看所有学生的信息-------");
        // 1、遍历学生对象数组，依次获取每个学生对象
        for (int i = 0; i < students.length; i++) {
            // 每获取到一个学生对象，接收一下
            Student student = students[i];
            // 当该学生对象不为null时，才打印该学生信息
            if (student != null) {
                System.out.println("学号：" + student.getId() +
                        "\t姓名：" + student.getName() +
                        "\t年龄：" + student.getAge() + "岁");
            }
        }
    }


    /**
     * 实现添加学生的功能
     *
     * @param students 学生对象数组
     * @param sc       键盘录入对象
     */
    public static Student[] addStudent(Student[] students, Scanner sc) {
        if (students == null || sc == null) {
            System.out.println("学生数组或键盘录入对象不能为null~");
            return null;
        }

        System.out.println("-------添加学生信息界面-------");

        //4-1、录入学生学号：
        while (true) {
            System.out.println("请您输入学生学号：");
            String id = sc.next();

            // a.判断学号的唯一性：
            boolean flag = containsId(students, id);
            if (flag) {
                // 如果存在，则提示：“该学生学号已存在！”，重新录入学号；
                System.out.println("该学号的学生已存在~ 请重新录入学号！");
            } else {
                // 如果不存在，则判断数组是否已存满：
                // 获取数组中有多少个元素
                int count = getArrayCount(students);
                // 判断数组中的元素个数 是否与 数组长度相等
                if (count == students.length) {
                    // 相等，说明数组已存满，则创建一个新数组，长度是老数组长度+1
                    Student[] newStudents = new Student[students.length + 1];
                    // 需将老数组的全部学生对象拷贝到新数组中
                    for (int i = 0; i < students.length; i++) {
                        newStudents[i] = students[i];
                    }

                    // 然后继续录入学生信息：
                    // 录入学生姓名
                    System.out.println("请您输入学生姓名：");
                    String name = sc.next();

                    // 录入学生年龄：
                    System.out.println("请您输入学生年龄：");
                    int age = sc.nextInt();
                    // 判断年龄合法性：年龄要求大于等于0岁，并小于等于200岁。
                    if (age >= 0 && age <= 200) {
                        // 封装学生信息进学生对象
                        Student student = new Student(id, name, age);
                        // 将学生对象添加进新数组。
                        newStudents[count] = student;
                        System.out.println("名叫" + name + "的学生添加成功~");
                        // 添加成功后，返回新数组
                        return newStudents;
                    }

                } else {
                    // 不相等，说明数组未存满，则继续录入学生信息：
                    // 录入学生姓名
                    System.out.println("请您输入学生姓名：");
                    String name = sc.next();

                    // 录入学生年龄：
                    System.out.println("请您输入学生年龄：");
                    int age = sc.nextInt();
                    // 判断年龄合法性：年龄要求大于等于0岁，并小于等于200岁。
                    if (age >= 0 && age <= 200) {
                        // 封装学生信息进学生对象
                        Student student = new Student(id, name, age);
                        // 将学生对象添加进数组。
                        /*
                            1、比如现在数组中有2个学生对象，有一个空位：
                                [学生1, 学生2, null]
                              索引：0     1     2
                            2、此时count计数：2
                            3、students[count] = student：
                               就是把当前封装好的学生对象放进2索引的位置，由于2索引位置为null，因此添加成功
                         */
                        students[count] = student;
                        System.out.println("名叫" + name + "的学生添加成功~");
                        // 添加成功后，返回原数组
                        return students;
                    }
                }
            }
        }
    }


    /**
     * 获取数组的元素个数
     *
     * @param students 学生对象数组
     * @return 返回数组的元素个数
     */
    public static int getArrayCount(Student[] students) {
        if (students == null) {
            System.out.println("您的学生数组不能为null");
            return 0;
        }

        // 1、定义计数器，用于统计数组的元素个数
        int count = 0;

        // 2、遍历学生对象数组，依次获取每个学生对象
        for (int i = 0; i < students.length; i++) {
            // 每获取到一个学生对象，接收一下
            Student student = students[i];
            // 判断当前学生对象是否不为null
            if (student != null) {
                // 不为null，则说明该索引位置存在元素，开始统计
                count++;
            }
        }

        // 3、遍历结束，说明统计完成，返回数组的元素个数
        return count;
    }


    /**
     * 判断学生学号的唯一性
     *
     * @param students 学生对象数组
     * @param id       学生学号
     * @return 存在返回true，不存在返回false
     */
    public static boolean containsId(Student[] students, String id) {
        // 1、遍历学生对象数组，依次获取每个学生对象
        for (int i = 0; i < students.length; i++) {
            // 每获取到一个学生对象，接收一下
            Student student = students[i];
            // 判断当前学生对象是否不为null
            if (student != null) {
                // 不为null，则获取到当前学生对象的学号，接收一下
                String stuId = student.getId();

                // 判断学号是否一样
                if (stuId.equals(id)) {
                    // 一样，说明学生存在，返回true
                    return true;
                }
            }
        }

        // 2、遍历结束，仍然找不到该学号的学生，返回false
        return false;
    }
}

          • 1
          • 2
          • 3
          • 4
          • 5
          • 6
          • 7
          • 8
          • 9
          • 10
          • 11
          • 12
          • 13
          • 14
          • 15
          • 16
          • 17
          • 18
          • 19
          • 20
          • 21
          • 22
          • 23
          • 24
          • 25
          • 26
          • 27
          • 28
          • 29
          • 30
          • 31
          • 32
          • 33
          • 34
          • 35
          • 36
          • 37
          • 38
          • 39
          • 40
          • 41
          • 42
          • 43
          • 44
          • 45
          • 46
          • 47
          • 48
          • 49
          • 50
          • 51
          • 52
          • 53
          • 54
          • 55
          • 56
          • 57
          • 58
          • 59
          • 60
          • 61
          • 62
          • 63
          • 64
          • 65
          • 66
          • 67
          • 68
          • 69
          • 70
          • 71
          • 72
          • 73
          • 74
          • 75
          • 76
          • 77
          • 78
          • 79
          • 80
          • 81
          • 82
          • 83
          • 84
          • 85
          • 86
          • 87
          • 88
          • 89
          • 90
          • 91
          • 92
          • 93
          • 94
          • 95
          • 96
          • 97
          • 98
          • 99
          • 100
          • 101
          • 102
          • 103
          • 104
          • 105
          • 106
          • 107
          • 108
          • 109
          • 110
          • 111
          • 112
          • 113
          • 114
          • 115
          • 116
          • 117
          • 118
          • 119
          • 120
          • 121
          • 122
          • 123
          • 124
          • 125
          • 126
          • 127
          • 128
          • 129
          • 130
          • 131
          • 132
          • 133
          • 134
          • 135
          • 136
          • 137
          • 138
          • 139
          • 140
          • 141
          • 142
          • 143
          • 144
          • 145
          • 146
          • 147
          • 148
          • 149
          • 150
          • 151
          • 152
          • 153
          • 154
          • 155
          • 156
          • 157
          • 158
          • 159
          • 160
          • 161
          • 162
          • 163
          • 164
          • 165
          • 166
          • 167
          • 168
          • 169
          • 170
          • 171
          • 172
          • 173
          • 174
          • 175
          • 176
          • 177
          • 178
          • 179
          • 180
          • 181
          • 182
          • 183
          • 184
          • 185
          • 186
          • 187
          • 188
          • 189
          • 190
          • 191
          • 192
          • 193
          • 194
          • 195
          • 196
          • 197
          • 198
          • 199
          • 200
          • 201
          • 202
          • 203
          • 204
          • 205
          • 206
          • 207
          • 208
          • 209
          • 210
          • 211
          • 212
          • 213
          • 214
          • 215
          • 216
          • 217
          • 218
          • 219
          • 220
          • 221
          • 222
          • 223
          • 224
          • 225
          • 226
          • 227
          • 228
          • 229
          • 230
          • 231
          • 232
          • 233
          • 234
          • 235
          • 236
          • 237
          • 238
          • 239
          • 240
          • 241
          • 242
          • 243
          • 244
          • 245
          • 246
          • 247
          • 248
          • 249
          • 250
          • 251
          • 252
          • 253
          • 254
          • 255
          • 256
          • 257
          • 258
          • 259
          • 260
          • 261
          • 262
          • 263
          • 264
          • 265
          • 266
          • 267
          • 268
          • 269
          • 270
          • 271
          • 272
          • 273
          • 274
          • 275
          • 276
          • 277
          • 278
          • 279
          • 280
          • 281
          • 282
          • 283
          • 284
          • 285
          • 286
          • 287
          • 288
          • 289
          • 290
          • 291
          • 292
          • 293
          • 294
          • 295
          • 296
          • 297
          • 298
          • 299
          • 300
          • 301
          • 302
          • 303
          • 304
          • 305
          • 306
          • 307
          • 308
          • 309
          • 310
          • 311
          • 312
          • 313
          • 314
          • 315
          • 316
          • 317
          • 318
          • 319
          • 320
          • 321
          • 322
          • 323
          • 324
          • 325
          • 326
          • 327
          • 328
          • 329
          • 330
          • 331
          • 332
          • 333
          • 334
          • 335
          • 336
          • 337
          • 338
          • 339
          • 340
          • 341
          • 342
          • 343
          • 344
          • 345
          • 346
          • 347
          • 348

        • 测试结果：

          ------学生管理界面------
1、添加学生信息
2、根据学号删除学生信息
3、根据学号修改学生年龄(+1岁)
4、查看所有学生的信息
5、退出界面
请您选择：
1
-------添加学生信息界面-------
请您输入学生学号：
jj01
该学号的学生已存在~ 请重新录入学号！
请您输入学生学号：
jj02
该学号的学生已存在~ 请重新录入学号！
请您输入学生学号：
jj03
请您输入学生姓名：
张三
请您输入学生年龄：
28
名叫张三的学生添加成功~
------学生管理界面------
1、添加学生信息
2、根据学号删除学生信息
3、根据学号修改学生年龄(+1岁)
4、查看所有学生的信息
5、退出界面
请您选择：
4
-------查看所有学生的信息-------
学号：jj01	姓名：张飞	年龄：34岁
学号：jj02	姓名：关羽	年龄：12岁
学号：jj03	姓名：张三	年龄：28岁
------学生管理界面------
1、添加学生信息
2、根据学号删除学生信息
3、根据学号修改学生年龄(+1岁)
4、查看所有学生的信息
5、退出界面
请您选择：
1
-------添加学生信息界面-------
请您输入学生学号：
jj04
请您输入学生姓名：
李四
请您输入学生年龄：
39
名叫李四的学生添加成功~
------学生管理界面------
1、添加学生信息
2、根据学号删除学生信息
3、根据学号修改学生年龄(+1岁)
4、查看所有学生的信息
5、退出界面
请您选择：
4
-------查看所有学生的信息-------
学号：jj01	姓名：张飞	年龄：34岁
学号：jj02	姓名：关羽	年龄：12岁
学号：jj03	姓名：张三	年龄：28岁
学号：jj04	姓名：李四	年龄：39岁
------学生管理界面------
1、添加学生信息
2、根据学号删除学生信息
3、根据学号修改学生年龄(+1岁)
4、查看所有学生的信息
5、退出界面
请您选择：
2
-------根据学号删除学生信息-------
请您输入要删除的学生的学号：
jj05
您要删除的学生不存在！删除失败~
------学生管理界面------
1、添加学生信息
2、根据学号删除学生信息
3、根据学号修改学生年龄(+1岁)
4、查看所有学生的信息
5、退出界面
请您选择：
2
-------根据学号删除学生信息-------
请您输入要删除的学生的学号：
jj01
学号为jj01的学生已成功删除~
------学生管理界面------
1、添加学生信息
2、根据学号删除学生信息
3、根据学号修改学生年龄(+1岁)
4、查看所有学生的信息
5、退出界面
请您选择：
4
-------查看所有学生的信息-------
学号：jj02	姓名：关羽	年龄：12岁
学号：jj03	姓名：张三	年龄：28岁
学号：jj04	姓名：李四	年龄：39岁
------学生管理界面------
1、添加学生信息
2、根据学号删除学生信息
3、根据学号修改学生年龄(+1岁)
4、查看所有学生的信息
5、退出界面
请您选择：
3
-------根据学号修改学生年龄-------
请您输入要修改的学生的学号：
jj01
您要修改的学生不存在！修改失败~
------学生管理界面------
1、添加学生信息
2、根据学号删除学生信息
3、根据学号修改学生年龄(+1岁)
4、查看所有学生的信息
5、退出界面
请您选择：
3
-------根据学号修改学生年龄-------
请您输入要修改的学生的学号：
jj03
学生张三的原年龄为：28岁
学号为jj03的学生年龄修改成功~
学生张三修改后的年龄为：29岁
------学生管理界面------
1、添加学生信息
2、根据学号删除学生信息
3、根据学号修改学生年龄(+1岁)
4、查看所有学生的信息
5、退出界面
请您选择：
4
-------查看所有学生的信息-------
学号：jj02	姓名：关羽	年龄：12岁
学号：jj03	姓名：张三	年龄：29岁
学号：jj04	姓名：李四	年龄：39岁
------学生管理界面------
1、添加学生信息
2、根据学号删除学生信息
3、根据学号修改学生年龄(+1岁)
4、查看所有学生的信息
5、退出界面
请您选择：
5
成功退出学生管理界面~

Process finished with exit code 0


          • 1
          • 2
          • 3
          • 4
          • 5
          • 6
          • 7
          • 8
          • 9
          • 10
          • 11
          • 12
          • 13
          • 14
          • 15
          • 16
          • 17
          • 18
          • 19
          • 20
          • 21
          • 22
          • 23
          • 24
          • 25
          • 26
          • 27
          • 28
          • 29
          • 30
          • 31
          • 32
          • 33
          • 34
          • 35
          • 36
          • 37
          • 38
          • 39
          • 40
          • 41
          • 42
          • 43
          • 44
          • 45
          • 46
          • 47
          • 48
          • 49
          • 50
          • 51
          • 52
          • 53
          • 54
          • 55
          • 56
          • 57
          • 58
          • 59
          • 60
          • 61
          • 62
          • 63
          • 64
          • 65
          • 66
          • 67
          • 68
          • 69
          • 70
          • 71
          • 72
          • 73
          • 74
          • 75
          • 76
          • 77
          • 78
          • 79
          • 80
          • 81
          • 82
          • 83
          • 84
          • 85
          • 86
          • 87
          • 88
          • 89
          • 90
          • 91
          • 92
          • 93
          • 94
          • 95
          • 96
          • 97
          • 98
          • 99
          • 100
          • 101
          • 102
          • 103
          • 104
          • 105
          • 106
          • 107
          • 108
          • 109
          • 110
          • 111
          • 112
          • 113
          • 114
          • 115
          • 116
          • 117
          • 118
          • 119
          • 120
          • 121
          • 122
          • 123
          • 124
          • 125
          • 126
          • 127
          • 128
          • 129
          • 130
          • 131
          • 132
          • 133
          • 134
          • 135
          • 136
          • 137
          • 138
          • 139
          • 140
          • 141
          • 142
          • 143
          • 144
          • 145
          • 146
          • 147
          • 148
          • 149
  • 相关阅读:
    windows 设置nginx、redis、jar包开机自启、mysql自动备份
    若依以及flowbale达梦国产化数据库改造_全网最细
    WPF 入门笔记 - 02 - 布局综合应用
    Apache Hive源码阅读环境搭建
    layui实现鼠标移入/移出时显示/隐藏tips
    入门编程第一步，从记住这些单词开始
    【Java 快速复习】垃圾回收算法 & 垃圾回收器
    贪心算法—Problem N
    【leetcode】【初级算法】【字符串9】最长公共前缀
    Kafka 的稳定性
  • 原文地址：https://blog.csdn.net/yelitoudu/article/details/127753618