面向对象综合训练

文字版格斗游戏

最原始的写法:

Javabean 类:

import java.util.Random;
 
public class Role {
    private int blood;
    private String name;
 
    public Role() {
    }
 
    public Role(int blood, String name) {
        this.blood = blood;
        this.name = name;
    }
 
    public int getBlood() {
        return blood;
    }
 
    public void setBlood(int blood) {
        this.blood = blood;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    // 攻击方法
    // 调用方法的对象攻击该方法的形参
    public void attack(Role role) {
        // 计算造成的伤害
        // 伤害是一个随机数, 范围是 [1, 20]
        Random r = new Random();
        // 得到造成的伤害
        int hurt = r.nextInt(20) + 1;
        // 获取被攻击者原来的血量
        int currentBlood = role.getBlood();
        // 计算被攻击者现在剩余的血量
        int remainBlood = currentBlood - hurt;
        // 当前血量低于造成的伤害时, 剩余血量将变为负数, 显然不可能, 此时将其赋值为 0
        remainBlood = remainBlood > 0 ? remainBlood : 0;
        // 将剩余血量赋值给被攻击的对象
        role.setBlood(remainBlood);
        // 打印攻击的过程
        System.out.println(this.getName() + "打了" + role.getName() + "一下, 造成了 " + hurt + " 点伤害, " +
                role.getName() + "还剩下 " + role.getBlood() + " 点血量.");
    }
}

测试类:

public class GameTest {
    public static void main(String[] args) {
        // 创建一个角色
        Role role1 = new Role(100, "乔峰");
        // 创建另一个角色
        Role role2 = new Role(100, "鸠摩智");
        // 开始格斗, 回合制游戏
        while (true) {
            // role1 先攻击 role2
            role1.attack(role2);
            // 判断 role2 剩余血量, 从而决定循环是否继续
            if (role2.getBlood() == 0) {
                System.out.println(role1.getName() + "K.O. 了" + role2.getName());
                break;
            }
 
            // 回合制游戏, 轮到 role2 攻击 role1 了
            // role2 攻击 role1
            role2.attack(role1);
            // 判断 role1 剩余血量, 从而决定循环是否继续
            if (role1.getBlood() == 0) {
                System.out.println(role2.getName() + " K.O. 了" + role1.getName());
                break;
            }
        }
    }
}

执行结果:

乔峰打了鸠摩智一下, 造成了 17 点伤害, 鸠摩智还剩下 83 点血量.
鸠摩智打了乔峰一下, 造成了 9 点伤害, 乔峰还剩下 91 点血量.
乔峰打了鸠摩智一下, 造成了 6 点伤害, 鸠摩智还剩下 77 点血量.
鸠摩智打了乔峰一下, 造成了 1 点伤害, 乔峰还剩下 90 点血量.
乔峰打了鸠摩智一下, 造成了 11 点伤害, 鸠摩智还剩下 66 点血量.
鸠摩智打了乔峰一下, 造成了 18 点伤害, 乔峰还剩下 72 点血量.
乔峰打了鸠摩智一下, 造成了 4 点伤害, 鸠摩智还剩下 62 点血量.
鸠摩智打了乔峰一下, 造成了 7 点伤害, 乔峰还剩下 65 点血量.
乔峰打了鸠摩智一下, 造成了 12 点伤害, 鸠摩智还剩下 50 点血量.
鸠摩智打了乔峰一下, 造成了 4 点伤害, 乔峰还剩下 61 点血量.
乔峰打了鸠摩智一下, 造成了 19 点伤害, 鸠摩智还剩下 31 点血量.
鸠摩智打了乔峰一下, 造成了 13 点伤害, 乔峰还剩下 48 点血量.
乔峰打了鸠摩智一下, 造成了 7 点伤害, 鸠摩智还剩下 24 点血量.
鸠摩智打了乔峰一下, 造成了 20 点伤害, 乔峰还剩下 28 点血量.
乔峰打了鸠摩智一下, 造成了 19 点伤害, 鸠摩智还剩下 5 点血量.
鸠摩智打了乔峰一下, 造成了 1 点伤害, 乔峰还剩下 27 点血量.
乔峰打了鸠摩智一下, 造成了 8 点伤害, 鸠摩智还剩下 0 点血量.
乔峰 K.O. 了鸠摩智

丰富了内容之后的代码:

Javabean 类:

import java.util.Random;
 
public class Role {
    private int blood;
    private String name;
    private char gender;
    private String face; // 长相是随机的
 
