Day9-面向对象综合训练

AIains

已于 2023-10-18 16:56:04 修改

阅读量626

点赞数

分类专栏：黑马程序员Java基础学习笔记文章标签：学习 java

于 2022-09-21 16:32:40 首次发布

本文链接：https://blog.csdn.net/aiains/article/details/125773708

版权

黑马程序员Java基础学习笔记专栏收录该内容

17 篇文章 35 订阅

订阅专栏

1、文字版格斗游戏

版本1：格斗游戏，每个游戏角色的姓名，血量，都不相同，在选定人物的时候（new对象的时候），这些信息就应该被确定下来。

角色1：姓名乔峰，血量100

角色2：姓名鸠摩智，血量100

格斗过程：

乔峰打了鸠摩智一下，造成了xx点伤害，鸠摩智还剩下xx点血量

鸠摩智打了乔峰一下，造成了xx点伤害，乔峰还剩下xx点血量

乔峰打了鸠摩智一下，造成了xx点伤害，鸠摩智还剩下xx点血量

...............

乔峰KO了鸠摩智

package test001;

import java.util.Random;

public class RoleTest {
    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);
            //判断r2的剩余血量
            if(r2.getBlood() == 0){
                System.out.println(r1.getName()+"KO了"+r2.getName());
                break;
            }
            //r2开始攻击r1
            r2.attack(r1);
            //判断r1的剩余血量
            if(r1.getBlood() == 0){
                System.out.println(r2.getName()+"KO了"+r1.getName());
                break;
            }
        }

    }
}

class Role {
    private String name;
    private int boold;

    public Role() {
    }

    public Role(String name, int boold) {
        this.name = name;
        this.boold = boold;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getBlood() {
        return boold;
    }

    public void setBlood(int boold) {
        this.boold = boold;
    }


    /**定义一个方法用于攻击别人
     * 思考：谁攻击谁？
     * Role r1 = new Role();
     * Role r2 = new Role();
     * r1.攻击(r2);
     * 方法的调用者去攻击参数
     */
    public void attack(Role role){
        //计算造成的伤害1~20
        Random r = new Random();
        int hurt = r.nextInt(20)+1;

        //剩余血量
        int remainBoold = role.getBlood() - hurt;

        //对剩余血量进行判断，如果是负数则修改为0
        remainBoold = remainBoold<0 ? 0 : remainBoold;

        //修改一下挨揍人的血量
        role.setBlood(remainBoold);

        //this表示方法的调用者
        System.out.println(this.getName()+"打了一下"+role.getName()+"，造成了"+hurt+
                "点伤害"+role.getName()+"还剩下"+remainBoold+"点血量");
    }

}

版本2：

版本1：格斗游戏，每个游戏角色的姓名，血量，都不相同，在选定人物的时候（new对象的时候），这些信息就应该被确定下来。

角色1：姓名乔峰，血量100，性别男，长相为气宇轩昂

角色2：姓名鸠摩智，血量100，性别男，长相为气宇轩昂

格斗过程：

乔峰使出了一招【背心钉】，转到对方的身后，一掌向鸠摩智背心的灵台穴拍去。结果给鸠摩智造成了一处瘀伤。

鸠摩智使出了一招【游空探爪】，飞起身形自半空中变掌为抓锁向乔峰。结果乔峰退了半步，毫发无损。

...............

乔峰KO了鸠摩智

package test001;

import java.util.Random;

public class RoleTest {
    public static void main(String[] args) {
        //1、创建角色
        Role r1 = new Role("乔峰",100,'男');
        Role r2 = new Role("鸠摩智",100,'男');

        //2、展示一下角色信息
        r1.showRoleInfo();
        r2.showRoleInfo();

        //3、开始格斗，回合制游戏
        while(true){
            //r1开始攻击r2
            r1.attack(r2);
            //判断r2的剩余血量
            if(r2.getBlood() == 0){
                System.out.println(r1.getName()+"KO了"+r2.getName());
                break;
            }
            //r2开始攻击r1
            r2.attack(r1);
            //判断r1的剩余血量
            if(r1.getBlood() == 0){
                System.out.println(r2.getName()+"KO了"+r1.getName());
                break;
            }
        }

    }
}

class Role {
    private String name;    //名字固定值
    private int boold;      //血量固定值
    private char gender;    //性别固定值
    private String face;    //  长相是随机的

