面向对象综合训练
编程技巧
- 先理解需求逻辑
- 再开始书写代码
一、文字版格斗游戏
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 + "点血量~");
}
}- 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;
}
}
}
}- 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 04、丰富的实现
- 给角色加两个属性：性别、长相（随机的）
- 加四个个数组：
- 女性长相数组、男性长相数组、功夫招式数组、受伤描述数组
- 角色类
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();
}
}- 测试类
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;
}
}- 测试结果
---------------请选择我方英雄---------------
请输入角色姓名：
乔峰
请输入角色性别(男/女)：
那地方
您输入的性别有误！请重新输入~
请输入角色性别(男/女)：
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、对象数组练习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;
}
}测试类
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()); } } }
测试结果：
所有商品信息： 编号: 001, 商品名称: 宇智波鼬手办, 商品价格: 1000.0, 库存数量: 30 编号: 002, 商品名称: 华为nova7, 商品价格: 2350.5, 库存数量: 200 编号: 003, 商品名称: 机械键盘, 商品价格: 399.9, 库存数量: 3 Process finished with exit code 0
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;
}
}测试类
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部汽车的信息-------- 请您录入汽车的品牌： 劳斯莱斯 请您录入汽车的价格(万元)： 1900 请您录入汽车的颜色： 黑白 --------录入第2部汽车的信息-------- 请您录入汽车的品牌： 宝马 请您录入汽车的价格(万元)： 400 请您录入汽车的颜色： 蓝白 --------录入第3部汽车的信息-------- 请您录入汽车的品牌： 梅赛德斯 请您录入汽车的价格(万元)： 450.5 请您录入汽车的颜色： 七彩色 所有汽车信息如下： 汽车品牌：劳斯莱斯, 汽车价格：1900.0万元, 汽车颜色：黑白 汽车品牌：宝马, 汽车价格：400.0万元, 汽车颜色：蓝白 汽车品牌：梅赛德斯, 汽车价格：450.5万元, 汽车颜色：七彩色 Process finished with exit code 0
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;
}
}测试类
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部手机的信息--------- 请您输入手机的品牌： 华为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
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;
}
}测试类
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个女朋友的信息----- 请输入女朋友的姓名： 张靓颖 请输入女朋友的年龄： 19 请输入女朋友的性别： 男 您输入的性别有误~ 请重新输入！ 请输入女朋友的性别： 大家 您输入的性别有误~ 请重新输入！ 请输入女朋友的性别： 女 请输入女朋友的爱好： 唱歌、跳舞、服装 -----开始录入第2个女朋友的信息----- 请输入女朋友的姓名： 刘亦菲 请输入女朋友的年龄： 20 请输入女朋友的性别： 女 请输入女朋友的爱好： 打游戏、演戏、唱歌 -----开始录入第3个女朋友的信息----- 请输入女朋友的姓名： 杨幂 请输入女朋友的年龄： 28 请输入女朋友的性别： 女 请输入女朋友的爱好： 美食、旅游、逛街 -----开始录入第4个女朋友的信息----- 请输入女朋友的姓名： 田馥甄 请输入女朋友的年龄： 22 请输入女朋友的性别： 女 请输入女朋友的爱好： 爱唱小幸运 所有女朋友的信息如下： 姓名：张靓颖，年龄：19岁，性别：女，爱好：唱歌、跳舞、服装 姓名：刘亦菲，年龄：20岁，性别：女，爱好：打游戏、演戏、唱歌 姓名：杨幂，年龄：28岁，性别：女，爱好：美食、旅游、逛街 姓名：田馥甄，年龄：22岁，性别：女，爱好：爱唱小幸运 最高年龄：28岁 最低年龄：19岁 总年龄：89岁 所有女朋友的平均年龄为：21岁 低于平均年龄的女朋友信息如下： 姓名：张靓颖，年龄：19岁，性别：女，爱好：唱歌、跳舞、服装 姓名：刘亦菲，年龄：20岁，性别：女，爱好：打游戏、演戏、唱歌 低于平均年龄的女朋友有2个。 Process finished with exit code 0
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;
}
}测试类：
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、根据学号修改学生年龄(+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
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