    String[] boyfaces = {"风流俊雅", "气宇轩昂", "相貌英俊", "五官端正", "相貌平平", "一塌糊涂", "面目狰狞"};
    String[] girlfaces = {"美奂绝伦", "沉鱼落雁", "婷婷玉立", "身材娇好", "相貌平平", "相貌简陋", "惨不忍睹"};
 
    // attack 攻击描述：
    String[] attacks_desc = {
            "%s使出了一招【背心钉】，转到对方的身后，一掌向%s背心的灵台穴拍去。",
            "%s使出了一招【游空探爪】，飞起身形自半空中变掌为抓锁向%s。",
            "%s大喝一声，身形下伏，一招【劈雷坠地】，捶向%s双腿。",
            "%s运气于掌，一瞬间掌心变得血红，一式【掌心雷】，推向%s。",
            "%s阴手翻起阳手跟进，一招【没遮拦】，结结实实的捶向%s。",
            "%s上步抢身，招中套招，一招【劈挂连环】，连环攻向%s。"
    };
 
    // injured 受伤描述：
    String[] injureds_desc = {
            "结果%s退了半步，毫发无损",
            "结果给%s造成一处瘀伤",
            "结果一击命中，%s痛得弯下腰",
            "结果%s痛苦地闷哼了一声，显然受了点内伤",
            "结果%s摇摇晃晃，一跤摔倒在地",
            "结果%s脸色一下变得惨白，连退了好几步",
            "结果『轰』的一声，%s口中鲜血狂喷而出",
            "结果%s一声惨叫，像滩软泥般塌了下去"
    };
 
    public Role() {
    }
 
    public Role(int blood, String name, char gender) {
        this.blood = blood;
        this.name = name;
        this.gender = gender;
        // 随机长相
        setFace(gender);
    }
 
    public char getGender() {
        return gender;
    }
 
    public void setGender(char gender) {
        this.gender = gender;
    }
 
    public String getFace() {
        return face;
    }
 
    public void setFace(char gender) {
        // 长相随机
        Random r = new Random();
        if (gender == '男') {
            // 从 boyfaces 里面随机长相
            int index = r.nextInt(boyfaces.length);
            this.face = boyfaces[index];
        } else if (gender == '女') {
            // 从 gilrfaces 里面随机长相
            int index = r.nextInt(girlfaces.length);
            this.face = girlfaces[index];
        } else {
            System.out.println("性别错误.");
        }
        this.face = face;
    }
 
    public int getBlood() {
        return blood;
    }
 