    //长相描述数组
    String[] boyface={"风流俊雅","气宇轩昂","相貌英俊","五官端正","相貌平平","一塌糊涂","面目狰狞"};
    String[] girlface={"美奂绝伦","沉鱼落雁","婷婷玉立","身材姣好","相貌平平","相貌简陋","惨不忍睹"};
    
    //attack攻击描述
    String[] attack_desc = {
            "%s使出了一招【背心钉】，转到对方的身后，一掌向%s背心的灵台穴拍去。",
            "%s使出了一招【游空探爪】，飞起身形自半空中变掌为抓锁向%s。",
            "%s大喝一声，身形下伏，一招【劈雷坠地】，捶向%s双腿。",
            "%s运气于掌，一瞬间掌心变得血红，一式【掌心雷】，推向%s。",
            "%s阴手翻起阳手跟进，一招【没遮拦】，结结实实的捶向%s。",
            "%s上步抢身，招中套招，一招【壁挂连环】，连环攻向%s。"
    };

    //injured 受伤描述
    String[] injureds_desc = {
            "结果%s退了半步，毫发无损",
            "结果给%s造成一处瘀伤",
            "结果一击命中，%s痛得弯下腰",
            "结果%s痛苦地闷哼了一声，显然受了点内伤",
            "结果%s摇摇晃晃，一跤摔倒在地",
            "结果%s脸色一下变得惨白，连退了好几步",
            "结果[轰]的一声，%s口中鲜血狂奔而出",
            "结果%s一声惨叫，像滩软泥般塌了下去",
    };

    //无参构造
    public Role() {
    }

    //全参构造
    public Role(String name, int boold,char gender) {
        this.name = name;
        this.boold = boold;
        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 == '男'){
            //从boyface里面随机长相
            int index = r.nextInt(boyface.length);//将随机抽到的长相值存储在index当中
            this.face = boyface[index];//将随机抽到的长相值赋值给成员变量
        } else if(gender == '女'){
            //从girlface里面随机长相
            int index = r.nextInt(girlface.length);
            this.face = girlface[index];
        } else{
            this.face = "面目狰狞";
        }

    }

    //名字
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    //血量
    public int getBlood() {
        return boold;
    }
    public void setBlood(int boold) {
        this.boold = boold;
    }

    //定义方法展示角色信息
    public void showRoleInfo(){
        System.out.println("姓名为："+getName());
        System.out.println("血量为："+getBlood());
        System.out.println("性别为："+getGender());
        System.out.println("长相为："+getFace());
    }

    /**定义一个方法用于攻击别人
     * 思考：谁攻击谁？
     * Role r1 = new Role();
     * Role r2 = new Role();
     * r1.攻击(r2);
     * 方法的调用者去攻击参数
     */
    public void attack(Role role){
        Random r = new Random();    //随机数
        int index = r.nextInt(attack_desc.length);//获取攻击方式，并保存到index当中
        String KungFu = attack_desc[index];//将攻击方式的值赋值给KungFu

        /**输出一个攻击效果
         * 输出KungFu的值，输出时与attack_desc数组有关，
         * attack_desc数组中含有两个占位符(%s)需要填充赋值
         * 根据情况，用this.getName()和role.getName()对%s进行填充赋值
         */
        System.out.printf(KungFu,this.getName(),role.getName());
        System.out.println();

        //计算造成的伤害1~20
        int hurt = r.nextInt(20)+1; //将随机得到的伤害值存储到hurt当中
        //剩余血量
        int remainBoold = role.getBlood() - hurt;   //获取角色剩余的血量
        //对剩余血量进行判断，如果是负数则修改为0
        remainBoold = remainBoold<0 ? 0 : remainBoold;  //三元选择结构
        //修改一下挨揍人的血量
        role.setBlood(remainBoold);     //利用setXxx()将求得的剩余血量赋值给挨揍人

        /**受伤的描述
         * 血量 > 90   0索引的描述
         * 80 ~ 90  1索引的描述
         * 70 ~ 80  2索引的描述
         * 60 ~ 70  3索引的描述
         * 40 ~ 60  4索引的描述
         * 20 ~ 40  5索引的描述
         * 10 ~ 20  6索引的描述
         * 血量 < 10  7索引的描述
         */
        if(remainBoold > 90){
            System.out.printf(injureds_desc[0],role.getName()); //用println会报错，用printf不会报错
        } else if(remainBoold > 80 & remainBoold < 90){
            System.out.printf(injureds_desc[1],role.getName());
        } else if(remainBoold > 70 & remainBoold < 80){
            System.out.printf(injureds_desc[2],role.getName());
        } else if(remainBoold > 60 & remainBoold < 70){
            System.out.printf(injureds_desc[3],role.getName());
        } else if(remainBoold > 40 & remainBoold < 60){
            System.out.printf(injureds_desc[4],role.getName());
        } else if(remainBoold > 20 & remainBoold < 40){
            System.out.printf(injureds_desc[5],role.getName());
        } else if(remainBoold > 10 & remainBoold < 20){
            System.out.printf(injureds_desc[6],role.getName());
        } else{
            System.out.printf(injureds_desc[7],role.getName());
        }
        System.out.println();

    }

}

