面向对象综合案例练习

练习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