面向对象综合训练
文字版格斗游戏
最原始的写法:
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;
}
}