项目难点分析：

1、属性中的颜值长相是随机的。我们在setXxx()里面随机，然后在构造里面直接调用就可以了
2、攻击attack方法，先把攻击的描述打印出来，描述完之后就要计算伤害，然后计算挨揍的人的剩余血量
   然后根据受伤情况、剩余血量进行不同的描述。

先把游戏过程想明白，逻辑先理顺然后再写代码。

2、两个对象数组练习

对象数组1：

定义数组存储3个商品对象。

商品的属性：商品的ID，名字，价格，库存。

创建三个商品对象，并把商品对象存入到数组当中。

package Goods;

public class GoodsTest {
    public static void main(String[] args) {
        //1、创建一个数组
        Goods[] arr = new Goods[3];

        //2、创建三个商品对象
        Goods g1 = new Goods("001","华为P40",5999.0,100);
        Goods g2 = new Goods("002","保温杯",288.0,10);
        Goods g3 = new Goods("003","枸杞",16.0,84);

        //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());
        }

    }
}

class Goods{
    String id;
    String name;
    double price;
    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 Goods;

import java.util.Scanner;

public class GoodsTest {
    public static void main(String[] args) {
        /**键盘录入
         * 1、第一套体系：
         * nextInt();   接收整数
         * nextDouble();    接收小数
         * next();  接收字符串
         * 遇到空格、制表符、回车，就停止接收。这些符号后面的数据就不会接收了。
         *
         * 第二套体系：
         * nextLine();  接收字符串
         */
        /*Scanner sc = new Scanner(System.in);
        System.out.println("请输入第一个整数：");
        int num1 = sc.nextInt();    //输入123 456
        System.out.println(num1);   //输出为123
        System.out.println("请输入第二个整数：");
        int num2 = sc.nextInt();    //不允许第二次输入
        System.out.println(num2);   //输出为456*/


        /*Scanner sc = new Scanner(System.in);
        System.out.println("请输入第一个字符串：");
        String str1 = sc.next();    //输入abc efg
        System.out.println(str1);   //输出为abc
        System.out.println("请输入第二个字符串：");
        String str2 = sc.next();
        System.out.println(str2);   //输出为efg*/

        /*Scanner sc = new Scanner(System.in);
        System.out.println("请输入第一个字符串：");
        String sstr1 = sc.nextLine();    //输入abcd efgh
        System.out.println(sstr1);   //输出为abcd efgh
        System.out.println("请输入第二个字符串：");
        String sstr2 = sc.nextLine();   //输入回车
        System.out.println(sstr2);   //输出为回车*/

        /**键盘录入注意事项：
         * 键盘录入两套体系不能混用
         * 弊端：先用nextInt,再用nextLine会导致下面的nextLine接收不到数据
         */
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入第一个字符串：");
        int num = sc.nextInt();    //输入123，然后回车
        System.out.println(num);   //输出为123
        System.out.println("请输入第二个字符串：");
        String line = sc.nextLine();   //不允许第二次输入
        System.out.println(line);   //输出为回车
    }
}

数组对象2：

定义数组存储3部汽车对象。

汽车属性：品牌，价格，颜色。

创建三个汽车对象，数据通过键盘录入而来，并把数据存入到数组当中。

package Car;

import java.util.Scanner;

public class CarTest {
    public static void main(String[] args) {
        //1、创建一个数组来存储3个汽车对象
        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 c = new Car();

            //录入品牌
            System.out.println("请输入第"+(i+1)+"辆汽车的品牌");
            String brand = sc.next();   //将键盘录入的品牌值放入到brand当中
            c.setBrand(brand);  //brand作为参数，调用setXxx()方法对成员变量brand进行赋值

            //录入价格
            System.out.println("请输入第"+(i+1)+"辆汽车的价格");
            int price = sc.nextInt();
            c.setPrice(price);

            //录入品牌
            System.out.println("请输入第"+(i+1)+"辆汽车的品颜色");
            String color = sc.next();
            c.setColor(color);

            //把汽车对象添加到数组当中
            arr[i] = c;
        }

