面向对象综合案例练习
面向对象综合案例练习
练习1：文字版格斗游戏
格斗游戏:每个游戏角色的名字血量都不同,在选定人物的时候(new对象的时候),这些信息就应该被确定下来
建立两个类：角色类和测试类
package com.itheima.MethodAllTest01;
import java.util.Random;
public class Role {
private String name;
private int blood;
public Role() {
}
public Role(String name, int blood) {
this.name = name;
this.blood = blood;
}
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 void attack(Role role) {
//计算造成随机的伤害 1~20
Random r = new Random();
int hurt = r.nextInt(20) + 1;
//修改一下挨揍的人的血量
//剩余血量
int remainBlood = role.getBlood() - hurt;
//对剩余血量进行验证，如果是负数，就修改为0
remainBlood = remainBlood < 0 ? 0 : remainBlood;
role.setBlood(remainBlood);
//this表示方法的调用者
System.out.println(this.getName() + "正在攻击" + role.getName() + "造成了" + hurt + "伤害," + role.getName() + "还剩下" + remainBlood + "点血量");
}
}
package com.itheima.MethodAllTest01;
public class GameTest {
public static void main(String[] args) {
//1、创建第一个角色
Role r1 = new Role("乔峰",100);
//2、创建第二个角色
Role r2 = new Role("鸠摩智",100);
//3、开始格斗,回合制
while (true){
//r1开始攻击r2
r1.attack(r2);
if (r2.getBlood() == 0){
System.out.println(r1.getName()+"K.O了"+r2.getName());
break;
}
r2.attack(r1);
if (r1.getBlood() == 0){
System.out.println(r2.getName()+"K.O了"+r1.getName());
break;
}
}
}
}
运行结果：
乔峰正在攻击鸠摩智造成了16伤害,鸠摩智还剩下84点血量
鸠摩智正在攻击乔峰造成了12伤害,乔峰还剩下88点血量
乔峰正在攻击鸠摩智造成了7伤害,鸠摩智还剩下77点血量
鸠摩智正在攻击乔峰造成了7伤害,乔峰还剩下81点血量
乔峰正在攻击鸠摩智造成了2伤害,鸠摩智还剩下75点血量
鸠摩智正在攻击乔峰造成了7伤害,乔峰还剩下74点血量
乔峰正在攻击鸠摩智造成了10伤害,鸠摩智还剩下65点血量
鸠摩智正在攻击乔峰造成了15伤害,乔峰还剩下59点血量
乔峰正在攻击鸠摩智造成了10伤害,鸠摩智还剩下55点血量
鸠摩智正在攻击乔峰造成了14伤害,乔峰还剩下45点血量
乔峰正在攻击鸠摩智造成了11伤害,鸠摩智还剩下44点血量
鸠摩智正在攻击乔峰造成了16伤害,乔峰还剩下29点血量
乔峰正在攻击鸠摩智造成了5伤害,鸠摩智还剩下39点血量
鸠摩智正在攻击乔峰造成了18伤害,乔峰还剩下11点血量
乔峰正在攻击鸠摩智造成了8伤害,鸠摩智还剩下31点血量
鸠摩智正在攻击乔峰造成了20伤害,乔峰还剩下0点血量
鸠摩智K.O了乔峰
游戏完善：
完善前的小知识点：
souf+%s
souf不会自动换行，%s表示占位，有多少个百分逗号后面就要有多少个内容
package com.itheima.MethodAllTest01;
public class Test {
public static void main(String[] args) {
//两部分参数
//第一部分：要输出的内容%s（表示占位）
//第二部分：填充的数据
System.out.printf("你好啊%s","张三");
System.out.printf("你好啊%s，你好啊%s","张三","李四");
}
}
运行结果：
你好啊张三你好啊张三，你好啊李四
完善后的代码：
package com.itheima.MethodAllTest02;
//文字版格斗游戏
import java.util.Random;
public class Role {
private String name;
private int blood;
private char gender;
private String face;//长相随机
String[] boyFaces = {"风流俊雅", "气宇轩昂", "相貌英俊", "五官端正", "相貌平平", "一塌糊涂", "面目狰狞"};
String[] girlFaces = {"如花似玉", "沉鱼落雁", "亭亭玉立", "身材娇好", "相貌平平", "相貌简陋", "惨不忍睹"};
//attack 攻击描述
String[] attscks_desc = {
"%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(String name, int blood, char gender) {
this.name = name;
this.blood = blood;
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 == '男') {
int index = r.nextInt(boyFaces.length);
this.face = boyFaces[index];
} else if (gender == '女') {
int index = r.nextInt(girlFaces.length);
this.face = girlFaces[index];
} else {
this.face = "惨不忍睹";
}
}
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 void attack(Role role) {
Random r = new Random();
int index = r.nextInt(attscks_desc.length);
String KungFu = attscks_desc[index];
//输出一个攻击效果
System.out.printf(KungFu, this.getName(), role.getName());
System.out.println();
//计算造成的伤害 1~20
int hurt = r.nextInt(20) + 1;
//修改一下挨揍的人的血量
//剩余血量
int remainBlood = role.getBlood() - hurt;
//堆剩余血量进行验证，如果是负数，就修改为0
remainBlood = remainBlood < 0 ? 0 : remainBlood;
//修改一下挨揍的人的血量
role.setBlood(remainBlood);
//受伤的描述
//血量> 90 0索引的描述
//80 ~ 90 1索引的描述
//70 ~ 80 2索引的描述
//60 ~ 70 3索引的描述
//40 ~ 60 4索引的描述
//20 ~ 40 5索引的描述
//10 ~ 20 6索引的描述
//小于 7索引的描述
if (remainBlood > 90) {
System.out.printf(injureds_desc[0], role.getName());
} else if (remainBlood > 80 && remainBlood <= 90) {
System.out.printf(injureds_desc[1], role.getName());
}else if (remainBlood>70&&remainBlood<=80){
System.out.printf(injureds_desc[2], role.getName());
}else if (remainBlood>60&&remainBlood<=70){
System.out.printf(injureds_desc[3], role.getName());
}else if(remainBlood>40&&remainBlood<=60){
System.out.printf(injureds_desc[4], role.getName());
}else if (remainBlood>20&&remainBlood<=40){
System.out.printf(injureds_desc[5], role.getName());
}else if (remainBlood>10&&remainBlood<=20){
System.out.printf(injureds_desc[6], role.getName());
}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());
}
}
package com.itheima.MethodAllTest02;
public class GameTest {
public static void main(String[] args) {
//1、创建第一个角色
Role r1 = new Role("乔峰",100,'男');
//2、创建第二个角色
Role r2 = new Role("鸠摩智",100,'男');
//展示一下角色信息
r1.showRoleInfo();
r2.showRoleInfo();
//3、开始格斗,回合制
while (true){
//r1开始攻击r2
r1.attack(r2);
if (r2.getBlood() == 0){
System.out.println(r1.getName()+"K.O了"+r2.getName());
break;
}
r2.attack(r1);
if (r1.getBlood() == 0){
System.out.println(r2.getName()+"K.O了"+r1.getName());
break;
}
}
}
}
运行结果：
姓名：乔峰
血量：100
性别：男
长相：相貌英俊
姓名：鸠摩智
血量：100
性别：男
长相：相貌平平
乔峰上步抢身，招中套招，一招[劈挂连环]，连环攻向鸠摩智。
结果鸠摩智退了半步，毫发无损
鸠摩智阴手翻起阳手跟进，一招[没迹拦]，结结实实的捶向乔峰。
结果给乔峰造成一处瘀伤
乔峰上步抢身，招中套招，一招[劈挂连环]，连环攻向鸠摩智。
结果给鸠摩智造成一处瘀伤
鸠摩智使出了一招[背心钉]，转到对方的身后，一掌向乔峰背心的灵台穴拍去。
结果乔峰痛苦地闷哼了一声，显然受了点内伤
乔峰上步抢身，招中套招，一招[劈挂连环]，连环攻向鸠摩智。
结果一击命中，鸠摩智痛得弯下腰
鸠摩智阴手翻起阳手跟进，一招[没迹拦]，结结实实的捶向乔峰。
结果乔峰摇摇晃晃，一跤摔倒在地
乔峰上步抢身，招中套招，一招[劈挂连环]，连环攻向鸠摩智。
结果鸠摩智摇摇晃晃，一跤摔倒在地
鸠摩智上步抢身，招中套招，一招[劈挂连环]，连环攻向乔峰。
结果乔峰脸色一下变得惨白，连退了好几步
乔峰使出了一招[游空探爪]，飞起身形自半空中变掌为抓锁向鸠摩智。
结果鸠摩智摇摇晃晃，一跤摔倒在地
鸠摩智阴手翻起阳手跟进，一招[没迹拦]，结结实实的捶向乔峰。
结果乔峰脸色一下变得惨白，连退了好几步
乔峰上步抢身，招中套招，一招[劈挂连环]，连环攻向鸠摩智。
结果鸠摩智脸色一下变得惨白，连退了好几步
鸠摩智使出了一招[游空探爪]，飞起身形自半空中变掌为抓锁向乔峰。
结果乔峰脸色一下变得惨白，连退了好几步
乔峰使出了一招[游空探爪]，飞起身形自半空中变掌为抓锁向鸠摩智。
结果鸠摩智脸色一下变得惨白，连退了好几步
鸠摩智阴手翻起阳手跟进，一招[没迹拦]，结结实实的捶向乔峰。
结果乔峰一声惨叫，像滩软泥般塌了下去
乔峰阴手翻起阳手跟进，一招[没迹拦]，结结实实的捶向鸠摩智。
结果鸠摩智一声惨叫，像滩软泥般塌了下去
鸠摩智阴手翻起阳手跟进，一招[没迹拦]，结结实实的捶向乔峰。
结果乔峰一声惨叫，像滩软泥般塌了下去
鸠摩智K.O了乔峰
练习2：对象数组练习
需求：定义数组存储三个商品对象，商品的属性：商品的ID，名字，价格，库存
创建三个商品对象，并把商品对象存入到数组中
package com.itheima.MethodAllTest03;
/*
练习2：对象数组练习
需求：定义数组存储三个商品对象，商品的属性：商品的ID，名字，价格，库存
创建三个商品对象，并把商品对象存入到数组中
*/
public class Goods {
private String id;
private String name;
private double price;
private int count;
public Goods() {
}
public Goods(String id, String name, double price, int count) {
this.id = id;
this.name = name;
this.price = price;
this.count = count;
}
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 double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public int getCount() {
return count;
}
public void setCount(int count) {
this.count = count;
}
}
package com.itheima.MethodAllTest03;
public class GoodsTest {
public static void main(String[] args) {
//1、创建一个数组
Goods[] arr = new Goods[3];
//2、创建三个对象
Goods g1 = new Goods("001","小米13",4599.00,100);
Goods g2 = new Goods("002","保温杯",227.0,45);
Goods g3 = new Goods("003","枸杞",12.6,10);
//3、把商品添加到数组中
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.getCount());
}
}
}
运行结果：
001,小米13,4599.0,100
002,保温杯,227.0,45
003,枸杞,12.6,10
练习2改进：对象数组练习1
改进前的小知识点：
键盘录入说明：
第一套体系：
nextInt（）；接收整数
nextDouble（）；接收小数
next（）；接收字符串
第一套体系遇到空格或制表符会停止接收，空格和制表符后面数据就不会接收了，（如果有两个或多个变量）空格后面的数据会自动给下一个变量来接收（如果没有第二个变量，数据会释放自动消失）
package com.itheima.MethodAllTest06;
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个整数");
int num1 = sc.nextInt();
System.out.println("num1="+num1);
System.out.println("请输入第二个整数");
int num2 = sc.nextInt();
System.out.println("num2="+num2);
System.out.println("请输入第一个字符串");
String str1 = sc.next();
System.out.println("第一个字符串为："+str1);
System.out.println("请输入第二个字符串");
String str2 = sc.next();
System.out.println("第二个字符串为："+str2);
}
}
运行结果1：
请输入一个整数
123
num1=123
请输入第二个整数
789
num2=789
请输入第一个字符串
abc
第一个字符串为：abc
请输入第二个字符串
xyz
第二个字符串为：xyz
运行结果2：
请输入一个整数
请输入一个整数
456 123
num1=456
请输入第二个整数
num2=123
请输入第一个字符串
abc efg
第一个字符串为：abc
请输入第二个字符串
第二个字符串为：efg
系统把空格后面的数据自动给了下一个变量，由下一个变量来接收
第二套体系：
nextLine（）；接收字符串
可以接收空格，制表符，遇到回车才停止接收数据
package com.itheima.MethodAllTest06;
import java.util.Scanner;
public class Test2 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入第一个字符串");
String str1 = sc.nextLine();
System.out.println("第一个字符串"+str1);
System.out.println("请输入第二个字符串");
String str2 = sc.nextLine();
System.out.println("第二个字符串"+str2);
}
}
运行结果：
请输入第一个字符串
abc 你好啊，xyz
第一个字符串abc 你好啊，xyz
请输入第二个字符串
efg 123 你好！
第二个字符串efg 123 你好！
注意：第一套系统和第二套系统不能混用，面前建议使用第一套系统，建议学完类型转换后在考虑使用
弊端：先使用nextInt，再使用nextLine会导致下面的nextLine接收不到数据（输入nextInt的数据后会回车，而回车会被nextLine接收导致nextLine接收不到数据）
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个整数");
int num = sc.nextInt();
System.out.println(num);//123+回车
System.out.println("请输入一个字符串");
String str = sc.nextLine();
System.out.println(str);
运行结果1：
请输入一个整数
123
123
请输入一个字符串
运行结果2：
请输入一个整数
123 789
123
请输入一个字符串
789（输出空格包含空格后面的数据）
练习2改进要求：对象数组2
定义数组存储三部汽车对象
汽车的属性：品牌、价格、颜色
创建三个汽车对象数据，通过键盘录入而来，并把数据存入到数组中
eg：
package com.itheima.MethodAllTest04;
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;
}
}
package com.itheima.MethodAllTest04;
import java.util.Scanner;
public class CarTest {
public static void main(String[] args) {
//1、创建一个数组存储三个汽车对象
Car[] arr = new Car[3];
//2、创建汽车对象，数据来自于键盘录入
Scanner sc = new Scanner(System.in);
for (int i = 0; i < arr.length; i++) {
//创建一个汽车对象
Car c = new Car();//car一定要在for循环里面，在for循环外面只会创建一个对象，后面遍历对象元素会把前面的元素进行 覆盖
//录入品牌、价格和颜色
System.out.println("请输入汽车品牌：");
String brand = sc.next();
c.setBrand(brand);
System.out.println("请输入汽车价格：");
int price = sc.nextInt();
c.setPrice(price);
System.out.println("请输入汽车颜色：");
String color = sc.next();
c.setColor(color);
//把汽车对象添加到数组当中
arr[i] = c;
}
//3、遍历数组
for (int i = 0; i < arr.length; i++) {
Car car = arr[i];
System.out.println(car.getBrand()+","+car.getPrice()+","+car.getColor());
}
}
}
运行结果：
请输入汽车品牌：
宝马
请输入汽车价格：
1000000
请输入汽车颜色：
白色
请输入汽车品牌：
劳斯莱斯
请输入汽车价格：
20000000
请输入汽车颜色：
红色
请输入汽车品牌：
五菱宏光
请输入汽车价格：
60000
请输入汽车颜色：
银色
宝马,1000000,白色
劳斯莱斯,20000000,红色
五菱宏光,60000,银色
练习3：对象数组3
要求：
定义数组存储三部手机对象；手机的属性：品牌，价格、颜色
要求计算出三部手机的平均价格
package com.itheima.MethodAllTest05;
/*
要求：
定义数组存储三部手机对象；手机的属性：品牌，价格、颜色
要求计算出三部手机的平均价格
*/
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;
}
}
package com.itheima.MethodAllTest05;
public class PhoneTest {
public static void main(String[] args) {
//1、创建一个数组
Phone[] arr = new Phone[3];
//2、创建手机对象
Phone p1 = new Phone("苹果",8999,"远峰蓝");
Phone p2 = new Phone("小米",1999,"白色");
Phone p3 = new Phone("华为",6999,"黑色");
//3、把手机对象添加到数组当中
arr[0] = p1;
arr[1] = p2;
arr[2] = p3;
//4、获取三部手机的平均价格
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);
}
}
运行结果：
5999
练习3：对象数组4
定义数组存储4个女朋友的对象
女朋友的属性：姓名、年龄、性别、爱好
要求1：统计四女朋友的平均年龄
要求2：统计年龄比平均值低的女朋友有几个，并把他们所有的信息打印出来
package com.itheima.MethodAllTest06;
/*
女朋友的属性：姓名、年龄、性别、爱好
要求1：统计四女朋友的平均年龄
要求2：统计年龄比平均值低的女朋友有几个，并把他们所有的信息打印出来
*/
public class GirlFriend {
private String name;
private int age;
private String gender;
private String hobby;
public GirlFriend() {
}
public GirlFriend(String name, int age, String 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 String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public String getHobby() {
return hobby;
}
public void setHobby(String hobby) {
this.hobby = hobby;
}
}
package com.itheima.MethodAllTest06;
public class GirlFriendTest {
public static void main(String[] args) {
//1、定义数组存入女朋友的对象
GirlFriend[] arr = new GirlFriend[4];
//创建四个女朋友对象
GirlFriend gf1 = new GirlFriend("范冰冰",17,"女","健身");
GirlFriend gf2 = new GirlFriend("迪丽热巴",21,"女","运动");
GirlFriend gf3 = new GirlFriend("景甜",20,"女","拍戏");
GirlFriend gf4 = new GirlFriend("关晓彤",25,"女","赚钱");
//2、把对象添加到数组当中
arr[0] = gf1;
arr[1] = gf2;
arr[2] = gf3;
arr[3] = gf4;
//求和
int sum = 0;
for (int i = 0; i < arr.length; i++) {
GirlFriend gf = arr[i];
sum = sum + gf.getAge();
}
//5、求平均值
int avg = sum/arr.length;
//统计年龄比平均值低的有几个，打印他们的信息
int count = 0;
for (int i = 0; i < arr.length; i++) {
GirlFriend gf = arr[i];
if (gf.getAge()<avg){
count++;
System.out.println(gf.getName()+","+gf.getAge()+","+gf.getGender()+","+gf.getHobby());
}
}
System.out.println("比平均值低的有："+count+"个");
}
}
运行结果：
范冰冰,17,女,健身
比平均值低的有：1个
练习3：对象数组4
定义一个长度为3的数组，数组存储1到3名学生对象作为初始数据，学生对象的学号姓名各不相同
学生的属性：学号、姓名、年龄
要求1：添加一个学生对象，并在添加的时候进行学号的唯一性判断
要求2：添加完毕之后，遍历所有学生信息
要求3：通过id删除学生信息；如果存在则删除，如果不存在则提示删除失败
要求4：删除完毕之后，遍历所有学生信息
要求5：查询数组id为2的学生，如果存在，则将他的年龄加1岁。
package com.itheima.MethodAllTest07;
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;
}
}
package com.itheima.MethodAllTest07;
/*
定义一个长度为3的数组，数组存储1到3名学生对象作为初始数据，学生对象的学号姓名个不相同
学生的属性：学号、姓名、年龄
要求1：添加一个学生对象，并在添加的时候进行学号的唯一性判断
要求2：添加完毕之后，遍历所有学生信息
要求3：通过id删除学生信息；如果存在则删除，如果不存在则提示删除失败
要求4：删除完毕之后，遍历所有学生信息
要求5：查询数组id为“2”的学生，如果存在，则将他的年龄加1岁。
*/
public class Test {
public static void main(String[] args) {
Student[] arr = new Student[3];//1、创建一个数组用来存储学生对象
//2、创建学生对象并添加到数组当中
Student stu1 = new Student(1,"张三",18);
Student stu2 = new Student(2,"李四",36);
Student stu3 = new Student(3,"王五",23);
//3、把学生对象添加到数组当中
arr[0] = stu1;
arr[1] = stu2;
arr[2] = stu3;
//4、要求1：添加一个学生对象，并在添加的时候进行学号的唯一性判断（学号不能重复）
Student stu4 = new Student(004,"赵六",21);
boolean flag = contains(arr, stu4.getId());
if (flag){
//stu4已经存在数组当中不需要添加
System.out.println("当前id重复，亲修改id后再次添加");
}else {
//不存在，要把stu4存放到数组当中
int count = getCount(arr);//
if (count == arr.length){
//已经存储满了
//存满了就要创建一个新的数组来存储stu4，长度=老数组长度+1
//再把老数组的元素拷贝到新数组当中
Student[] newArr = creatNewArr(arr);
newArr[count] = stu4;//把stu4放进数组当中
// 要求2：添加完毕之后，遍历所有学生信息
printArr(newArr);
}else{
//没有存满
arr[count] = stu4;//count是3，此时数组的下标是3，刚好存入4个数据
printArr(arr);// 要求2：添加完毕之后，遍历所有学生信息
}
}
//要求3：通过id删除学生信息；如果存在则删除，如果不存在则提示删除失败
//需要先找到id在数组中的索引
int index = getIndex(arr,4);//给的id是4，和arr里面的id进行比较，因为不相等所以返回的是4（这里的4只是举一个例子范 围应该在0~3之间
if (index >=0){
//如果存在，则删除
arr[index] = null;
printArr(arr);//调用前面打印的方法，要求4：遍历数组
}else {
//如果不存在，则提示失败
System.out.println("当前id不存在，删除失败");
}
//要求4：删除完毕之后，遍历所有学生信息（在要求3里面）
//要求5：查询数组id为“2”的学生，如果存在，则将他的年龄加1岁
//先找到id为2的学生的索引
int index01 = getIndex(arr,2);
//判断索引
if (index01 >= 0){
//如果存在则将他的年龄加一岁
Student stu = arr[index01];
//把原来的年龄拿出来
int newAge = stu.getAge() + 1;
//把+1之后的年龄塞进去
stu.setAge(newAge);
//遍历数组
printArr(arr);
}else {
//如果不存在，则直接提示
System.out.println("当前id不存在，修改失败");
}
}
//已经存储满了
//存满了就要创建一个新的数组来存储stu4，长度=老数组长度+1
//再把老数组的元素拷贝到新数组当中
public static Student[] creatNewArr(Student[] arr){
Student[] newArr = new Student[arr.length+1];//创建一个新数组
//循环遍历，得到老数组中的每个元素
for (int i = 0; i < arr.length; i++) {
//把数组中的元素添加到新数组中当中
newArr[i] = arr[i];
}
return newArr;//把老数组返回
}
//要求1：定义一个方法判断数组中已经存储了几个元素
public static int getCount(Student[] arr){
//定义一个变量来统计
int count = 0;
for (int i = 0; i < arr.length; i++) {
if (arr[i] != null){
count++;
}
}
//当前循环结束之后就能够得出数组的那种有几个元素
//count最后的结果是3
return count;
}
//构造一个方法，在添加的时候进行学号的唯一性判断
public static boolean contains(Student[] arr ,int id){
for (int i = 0; i < arr.length; i++) {
Student stu = arr[i];//依次获取学生里面的对象
if (stu !=null) {//对数组里面的学生进行判断，如果学号满了，判断数组里面id是否有和stu4id相同
int sid = stu.getId();//获取数组中学生对象的stu4id
//进行比较
if (sid == id) {//对stu4id和数组梨的id进行比较
return true;
}
}
}
return false;//不相等=false
}
// 要求2：添加完毕之后，遍历所有学生信息
public static void printArr(Student[] arr){
for (int i = 0; i < arr.length; i++) {
Student stu = arr[i];
if(stu !=null){//如果数组里面的元素不是空则打印出来，如果是空则不需要做任何操作
System.out.println(stu.getId()+","+stu.getName()+","+stu.getAge());
}
}
}
//要求3前，需要先找到id在数组中的索引，所以构造一个方法
public static int getIndex(Student[] arr,int id){
for (int i = 0; i < arr.length; i++) {
//一次得到每一个学生对象
Student stu = arr[i];
//对stu进行一个非空判断
if (stu != null){
int sid = stu.getId();
if (sid == id){//判断所给的id是否和数组里面的sid相等
return i;//如果相等，则返回i
}
}
}
return -1;//当循环结束之后,还没有找到，就表示不存在
}
}
运行结果：
1,张三,18
2,李四,36
3,王五,23
4,赵六,21
当前id不存在，删除失败
1,张三,18
2,李四,37
3,王五,23