    public void setBlood(int blood) {
        this.blood = blood;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    // 攻击方法
    // 调用方法的对象攻击该方法的形参
    public void attack(Role role) {
        Random r = new Random();
 
        // 打印攻击的效果
        int index = r.nextInt(attacks_desc.length);
        String Kungfu = attacks_desc[index];
        System.out.printf(Kungfu, this.getName(), role.getName());
 
        // 计算造成的伤害
        // 伤害是一个随机数, 范围是 [1, 20]
        // 得到造成的伤害
        int hurt = r.nextInt(20) + 1;
        // 获取被攻击者原来的血量
        int currentBlood = role.getBlood();
        // 计算被攻击者现在剩余的血量
        int remainBlood = currentBlood - hurt;
        // 当前血量低于造成的伤害时, 剩余血量将变为负数, 显然不可能, 此时将其赋值为 0
        remainBlood = remainBlood > 0 ? remainBlood : 0;
        // 将剩余血量赋值给被攻击的对象
        role.setBlood(remainBlood);
 
        // 打印受伤的描述
        // 血量>90 0 索引的描述 否则
        // 血量>80 1 索引的描述 否则
        // 血量>70 2 索引的描述 否则
        // 血量>60 3 索引的描述 否则
        // 血量>40 4 索引的描述 否则
        // 血量>20 5 索引的描述 否则
        // 血量>10 6 索引的描述 否则
        // 7 索引的描述
        if (remainBlood > 90) {
            System.out.printf(injureds_desc[0], role.getName());
            System.out.println();
        } else if (remainBlood > 80) {
            System.out.printf(injureds_desc[1], role.getName());
            System.out.println();
        } else if (remainBlood > 70) {
            System.out.printf(injureds_desc[2], role.getName());
            System.out.println();
        } else if (remainBlood > 60) {
            System.out.printf(injureds_desc[3], role.getName());
            System.out.println();
        } else if (remainBlood > 40) {
            System.out.printf(injureds_desc[4], role.getName());
            System.out.println();
        } else if (remainBlood > 20) {
            System.out.printf(injureds_desc[5], role.getName());
            System.out.println();
        } else if (remainBlood > 10) {
            System.out.printf(injureds_desc[6], role.getName());
            System.out.println();
        } else {
            System.out.printf(injureds_desc[7], role.getName());
            System.out.println();
        }
    }
 
    // 展示角色的信息
    public void showRoleInfo() {
        System.out.println("姓名为: " + getName());
        System.out.println("血量为: " + getBlood());
        System.out.println("性别为: " + getGender());
        System.out.println("长相为: " + getFace());
    }
}

测试类:

public class GameTest {
    public static void main(String[] args) {
        // 创建一个角色
        Role role1 = new Role(100, "乔峰", '男');
        // 创建另一个角色
        Role role2 = new Role(100, "鸠摩智", '男');
 
        role1.showRoleInfo();
        role2.showRoleInfo();
 
        // 开始格斗, 回合制游戏
        while (true) {
            // role1 先攻击 role2
            role1.attack(role2);
            // 判断 role2 剩余血量, 从而决定循环是否继续
            if (role2.getBlood() == 0) {
                System.out.println(role1.getName() + "K.O. 了" + role2.getName());
                break;
            }
 
            // 回合制游戏, 轮到 role2 攻击 role1 了
            // role2 攻击 role1
            role2.attack(role1);
            // 判断 role1 剩余血量, 从而决定循环是否继续
            if (role1.getBlood() == 0) {
                System.out.println(role2.getName() + " K.O. 了" + role1.getName());
                break;
            }
        }
    }
}

执行结果:

姓名为: 乔峰
血量为: 100
性别为: 男
长相为: 风流俊雅
姓名为: 鸠摩智
血量为: 100
性别为: 男
长相为: 五官端正
乔峰大喝一声，身形下伏，一招【劈雷坠地】，捶向鸠摩智双腿。结果鸠摩智退了半步，毫发无损
鸠摩智阴手翻起阳手跟进，一招【没遮拦】，结结实实的捶向乔峰。结果给乔峰造成一处瘀伤
乔峰大喝一声，身形下伏，一招【劈雷坠地】，捶向鸠摩智双腿。结果一击命中，鸠摩智痛得弯下腰
鸠摩智阴手翻起阳手跟进，一招【没遮拦】，结结实实的捶向乔峰。结果给乔峰造成一处瘀伤
乔峰上步抢身，招中套招，一招【劈挂连环】，连环攻向鸠摩智。结果鸠摩智痛苦地闷哼了一声，显然受了点内伤
鸠摩智上步抢身，招中套招，一招【劈挂连环】，连环攻向乔峰。结果乔峰痛苦地闷哼了一声，显然受了点内伤
乔峰运气于掌，一瞬间掌心变得血红，一式【掌心雷】，推向鸠摩智。结果鸠摩智摇摇晃晃，一跤摔倒在地
鸠摩智阴手翻起阳手跟进，一招【没遮拦】，结结实实的捶向乔峰。结果乔峰痛苦地闷哼了一声，显然受了点内伤
乔峰阴手翻起阳手跟进，一招【没遮拦】，结结实实的捶向鸠摩智。结果鸠摩智摇摇晃晃，一跤摔倒在地
鸠摩智上步抢身，招中套招，一招【劈挂连环】，连环攻向乔峰。结果乔峰摇摇晃晃，一跤摔倒在地
乔峰使出了一招【背心钉】，转到对方的身后，一掌向鸠摩智背心的灵台穴拍去。结果鸠摩智摇摇晃晃，一跤摔倒在地
鸠摩智上步抢身，招中套招，一招【劈挂连环】，连环攻向乔峰。结果乔峰摇摇晃晃，一跤摔倒在地
乔峰上步抢身，招中套招，一招【劈挂连环】，连环攻向鸠摩智。结果鸠摩智脸色一下变得惨白，连退了好几步
鸠摩智使出了一招【背心钉】，转到对方的身后，一掌向乔峰背心的灵台穴拍去。结果乔峰摇摇晃晃，一跤摔倒在地
乔峰上步抢身，招中套招，一招【劈挂连环】，连环攻向鸠摩智。结果鸠摩智脸色一下变得惨白，连退了好几步
鸠摩智使出了一招【背心钉】，转到对方的身后，一掌向乔峰背心的灵台穴拍去。结果乔峰脸色一下变得惨白，连退了好几步
乔峰大喝一声，身形下伏，一招【劈雷坠地】，捶向鸠摩智双腿。结果鸠摩智脸色一下变得惨白，连退了好几步
鸠摩智使出了一招【背心钉】，转到对方的身后，一掌向乔峰背心的灵台穴拍去。结果『轰』的一声，乔峰口中鲜血狂喷而出
乔峰使出了一招【背心钉】，转到对方的身后，一掌向鸠摩智背心的灵台穴拍去。结果『轰』的一声，鸠摩智口中鲜血狂喷而出
鸠摩智上步抢身，招中套招，一招【劈挂连环】，连环攻向乔峰。结果乔峰一声惨叫，像滩软泥般塌了下去
乔峰上步抢身，招中套招，一招【劈挂连环】，连环攻向鸠摩智。结果鸠摩智一声惨叫，像滩软泥般塌了下去
鸠摩智上步抢身，招中套招，一招【劈挂连环】，连环攻向乔峰。结果乔峰一声惨叫，像滩软泥般塌了下去
鸠摩智 K.O. 了乔峰

对象数组 1

要求:
定义数组存储 3 个商品对象.
商品的属性: 商品的 id, 名字, 价格, 库存.
创建三个商品对象, 并把商品对象存入到数组当中.

Javabean 类:

// 定义数组存储 3 个商品对象.
//         商品的属性: 商品的 id, 名字, 价格, 库存.
//         创建三个商品对象, 并把商品对象存入到数组当中.
 
public class Goods {
    private String id;
    private String name;
    private int price;
    private int left;
 