        //遍历数组进行输出
        for (int i = 0; i < arr.length; i++) {
            Car car = arr[i];
            System.out.println(car.getBrand()+","+car.getPrice()+","+car.getColor());
        }
    }
}

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;
    }
}

3、对象数组练习-判断并统计

数组对象3：

定义数组存储3部手机对象。

手机的属性：品牌、价格、颜色。

要求：计算出三部手机的价格。

package Phone;

public class PhoneTest {
    public static void main(String[] args) {
        //1、创建一个数组
        Phone[] arr = new Phone[3];

        //2、创建手机对象
        Phone p1 = new Phone("华为",5999,"黑色");
        Phone p2 = new Phone("vivo",1388,"蓝色");
        Phone p3 = new Phone("oppen",3999,"白色");

        //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();
        }

        //5、求平均值
        //数据不能写死，尽量不写死
        int vag1 = sum / arr.length;
        System.out.println("平均价格(保留整数)为：" + vag1);
        double vag2 = sum*1.0 / arr.length;
        System.out.println("平均价格(保留小数)为：" + vag2);

    }
}
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;
    }
}

对象数组4：

定义数组存储4个女朋友的对象。

女朋友的属性：姓名、年龄、性别、爱好。

要求1：计算出四个女朋友的平均年龄。

要求2：统计年龄比平均值低的女朋友有几个？并把她们的所有信息都打印出来。

package girl;

public class GirlFriendTest{
    public static void main(String[] args) {

        //1、定义数组，存储女朋友对象
        GirlFriend[] arr = new GirlFriend[4];

        //2、创建对象并赋值
        GirlFriend gf1 = new GirlFriend("小红",18,"女","睡觉");
        GirlFriend gf2 = new GirlFriend("小丽",23,"女","吃零食");
        GirlFriend gf3 = new GirlFriend("小白",28,"女","玩游戏");
        GirlFriend gf4 = new GirlFriend("小苏",21,"女","学习");

        //3、将对象放入数组
        arr[0] = gf1;
        arr[1] = gf2;
        arr[2] = gf3;
        arr[3] = gf4;

        //4、求年龄的平均值
        int sum = 0;    //sum为年龄的累加，初始值为0
        for (int i = 0; i < arr.length; i++) {
            GirlFriend gf = arr[i];
            sum = sum + gf.getAge();
        }
        int vag = sum / arr.length;     //计算平均年龄
        System.out.println("平均年龄为："+ vag );

        //5、统计符合要求的女朋友的数目
        int count = 0;  //count为计数器，用于统计个数，初始值为0
        for (int i = 0; i < arr.length; i++) {
            GirlFriend gf = arr[i];
            if(vag > gf.getAge()){
                System.out.println(gf.getName()+","+gf.getAge()+","+
                        gf.getGender()+","+gf.getHobby());
                count++;
            }
        }
        System.out.println("小于平均年龄的女友个数有"+count+"个");
    }

}

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;
    }
}

4、复杂对象数组练习-添加和遍历

对象数组5：
定义一个长度为3的数组，数组存储1~3名学生对象作为初始数据，学生对象的学号，姓名各不相同。学生的属性：学号、姓名、年龄。

要求1：再次添加一个学生对象，并在添加的时候进行学号的唯一性判断。

要求2：添加完毕之后，遍历所有学生信息。

要求3：通过删除id删除学生信息。如果存在则删除，如果不存在则提示删除失败。

要求4：删除完毕之后，遍历所有学生信息。

要求5：查询数组id为heima002的学生，如果存在，则将他的年龄+1岁。

package Student;

