目录
- 文字格斗游戏
- 数组练习一
- 数组练习二
- 数组练习三
- 数组练习四
- 数组练习五
文字格斗游戏
需求：每个游戏角色的姓名，血量都不相同，在选定人物的时候(new对象的时候)，这些信息就应该被确定下来
第一步：编写角色对象属性
// 1.定义人物姓名属性
private String name;
// 定义人物血量属性
private int boold;
// 定义人物性别属性
private char gender;
// 定义人物长相属性
private String face;
// 定义人物长相随机数组
String[] boyface = {"风韵犹存","风流俊雅","气宇轩昂","相貌英俊","相貌平平"};
String[] girface = {"美姿绝伦","沉鱼落雁","亭亭玉立","身材娇好","相貌平平"};
// 定义攻击描述
String[] attacks_desc = {
"%s使出了一招[背心顶]，转到对手的身后，一掌向%s背心的灵台穴拍去。",
"%s使出了一招[游空探爪]，飞起身形自半空中变掌为抓锁向%s。",
"%s大喝一声，身形下俯，一招[霹雷坠地]，锤向%s双腿。",
"%s运气于掌，一瞬间掌心变得血红，一式[掌心雷]，推向%s",
"%s上步抢身，招中套招，一招[霹挂连环]，连环攻向%s。",
};
// 定义受伤描述
String[] injureds_desc = {
"结果%s退了半步，毫发无伤。",
"结果给%s造成了一处瘀伤。",
"结果一击命中，%s痛的弯下腰。",
"结果%s痛苦的闷哼了一声，显然受了点内伤。",
"结果%s摇摇晃晃，一跤摔倒在地上。",
"结果%s脸色一下变得苍白，连退了好几步。",
"结果[轰]的一声，%s口中鲜血狂喷面出。",
"结果%s一声惨叫，像滩软泥般的塌了下去。",
};
第二步：构造带全部参数方法
// 1.2 创建带全部参数构造方法
public FightInfo(String name, int boold, char gender) {
this.name = name;
this.boold = boold;
this.gender = gender;
// 随机长相
setFace(gender);
}
第三步：编写人物长相的随机方法
// 1.3 编写face的set方法
public void setFace(char gender) {
// 1.4 随机长相
Random r = new Random();
if(gender == '男'){
// 从男长相数组里面随机获取索引
int index = r.nextInt(boyface.length);
// 将这个数组里面的随机索引赋值给this.face。
this.face = boyface[index];
}else if(gender == '女'){
// 从女长相数组里面随机获取索引
int index = r.nextInt(girface.length);
// 将这个数组里面的随机索引赋值给this.face。
this.face = girface[index];
}else{
this.face = "惨不忍睹";
}
}
第四步：定义攻击别人的方法
// 2.1 随机生成输出一个攻击方式
Random r = new Random();
// 定义index用于获取数组的随机索引
int index = r.nextInt(attacks_desc.length);
// 将数组的随机索引里面的值赋值给GongFu
String GongFu = attacks_desc[index];
System.out.printf(GongFu,this.getName(),fightInfo.getName());
System.out.println();
第五步：生成随机伤害
// 2.2 生成随机数计算造成的伤害 1-20随机
int hurt = r.nextInt(20) + 1;
第六步：定义变量用来存放被攻击后剩余的血量
// 2.3 定义变量remainBoold用来修改挨揍人的血量
int remainBoold = fightInfo.getBoold() - hurt;
第七步：对剩余血量做一个负数判断
// 2.4 对剩余血量做一个验证，如果为负数的时候就修改为0.
remainBoold = remainBoold < 0 ? 0 : remainBoold;
第八步：修改挨揍人和血量
// 2.5 修改一下挨揍的人和血量。
fightInfo.setBoold(remainBoold);
第九步：生成受伤描述
// 对剩余血量进行判断。
if(remainBoold > 90){
// 输出信息为：数组的索引对应的描述和挨揍的那个人
System.out.printf(injureds_desc[0],fightInfo.getName());
}else if(remainBoold >= 80 && remainBoold <= 90){
System.out.printf(injureds_desc[1],fightInfo.getName());
}else if(remainBoold >= 70 && remainBoold <= 80){
System.out.printf(injureds_desc[2],fightInfo.getName());
}else if(remainBoold >= 60 && remainBoold <= 70){
System.out.printf(injureds_desc[3],fightInfo.getName());
}else if(remainBoold >= 40 && remainBoold <= 60){
System.out.printf(injureds_desc[4],fightInfo.getName());
}else if(remainBoold >= 20 && remainBoold <= 40){
System.out.printf(injureds_desc[5],fightInfo.getName());
}else if(remainBoold >= 10 && remainBoold <= 20){
System.out.printf(injureds_desc[6],fightInfo.getName());
}else{
System.out.printf(injureds_desc[7],fightInfo.getName());
}
第十步：创建两个角色对象
// 3.创建第一个角色
FightInfo r1 = new FightInfo("后裔",100,'男');
// 创建第二个角色
FightInfo r2 = new FightInfo("艾琳",100,'女');
第十一步：循环开始格斗
// 4.1 开始格斗，回合制游戏用while来循环
while (true){
// r1开始攻击r2
r1.attack(r2);
System.out.println();
// 判断r2的剩余血量 如果为0就退出
if(r2.getBoold() == 0){
System.out.println(r1.getName() + "K.O了" + r2.getName());
break;
}
// r2开始攻击r1
r2.attack(r1);
System.out.println();
// 判断r2的剩余血量 如果为0就退出
if(r1.getBoold() == 0){
System.out.println(r2.getName() + " K.O了 " + r1.getName());
break;
}
}
我们来运行看一下效果吧：
数组练习一
需求：定义数组存储3个商品对象。 商品的属性：商品的id，名字，价格，库存。 创建三个商品对象，并把商品对象存入到数组当中。
第一步：定义商品属性和编写JavaBean
// 定义商品属性
private String id;
private String name;
private double price;
private int count;
第二步：创建商品对象数组
// 1. 创建一个商品数组
GoodsInfo[] arr = new GoodsInfo[3];
第三步：创建三个商品对象
GoodsInfo s1 = new GoodsInfo("1","华为p40",5999.9,100);
GoodsInfo s2 = new GoodsInfo("2","华为p50",6999.9,100);
GoodsInfo s3 = new GoodsInfo("3","华为p60",7999.9,100);
第四步：把商品对象添加进数组里
// 3.把商品添加到数组里面。
// 表示把第一个商品的对象放到0索引上。
arr[0] = s1;
// 表示把第二个商品的对象放到1索引上。
arr[1] = s2;
// 表示把第三个商品的对象放到2索引上。
arr[2] = s3;
第五步：遍历数组
for (int i = 0; i < arr.length; i++) {
GoodsInfo goods = arr[i];
System.out.println("商品id：" + goods.getId() + " 商品名称：" + goods.getName() + " 商品价格：" + goods.getPrice() + " 商品库存：" + goods.getCount());
}
我们来运行看一下吧：
完整代码： 测试类
public static void main(String[] args) {
// 1. 创建一个商品数组
GoodsInfo[] arr = new GoodsInfo[3];
// 2. 创建三个商品对象
GoodsInfo s1 = new GoodsInfo("1","华为p40",5999.9,100);
GoodsInfo s2 = new GoodsInfo("2","华为p50",6999.9,100);
GoodsInfo s3 = new GoodsInfo("3","华为p60",7999.9,100);
// 3.把商品添加到数组里面。
// 表示把第一个商品的对象放到0索引上。
arr[0] = s1;
// 表示把第二个商品的对象放到1索引上。
arr[1] = s2;
// 表示把第三个商品的对象放到2索引上。
arr[2] = s3;
for (int i = 0; i < arr.length; i++) {
GoodsInfo goods = arr[i];
System.out.println("商品id：" + goods.getId() + " 商品名称：" + goods.getName() + " 商品价格：" + goods.getPrice() + " 商品库存：" + goods.getCount());
}
}
数组练习二
需求：定义数组存储3部汽车对象。汽车的属性：品牌，价格，颜色。
创建三个汽车对象，数据通过键盘录入而来，并把数据存储到数组当中
第一步：定义汽车对象属性
private String brand; // 品牌
private double price; // 价格
private String color; // 颜色
第二步：创建汽车的数组
// 1. 创建数组用来存储3个汽车对象
CarInfo[] arr = new CarInfo[3];
第三步：键盘循环录入三个汽车信息
// 2.创建汽车对象，数据类源于键盘录入。
for (int i = 0; i < arr.length; i++) {
// 2.1 创建汽车的对象
CarInfo car = new CarInfo();
// 录入汽车品牌
System.out.println("请输入第" + (i + 1) +"个汽车的品牌：");
String brand = sc.next();
car.setBrand(brand);
// 录入汽车价格
System.out.println("请输入第" + (i + 1) +"个汽车的价格：");
double price = sc.nextDouble();
car.setPrice(price);
// 录入汽车颜色
System.out.println("请输入第" + (i + 1) +"个汽车的颜色：");
String color = sc.next();
car.setColor(color);
// 2.2 把汽车对象添加到数组当中。
arr[i] = car;
}
第四步：遍历数组
for (int i = 0; i < arr.length; i++) {
CarInfo car = arr[i];
System.out.println("汽车品牌：" + car.getBrand() + " 汽车价格：" + car.getPrice() + " 汽车颜色：" + car.getColor());
}
我们来运行看一下吧：
数组练习三
需求：定义数组存储3部手机对象，手机的属性：品牌，价格，颜色。
要求：计算出三部手机的平均价格
第一步：定义手机对象属性
private String brand; // 品牌
private double price; // 价格
private String color; // 颜色
第二步：创建手机对象的数组
// 1. 创建数组用来存储3个手机对象
PhoneInfo[] arr = new PhoneInfo[3];
第三步：通过键盘录入手机对象信息
// 2.创建手机对象，数据类源于键盘录入。
for (int i = 0; i < arr.length; i++) {
// 2.1 创建手机的对象
PhoneInfo Phone = new PhoneInfo();
// 录入手机品牌
System.out.println("请输入第" + (i + 1) +"个手机的品牌：");
String brand = sc.next();
Phone.setBrand(brand);
// 录入手机价格
System.out.println("请输入第" + (i + 1) +"个手机的价格：");
double price = sc.nextDouble();
Phone.setPrice(price);
// 录入手机颜色
System.out.println("请输入第" + (i + 1) +"个手机的颜色：");
String color = sc.next();
Phone.setColor(color);
// 2.2 把汽车对象添加到数组当中。
arr[i] = Phone;
}
第四步：求出手机的总价格
// 3.遍历数组先求出手机的价格总和
int sum = 0,avg = 0;
for (int i = 0; i < arr.length; i++) {
PhoneInfo Phone = arr[i];
// 总价格=数组中每个手机的价格
sum += Phone.getPrice();
System.out.println("手机品牌：" + Phone.getBrand() + " 手机价格：" + Phone.getPrice() + " 手机颜色：" + Phone.getColor());
}
第五步：求出平均价格
// 4.求平均值 平均价格=总价格除以数组的长度
avg = sum / arr.length;
System.out.println("手机总价：" + sum + "\n" + "手机平均：" + avg);
我们来运行看一下：
数组练习四
需求：定义数组存储4个女朋友的对象。并把他们的信息打印出来 女朋友属性：姓名，年龄，性别，爱好。
要求1：计算出四个女朋友的平均年龄。
要求2：统计年龄比平均值低的女朋友有几个？
第一步：定义女朋友对象属性
private String name; // 姓名
private int age; // 年龄
private char sex; // 性别
private String hobby;// 爱好
第二步：创建数组
GirlfriendInfo[] arr = new GirlfriendInfo[4];
第三步：创建女朋友对象
// 2.创建女朋友对象
GirlfriendInfo gir1 = new GirlfriendInfo("小诗诗", 19, '女', "玩游戏");
GirlfriendInfo gir2 = new GirlfriendInfo("小婷婷", 20, '女', "追剧");
GirlfriendInfo gir3 = new GirlfriendInfo("小慧慧", 21, '女', "逛街");
GirlfriendInfo gir4 = new GirlfriendInfo("小莉莉", 22, '女', "学习");
第四步：把对象装进数组里面
// 3.把女朋友对象存放进数组里面
arr[0] = gir1;
arr[1] = gir2;
arr[2] = gir3;
arr[3] = gir4;
第五步：循环求出年龄
// 4.求年龄总和
int sum = 0, avg = 0;
for (int i = 0; i < arr.length; i++) {
// 总和 = 遍历数组里面每一个对象通过get获取到年龄相加累和
sum += arr[i].getAge();
}
第六步：求出平均年龄
// 5.求平均年龄：平均年龄=年龄总和/数组里面的长度
avg = sum / arr.length;
第七步：统计比平均年龄小的有几个
// 6.统计年龄比平均年龄小的有几个
// 定义一个count变量用来统计比平均年龄低的个数
int count = 0;
for (int i = 0; i < arr.length; i++) {
// 通过数组下标.get方法获取到数组里面每一个对象的年龄进行判断。
if (arr[i].getAge() < avg) {
// 如果比平均年龄低的话count就+1
count++;
}
}
第八步：输出全部信息
// 7.输出全部信息
for (int i = 0; i < arr.length; i++) {
System.out.println("第" + (i + 1) + "个女朋友姓名：" + arr[i].getName() + " 年龄：" + arr[i].getAge() + " 性别：" + arr[i].getSex() + " 爱好：" + arr[i].getHobby());
}
System.out.println("平均年龄：" + avg + "\n" + "比平均年龄低的有" + count + "个");
我们来运行看一下吧：
数组练习五
-
需求：定义一个学生数组，里面存储1-3名学生对象作为初始数据，学生对象的学号不同，姓名各不相同
学生属性：学号，姓名，年龄。
要求1：再次添加一个学生，并在添加的时候进行学号的唯一性判断。
要求2：添加完毕后，遍历出所有学生的信息。
要求3：通过id删除学生信息（如果存在，就删除，如果不存在，则提示删除失败）
要求4：删除完毕后，遍历所有学生的信息。
要求5：查询数组id为：2的学生，如果存在，则将他的年龄+1岁。
第一步：定义学生对象属性
private int id; // 学生id
private String name; //学生姓名
private int age; // 学生年龄
第二步：创建学生数组
// 1. 定义学生数组 数组长度等于初始3个数据+需要添加学生的个数
StudentInfo[] arr = new StudentInfo[3];
第三步：添加3名学生作为初始值
// 1.1 添加3名学生为初始数据并添加到数组里面
arr[0] = new StudentInfo(1,"张三",17);
arr[1] = new StudentInfo(2,"李四",18);
arr[2]= new StudentInfo(3,"王五",19);
第四步：再次添加一个学生，并在添加的时候进行学号的唯一性判断。
-
分析：添加学生：唯一性判断：
1.1 学号已存在---不用添加。
1.2 学号不存在--- 就可以把学生对象直接添加进数组.
1.3 数组已经满了---只能创建一个新的数组，新的数组的长度 = 老数组 + 1；
1，4 数组没有满 --- 直接添加。
4.1：添加一名学生
StudentInfo stu = new StudentInfo(4,"赵六",20);
4.2：定义一个方法用来判断添加学生的id存不存在
// 依次获取到数组里面的每一个学生对象
for (int i = 0; i < arr.length; i++) {
StudentInfo stu = arr[i];
if(stu != null){
// 获取数组中学生对象的id
int sid = stu.getId();
// 遍历数组里面的每一位学生的id比较
if(sid == id){
// 如果存在就返回true
return true;
}
}
}
// 当循环结束后还没有找到就表示id不存在
return false;
4.3：判断学号是否存在
// 2.1 判断学号是否存在
boolean flag = Stuid(arr,stu.getId());
if(flag){
// 已经存在
System.out.println("当前id已经存在，请重新输入！");
}else{
// 不存在就判断当前数组长度满没满
}
4.4：定义一个方法用来判断当前学生数组中已经存了多少个
// 定义一个计数器用来统计数组有多少个元素
int count = 0;
for (int i = 0; i < arr.length; i++) {
if(arr[i] != null){
count++;
}
}
// 当循环结束count的个数就是数组当中一共有几个元素
return count;
4.5：判断数组中是否存满
// 不存在就判断当前数组长度满没满
// 2.2 判断数组中是否存满
int count = Stucount(arr);
if(count == arr.length){
// 已经存满
}else{
// 没有存满
arr[count] = stu;
}
4.6：如果数组满了就创建一个新的数组，长度=老数组的长度+1，然后把老数组的元素拷贝到新数组当中
// 创建新数组，长度=老数组的长度+1
StudentInfo[] newArr = new StudentInfo[arr.length + 1];
// 循环遍历得到老数组中的每一个元素
for (int i = 0; i < arr.length; i++) {
// 把老数组中的元素添加到新的数组中。
newArr[i] = arr[i];
}
// 把新数组返回
return newArr;
4.7：创建新元素并将老数组移到新数组
// 已经存满
// 2.3 调用创建新数组方法创建新数组
StudentInfo[] newArr = Stuarr(arr);
// 把新元素添加进去
newArr[count] = stu;
我们运行看一下：
到这里就把赵六给添加进来啦！
第五步：通过id删除学生信息
5.1：定义一个方法用来拿到id的索引
for (int i = 0; i < arr.length; i++) {
//依次得到每一个学生对象
StudentInfo stu = arr[i];
// 对Stu进行一个非空判断
if(stu != null){
int sid = stu.getId();
if(sid == id){
return i;
}
}
}
// 当循环结束之后，还没有找到就表示不存在
return -1;
5.2：判断id存不存在
int index = Stuindex(arr,3);
if(index >= 0){
// 如果存在，就删除
arr[index] = null;
// 要求4：删除完毕后，遍历所有学生的信息。
// 调用StuPrint方法遍历数组学生信息
StuPrint(arr);
}else{
// 如果不存在，就提示删除失败
System.out.println("当前id不存在,删除失败！");
}
到这里我们就成功把id为3的学生给删除掉啦。
第六步：删除完毕后，遍历所有学生的信息。
// 调用StuPrint方法遍历数组学生信息
StuPrint(arr);
第七步：查询数组id为：2的学生，如果存在，则将他的年龄+1岁。
7.1：调用Stuindex方法来拿到id索引
// 5.1 调用Stuindex方法来拿到id索引
int index1 = Stuindex(arr,2);
7.2：判断索引存不存在
if(index1 >= 0){
// 存在 将他的年龄加1
StudentInfo stu1 = arr[index1];
// 把原来的年龄拿出来
int newAge = stu1.getAge() + 1;
// 把加1之后的年龄塞回去
stu1.setAge(newAge);
// 遍历数组
StuPrint(arr);
}else{
// 不存在 则提示
System.out.println("当前id不存在，修改失败！");
}
到这里我们就全部编写完成啦，把id为2的学生年龄+1，我们来运行看一下：
完整代码：
package demo9;
public class Student {
public static void main(String[] args) {
// 数组练习五
/*需求：定义一个学生数组，里面存储1-3名学生对象作为初始数据，学生对象的学号不同，姓名各不相同
学生属性：学号，姓名，年龄。
要求1：再次添加一个学生，并在添加的时候进行学号的唯一性判断。
要求2：添加完毕后，遍历出所有学生的信息。
要求3：通过id删除学生信息（如果存在，就删除，如果不存在，则提示删除失败）
要求4：删除完毕后，遍历所有学生的信息。
要求5：查询数组id为：2的学生，如果存在，则将他的年龄+1岁。
*/
// 1. 定义学生数组 数组长度等于初始3个数据+需要添加学生的个数
StudentInfo[] arr = new StudentInfo[3];
// 1.1 添加3名学生为初始数据并添加到数组里面
arr[0] = new StudentInfo(1,"张三",17);
arr[1] = new StudentInfo(2,"李四",18);
arr[2]= new StudentInfo(3,"王五",19);
// 2. 要求1：再次添加一个学生，并在添加的时候进行学号的唯一性判断。
StudentInfo stu = new StudentInfo(4,"赵六",20);
// 2.1 判断学号是否存在
boolean flag = Stuid(arr,stu.getId());
if(flag){
// 已经存在
System.out.println("当前id已经存在，请重新输入！");
}else{
// 不存在就判断当前数组长度满没满
// 2.2 判断数组中是否存满
int count = Stucount(arr);
if(count == arr.length){
// 已经存满
// 2.3 调用创建新数组方法创建新数组
StudentInfo[] newArr = Stuarr(arr);
// 把新元素添加进去
newArr[count] = stu;
// 3. 要求2：添加完毕后，遍历出所有学生的信息。调用StuPrint方法遍历
// StuPrint(newArr);
}else{
// 没有存满
arr[count] = stu;
// 3. 要求2：添加完毕后，遍历出所有学生的信息。调用StuPrint方法遍历
// StuPrint(arr);
}
}
// 4. 要求3：通过id删除学生信息（如果存在，就删除，如果不存在，则提示删除失败）
// 要先找到id在数组中对应的索引，所以需要定义一个方法来拿到id的索引
// 4.2 判断id存不存在
int index = Stuindex(arr,3);
if(index >= 0){
// 如果存在，就删除
arr[index] = null;
// 要求4：删除完毕后，遍历所有学生的信息。
// 调用StuPrint方法遍历数组学生信息
// StuPrint(arr);
}else{
// 如果不存在，就提示删除失败
System.out.println("当前id不存在,删除失败！");
}
// 5. 要求5：查询数组id为：2的学生，如果存在，则将他的年龄+1岁。
// 5.1 调用Stuindex方法来拿到id索引
int index1 = Stuindex(arr,2);
// 5.2 判断索引
if(index1 >= 0){
// 存在 将他的年龄加1
StudentInfo stu1 = arr[index1];
// 把原来的年龄拿出来
int newAge = stu1.getAge() + 1;
// 把加1之后的年龄塞回去
stu1.setAge(newAge);
// 遍历数组
StuPrint(arr);
}else{
// 不存在 则提示
System.out.println("当前id不存在，修改失败！");
}
}
// 2.1 定义一个方法用来判断添加学生的id存不存在
public static boolean Stuid(StudentInfo[] arr,int id){
// 依次获取到数组里面的每一个学生对象
for (int i = 0; i < arr.length; i++) {
StudentInfo stu = arr[i];
if(stu != null){
// 获取数组中学生对象的id
int sid = stu.getId();
// 遍历数组里面的每一位学生的id比较
if(sid == id){
// 如果存在就返回true
return true;
}
}
}
// 当循环结束后还没有找到就表示id不存在
return false;
}
// 2.2 定义一个方法用来判断当前学生数组中已经存了多少个
public static int Stucount(StudentInfo[] arr){
// 定义一个计数器用来统计数组有多少个元素
int count = 0;
for (int i = 0; i < arr.length; i++) {
if(arr[i] != null){
count++;
}
}
// 当循环结束count的个数就是数组当中一共有几个元素
return count;
}
// 2.3 创建一个新的数组，长度=老数组的长度+1，然后把老数组的元素拷贝到新数组当中。
public static StudentInfo[] Stuarr(StudentInfo[] arr){
// 创建新数组，长度=老数组的长度+1
StudentInfo[] newArr = new StudentInfo[arr.length + 1];
// 循环遍历得到老数组中的每一个元素
for (int i = 0; i < arr.length; i++) {
// 把老数组中的元素添加到新的数组中。
newArr[i] = arr[i];
}
// 把新数组返回
return newArr;
}
// 3. 要求2：添加完毕后，遍历出所有学生的信息。
// 由于他在判断的时候如果存满了就添加进新数组，没有存放就添加进老数组。所有这边需要定义一个方法来遍历两个数组
public static void StuPrint(StudentInfo[] arr){
for (int i = 0; i < arr.length; i++) {
if(arr[i] != null){
System.out.println("学生id:" + arr[i].getId() + " 姓名:" + arr[i].getName() + " 年龄:" + arr[i].getAge());
}
}
}
// 4.1 定义一个方法用来拿到id的索引
public static int Stuindex(StudentInfo[] arr,int id){
for (int i = 0; i < arr.length; i++) {
//依次得到每一个学生对象
StudentInfo stu = arr[i];
// 对Stu进行一个非空判断
if(stu != null){
int sid = stu.getId();
if(sid == id){
return i;
}
}
}
// 当循环结束之后，还没有找到就表示不存在
return -1;
}
}
怎么样，是不是感觉有点难呢？没关系，经过你的多次练习，相信你能做到轻而易举就实现的。有什么不懂的可以在评论区评论哟！我们下期再见！
==最后非常感谢您的阅读，也希望能得到您的反馈 ==