    public Goods() {
    }
 
    public Goods(String id, String name, int price, int left) {
        this.id = id;
        this.name = name;
        this.price = price;
        this.left = left;
    }
 
    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 getPrice() {
        return price;
    }
 
    public void setPrice(int price) {
        this.price = price;
    }
 
    public int getLeft() {
        return left;
    }
 
    public void setLeft(int left) {
        this.left = left;
    }
}

测试类:

public class GoodsTest {
    public static void main(String[] args) {
        // 创建一个数组
        Goods[] arr = new Goods[3];
 
        // 创建三个商品对象
        Goods g1 = new Goods("001", "华为P40", 5999, 100);
        Goods g2 = new Goods("002", "小米14", 2999, 200);
        Goods g3 = new Goods("003", "MacBook Pro", 28999, 60);
 
        // 把商品放到数组中
        arr[0] = g1;
        arr[1] = g2;
        arr[2] = g3;
 
        // 遍历数组
        for (int i = 0; i < arr.length; i++) {
            Goods goods = arr[i];
            System.out.println(goods.getId() + ", " + goods.getName() + ", " + goods.getPrice() + ", " + goods.getLeft());
        }
    }
}

执行结果:

001, 华为P40, 5999, 100
002, 小米14, 2999, 200
003, MacBook Pro, 28999, 60

对象数组 2

要求:
定义数组存储 3 部汽车对象.
汽车的属性: 品牌, 价格, 颜色.
创建三个汽车对象, 数据通过键盘录入而来, 并把数据存入到数组当中.

Javabean 类:

public class Car {
    private String brand; // 品牌
    private int price; // 价格
    private String color; // 颜色
 
    public Car() {
    }
 
    public Car(String brand, int price, String color) {
        this.brand = brand;
        this.price = price;
        this.color = color;
    }
 
    public String getBrand() {
        return brand;
    }
 
    public void setBrand(String brand) {
        this.brand = brand;
    }
 
    public int getPrice() {
        return price;
    }
 
    public void setPrice(int price) {
        this.price = price;
    }
 
    public String getColor() {
        return color;
    }
 