public class studentTest {
    public static void main(String[] args) {
        //1、创建一个数组用来存储学生对象
        Student[] arr = new Student[3];
        //2、创建学生对象，并添加到数组当中
        Student stu1 = new Student(1,"张三",20);
        Student stu2 = new Student(2,"李四",25);
        Student stu3 = new Student(3,"王二",29);
        //3、把学生对象添加到数组当中
        arr[0] = stu1;
        arr[1] = stu2;
        arr[2] = stu3;


        /*//要求1：再次添加一个学生对象，并在添加的时候进行学号的唯一性判断。
        //4、创建添加的对象
        Student stu4 = new Student(4,"麻子",35);
        //5、唯一性判断
        //定义布尔变量，来保留判断id是否重复的结果，即用来判断id的唯一性
        boolean flag = contains(arr,stu4.getId());
        if(flag){
            //5.1、已经存在-----不用添加
            System.out.println("当前id重复，请修改id后再进行添加");
        } else {
            //5.2、不存在-----就可以把学生对象添加到数组当中
            int count = getCount(arr);  //查看数组是否已满
        // 6、添加元素
            if(count ==arr.length){
            //6.1、已经存满----只能创建一个新数组，新数组的长度=老数组+1
                Student[] newArr = creatNewArr(arr);
                //老数组[stu1,stu2,stu3]   此时count=3
                //新数组[stu1,stu2,stu3,stu4]      arr[3]的位置是stu4
                newArr[count] = stu4;
            //要求2：添加完毕之后，遍历所有学生信息。
                printArr(newArr);

            } else {
            //6.2、没有存满-------直接添加
                //[stu1,stu2,null]
                //例如：getCount获取到的是2，表示数组当中已经有了2个元素
                //还有一层意思：如果下一次要添加数据，就是添加到2索引的位置
                arr[count] = stu4;
                //要求2：添加完毕之后，遍历所有学生信息。
                printArr(arr);
            }
        }*/

        
        /*//要求3：通过删除id删除学生信息。
        //要找到id在数组中对应的索引
        int index = getIndex(arr,4);
        if(index >= 0){
            //如果存在则删除
            arr[index] = null;  //删除，即变为null值
        //要求4：删除完毕之后，遍历所有学生信息。
            printArr(arr);  //遍历数组
        } else {
            //如果不存在则提示删除失败。    此时index的值为-1
            System.out.println("当前id不存在，删除失败");
        }*/

        
        //要求5：查询数组id为2的学生，如果存在，则将他的年龄+1岁。
        //先找到id为2的学生对应的索引
        int index = getIndex(arr,2);    //index为索引值
        //判断索引
        if(index >= 0){
            //存在，则将他的年龄+1
            Student stu = arr[index];
                //把原来的年龄拿出来，    stu.getAge()用来获取原来的年龄
            int newAge = stu.getAge()+1;
            //把+1后的年龄塞回去
            stu.setAge(newAge);     //setAge()方法是对age赋值
            printArr(arr);
        } else{
            //不存在，则输出提示     此时index的值为-1
            System.out.println("当前id不存在，修改失败");
        }


        /**运行说明：
         * 要求1、2为一个class，要求3、4为一个class，要求5为一个class，
         */
    }




    //定义一个方法，用来输出打印数组，  没有返回值
    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());
            }
        }
    }


    //定义一个方法，用来创建一个新的数组，数组长度为老数组的长度+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;
    }


    //定义一个方法，用来判断数组中已经存在几个元素    返回值为统计的个数
    public static int getCount(Student[] arr){
        //定义一个计数器用来统计
        int count = 0;
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] != null){     //存在元素值的元素不为null
                count++;
            }
        }
        //当循环结束之后，返回统计出的个数
        return count;
    }


    //定义一个方法，用来将id与数组中的id作比较，用来判断id的唯一性     唯一时返回值为true，不唯一时返回值为false
    public static boolean contains(Student[] arr,int id){
        boolean flag = false;
        for (int i = 0; i < arr.length; i++) {
            //依次获取到数组里面的每一个学生对象
            Student stu = arr[i];
            if(stu != null){
                //获取数组中学生对象的id
                int sid = stu.getId();
                //比较
                if(sid == id){
                    return true;
                }
            }
        }
        //当循环结束后，还没有找到一样的，那么久表示数组中要查找的id不存在。
        return false;
    }


    //定义一个方法，用来寻找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){
                    return i;   //返回id对应的索引
                }
            }

        }
        //当循环结束之后还没找到，表示不存在
        return -1;
    }

}

/**设计方法的步骤：
 *1、我要干嘛？
 *2、我干这件事，需要什么才能完成？
 *3、调用处是否需要继续使用方法的结果？   使用则返回结果，不使用则不返回
 */

    //Javabean
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;
    }
}