    public void setColor(String color) {
        this.color = color;
    }
}

测试类:

import java.util.Scanner;
 
public class CarTest {
    public static void main(String[] args) {
        // 创建一个数组, 长度为 3, 用来存储 3 部汽车
        Car[] arr = new Car[3];
 
        Scanner sc = new Scanner(System.in);
 
        // 从键盘录入 3 部车的信息, 然后存入数组中
        for (int i = 0; i < arr.length; i++) {
            Car car = new Car();  // 这一条语句需要放进 for 循环内部
            System.out.print("请输入第 " + (i + 1) + " 量汽车的品牌: ");
            car.setBrand(sc.next());
            System.out.print("请输入第 " + (i + 1) + " 量汽车的价格: ");
            car.setPrice(sc.nextInt());
            System.out.print("请输入第 " + (i + 1) + " 量汽车的颜色: ");
            car.setColor(sc.next());
            arr[i] = car;
        }
 
        // 打印数组
        for (int i = 0; i < arr.length; i++) {
            System.out.println("第 " + (i + 1) + " 辆车的品牌为: " + arr[i].getBrand() + ", 价格为: " + arr[i].getPrice() + ", 颜色为: " + arr[i].getColor());
        }
    }
}

执行结果:

请输入第 1 量汽车的品牌: 福特
请输入第 1 量汽车的价格: 2999999
请输入第 1 量汽车的颜色: 黑色
请输入第 2 量汽车的品牌: 通用
请输入第 2 量汽车的价格: 3999999
请输入第 2 量汽车的颜色: 白色
请输入第 3 量汽车的品牌: 特斯拉
请输入第 3 量汽车的价格: 4999999
请输入第 3 量汽车的颜色: 银色
第 1 辆车的品牌为: 福特, 价格为: 2999999, 颜色为: 黑色
第 2 辆车的品牌为: 通用, 价格为: 3999999, 颜色为: 白色
第 3 辆车的品牌为: 特斯拉, 价格为: 4999999, 颜色为: 银色

对象数组 3

要求:
定义数组存储 3 部手机对象.
手机的属性: 品牌, 价格, 颜色.
要求: 计算出三部手机的平均价格.

Javabean 类:

public class Phone {
    private String brand; // 品牌
    private int price; // 价格
    private String color; // 颜色
 
    public Phone() {
    }
 
    public Phone(String brand, int price, String color) {
        this.brand = brand;
        this.price = price;
        this.color = color;
    }
 
    public String getBrand() {
        return brand;
    }
 
    public void setBrand(String brand) {
        this.brand = brand;
    }
 
    public int getPrice() {
        return price;
    }
 
    public void setPrice(int price) {
        this.price = price;
    }
 
    public String getColor() {
        return color;
    }
 
    public void setColor(String color) {
        this.color = color;
    }
}

测试类:

public class PhoneTest {
    public static void main(String[] args) {
        // 创建一个数组, 包括 3 个对象, 用来存放手机
        Phone[] arr = new Phone[3];
 
        // 创建手机对象
        Phone p1 = new Phone("小米", 1999, "黑色");
        Phone p2 = new Phone("华为", 5999, "白色");
        Phone p3 = new Phone("荣耀", 4999, "蓝色");
 
        // 将手机对象放到数组中
        arr[0] = p1;
        arr[1] = p2;
        arr[2] = p3;
 
        // 求价格的总和
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            Phone phone = arr[i];
            sum = sum + phone.getPrice();
        }
 
        // 求价格的平均值
        int avg = sum / arr.length;
        System.out.println("三部手机的价格的平均值为: " + avg);
    }
}

执行结果:

三部手机的价格的平均值为: 4332

对象数组 4

要求:
定义数组存储 4 个女朋友的对象.
女朋友的属性: 姓名, 年龄, 性别, 爱好.
要求 1: 计算出四女朋友的平均年龄.
要求 2: 统计年龄比平均值低的女朋友有几个? 并把她们的所所有信息打印出来.

Javabean 类:

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 hobby) {
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.hobby = hobby;
    }
 
    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;
    }
}

测试类:

public class GirlFriendTest {
    public static void main(String[] args) {
        // 创建一个数组, 长度为 4, 存储女朋友对象
        GirlFriend[] girls = new GirlFriend[4];
 
        // 创建女朋友对象
        GirlFriend g1 = new GirlFriend("小张", 23, '女', "羽毛球");
        GirlFriend g2 = new GirlFriend("小杨", 22, '女', "跳舞");
        GirlFriend g3 = new GirlFriend("小李", 21, '女', "吃饭");
        GirlFriend g4 = new GirlFriend("小王", 20, '女', "睡觉");
 
        // 将女朋友对象添加到数组中
        girls[0] = g1;
        girls[1] = g2;
        girls[2] = g3;
        girls[3] = g4;
 
        // 求四个女朋友的年龄之和
        int sum = 0;
        for (int i = 0; i < girls.length; i++) {
            sum = sum + girls[i].getAge();
        }
 
        // 求四个女朋友的年龄的平均值
        int avg = sum / girls.length;
        System.out.println("四个女朋友的年龄的平均值为: " + avg);
 
        // 找到年龄低于平均值的女朋友对象, 打印出来, 并计算总共有多少个
        int count = 0;
        for (int i = 0; i < girls.length; i++) {
            if (girls[i].getAge() < avg) {
                ++count;
                System.out.println("姓名: " + girls[i].getName() + ", 年龄: " + girls[i].getAge() + ", 性别: " + girls[i].getGender() + ", 兴趣爱好: " + girls[i].getHobby());
            }
        }
        System.out.println("年龄低于平均年龄的有 " + count + " 个.");
    }
}

执行结果:

四个女朋友的年龄的平均值为: 21
姓名: 小王, 年龄: 20, 性别: 女, 兴趣爱好: 睡觉
年龄低于平均年龄的有 1 个.

对象数组 5

要求:
定义一个长度为 3 的数组, 数组存储 1~3 名学生对象作为初始数据, 学生对象的学号, 姓名各不相同.
学生的属性: 学号, 姓名, 年龄.
要求 1: 再次添加一个学生对象, 并在添加的时候进行学号的为唯一性判断.
要求 2: 添加完毕之后, 遍历所有学生信息.
要求 3: 通过 id 删除学生信息.
如果存在, 则删除, 如果不存在, 则提示删除失败.
要求 4: 删除完毕之后, 遍历所有学生信息.
要求 5: 查询数组 id 为 "2" 的学生, 如果存在, 则: 将他的年龄 +1 岁.

Javabean 类:

public class Student {
    private int id;
    private String name;
    private int age;
 
    public Student() {
    }
 
    public Student(int id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }
 
    public int getId() {
        return id;
    }
 
    public void setId(int 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 的测试类:

public class StudentTest {
    public static void main(String[] args) {
        // 创建一个长度为 3 的数组, 用来存储学生对象
        Student[] students = new Student[3];
 
        // 创建三个学生对象
        Student s1 = new Student(1, "xiaoming", 19);
        Student s2 = new Student(2, "xiaowang", 18);
        Student s3 = new Student(3, "xiaoli", 17);
 
        // 将学生对象添加到数组中
        students[0] = s1;
        students[1] = s2;
        students[2] = s3;
 
        // 要求 1: 再次添加一个学生对象,并在添加的时候进行学号的为唯一性判断
 
        // 创建一个新的学生对象
        Student s4 = new Student(4, "xiaozhang", 16);
        // 判断 id 是否重复,
        // 如果已经出现过了, 就不添加, 否则将该新学生对象添加到学生对象数组中
        // 如果学生对象数组已满, 则新建一个学生对象数组, 长度为现在的长度加 1
        // 如果学生对象数组不满, 则直接添加
        if (contains(students, s4.getId())) {
            System.out.println("当前 ID 重复, 请修改 ID 后再添加.");
        } else {
            int count = count(students);  // 当前元素个数
            // 数组已满
            if (count == students.length) {
                // 创建新的数组
                Student[] newStudents = creatNewStudents(students);
                // 将新建的对象添加到新数组的末尾
                newStudents[count] = s4;
                // 要求 2: 添加完毕之后, 遍历所有学生信息, 这里是遍历新数组
                extracted(newStudents);
            } else {  // 数组未满, 将新建的对象添加到老数组的现有元素的最后面
                students[count] = s4;
                // 要求 2: 添加完毕之后, 遍历所有学生信息, 这里是遍历老数组
                extracted(students);
            }
        }
    }
 
    // 判断一个 ID 是否已经出现
    public static boolean contains(Student[] students, int newId) {
        for (int i = 0; i < students.length; i++)
            if (students[i] != null && students[i].getId() == newId)  // 数组可能没有装满, 所以要首先进行非空判断
                return true;
        return false;
    }
 
    // 计算一个数组已经有了多少个对象
    public static int count(Student[] students) {
        // 就是判断这个数组中有多少个非 null
        int count = 0;
        for (int i = 0; i < students.length; i++)
            if (students[i] != null)
                ++count;
        return count;
    }
 
    // 复制一个数组到另一个新数组, 新数组长度是老数组长度加 1
    private static Student[] creatNewStudents(Student[] students) {
        // 建立新数组
        Student[] newStudents = new Student[students.length + 1];
        // 把老数组中的元素添加到新数组
        for (int i = 0; i < students.length; i++)
            newStudents[i] = students[i];
        // 返回新数组
        return newStudents;
    }
 
    // 遍历学生数组并打印内容
    private static void extracted(Student[] students) {
        for (int i = 0; i < students.length; i++) {
            if ((students[i] != null))
                System.out.println(students[i].getId() + ", " + students[i].getName() + ", " + students[i].getAge());
        }
    }
}

要求 3 和要求 4 的测试类:

import java.util.Scanner;
 
public class StudentTest {
    public static void main(String[] args) {
        // 创建一个长度为 3 的数组, 用来存储学生对象
        Student[] students = new Student[3];
 
        // 创建三个学生对象
        Student s1 = new Student(1, "xiaoming", 19);
        Student s2 = new Student(2, "xiaowang", 18);
        Student s3 = new Student(3, "xiaoli", 17);
 
        // 将学生对象添加到数组中
        students[0] = s1;
        students[1] = s2;
        students[2] = s3;
 
        print(students);
 
        // 要求 3: 通过 id 删除学生信息
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入学生 ID: ");
        int id = sc.nextInt();
        int index = getIndex(students, id);
        if (index == -1) {
            System.out.println("ID 输入错误");
        } else {
            // 根据索引删除数组元素, 可以直接让该元素变为 null
            students[index] = null;
        }
 
        print(students);
    }
 
    // 遍历数组并打印输出
    public static void print(Student[] students) {
        for (int i = 0; i < students.length; i++) {
            if (students[i] != null)
                System.out.println(students[i].getId() + ", " + students[i].getName() + ", " + students[i].getAge());
        }
    }
 
    // 根据 ID 找学生对象在数组中的索引, 如果不存在, 返回 -1
    public static int getIndex(Student[] students, int id) {
        for (int i = 0; i < students.length; i++)
            if (students[i] != null && students[i].getId() == id)
                return i;
        return -1;
    }
}

要求 5 的测试类:

public class StudentTest {
    public static void main(String[] args) {
        // 要求 5: 查询数组 id 为 "2" 的学生, 如果存在, 则将他的年龄 +1 岁
        // 创建数组, 存放学生对象
        Student[] students = new Student[3];
 
        // 创建三个学生对象
        Student s1 = new Student(1, "xiaoming", 19);
        Student s2 = new Student(2, "xiaowang", 18);
        Student s3 = new Student(3, "xiaoli", 17);
 
        // 将学生对象添加到数组中
        students[0] = s1;
        students[1] = s2;
        students[2] = s3;
 
        print(students);
 
        int index = getIndex(students, 2);
        if (index >= 0)
            students[index].setAge(students[index].getAge() + 1);
        else System.out.println("当前 ID 不存在, 修改失败.");
        print(students);
    }
 
    // 遍历数组并打印输出
    public static void print(Student[] students) {
        for (int i = 0; i < students.length; i++) {
            if (students[i] != null)
                System.out.println(students[i].getId() + ", " + students[i].getName() + ", " + students[i].getAge());
        }
    }
 
    // 根据 ID 找学生对象在数组中的索引, 如果不存在, 返回 -1
    public static int getIndex(Student[] students, int id) {
        for (int i = 0; i < students.length; i++)
            if (students[i] != null && students[i].getId() == id)
                return i;
        return -1;
    }
}
posted @   有空  阅读(11)  评论(0)  编辑  收藏  举报
相关博文：
·  学生管理系统
·  Objects
·  面向对象综合案例练习
·  08面向对象综合练习
·  第十节 面向对象综合训练
阅读排行：
· 10年+ .NET Coder 心语 ── 封装的思维：从隐藏、稳定开始理解其本质意义
· 地球OL攻略 —— 某应届生求职总结
· 周边上新：园子的第一款马克杯温暖上架
· Open-Sora 2.0 重磅开源！
· 提示词工程——AI应用必不可少的技术
点击右上角即可分享
微信分享提示
SQL AI 助手