《面向对象综合训练01~05》

《面向对象综合训练01~05》

训练01：文字版格斗游戏

• 第一步：创建游戏角色的javabean类

public class Role {
    private String name;
    private int blood;
    private char gender;
    private String face;//长相是随机的

    //创建男女长相的随机数组
    String[] boyfaces = {"风流俊雅", "气字轩昂", "相貌英俊", "五官端正", "相貌平平", "一塌糊涂", "面目狰狞"};
    String[] girlfaces = {"美奂绝伦", "沉鱼落雁", "婷婷玉立", "身材娇好", "相貌平平", "相貌简陋", "惨不忍睹"};
    //attack 攻击描述:
    String[] attacks_desc = {
            "%s使出了一招【背心钉】，转到对方的身后，一掌向%s背心的灵台穴拍去。",
            "%s使出了一招【游空探爪】，飞起身形自半空中变掌为抓锁向%s.",
            "%s大喝一声，身形下伏，一招【劈雷坠地】，捶向%s双腿。n",
            "%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 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 getFace() {
        return face;
    }

    public void setFace(char gender) {
        //在初始化过程中使用setFace随机设置长相
        Random r = new Random();
        if (gender == '男') {
            //如果人物性别是男，就从boyfaces随机一个长相
            int index = r.nextInt(boyfaces.length);
            this.face = boyfaces[index];
        } else if (gender == '女') {
            //如果人物性别是男，就从grilfaces随机一个长相
            int index = r.nextInt(girlfaces.length);
            this.face = girlfaces[index];
        } else {
            this.face = "面目狰狞";
        }
    }
    
    //输出所创建角色的所有属性
    public void getInfoRole() {
        System.out.println("姓名：" + getName());
        System.out.println("血量：" + getBlood());
        System.out.println("性别：" + getGender());
        System.out.println("长相：" + getFace());
    }
    
    //设计一个攻击方法
    public void attack(Role role) {
        //首先描述攻击招式
        Random r = new Random();
        int index = r.nextInt(attacks_desc.length);
        System.out.printf(attacks_desc[index], this.getName(), role.getName());
        System.out.println();

        //计算造成的伤害

        int hurt = r.nextInt(20) + 1;

        //计算被攻击者剩余血量
        int remainBlood = role.getBlood() - hurt;

        //对剩余血量做验证，如果已经为负数了，就修改为0
        remainBlood = remainBlood < 0 ? 0 : remainBlood;

        //修改被攻击者的剩余血量
        role.setBlood(remainBlood);

        //受伤情况描述
        if (remainBlood >= 90) {
            System.out.printf(injureds_desc[0], role.getName());
        } else if (remainBlood >= 80) {
            System.out.printf(injureds_desc[1], role.getName());
        } else if (remainBlood >= 70) {
            System.out.printf(injureds_desc[2], role.getName());
        } else if (remainBlood >= 60) {
            System.out.printf(injureds_desc[3], role.getName());
        } else if (remainBlood >= 40) {
            System.out.printf(injureds_desc[4], role.getName());
        } else if (remainBlood >= 20) {
            System.out.printf(injureds_desc[5], role.getName());
        } else if (remainBlood >= 10) {
            System.out.printf(injureds_desc[6], role.getName());
        } else {
            System.out.printf(injureds_desc[7], role.getName());
        }
        System.out.println();
    }
}

• 创建游戏测试类进行测试

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

        //2.使用while循环实现两个角色相互攻击
        while (true) {
            //r1先攻r2
            r1.attack(r2);
            //判断被攻击者的血量，如果为0跳出输出结果、跳出循环
            if (r2.getBlood() == 0) {
                System.out.println(r1.getName() + "K.O 了" + r2.getName());
                break;
            }
            //r2再共计r1
            r2.attack(r1);
            //判断被攻击者的血量，如果为0跳出输出结果、跳出循环
            if (r1.getBlood() == 0) {
                System.out.println(r2.getName() + "K.O 了" + r1.getName());
                break;
            }
        }
    }
}

训练02：两个对象数组练习

• 对象数组练习1
  • 定义数组存储3个商品对象，
  • 商品的属性:商品的id，名字，价格，库存。
  • 创建四个商品对象，并把商品对象存入到数组当中；

第一步：创建商品的javabean类

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

    @Override
    public String toString() {
        return "Goods{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", price=" + price +
                ", count=" + count +
                '}';
    }
}

第二步：定义数组，创建4个商品对象，并存入数组

public class GoodsTest {
    public static void main(String[] args) {
        //1.动态初始化创建数组
        Goods[] goods = new Goods[4];

        //2.创建3个商品对象
        Goods g1 = new Goods("001","华为P40",5999.0,100);
        Goods g2 = new Goods("001","保温杯",239.0,50);
        Goods g3 = new Goods("001","小米笔记本",6999.0,10);
        Goods g4 = new Goods("001","苹果13手机",7999.0,59);

        //3.把商品对象存入数组中
        goods[0] = g1;
        goods[1] = g2;
        goods[2] = g3;
        goods[3] = g4;

        //3.打印数组
        for (int i = 0; i < goods.length; i++) {
            Goods good = goods[i];
            System.out.println(good.toString());
        }
    }
}

• 对象数组练习2
  • 定义数组存储3部汽车对象；
  • 汽车的属性:品牌，价格，颜色；
  • 创建三个汽车对象，数据通过键盘录入而来，并把数据存入到数组当中；
• 第一步：创建汽车的javabean类

public class Cars {
    private String brand;
    private int price;
    private String color;

    public Cars() {
    }

    public Cars(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;
    }

    @Override
    public String toString() {
        return "Cars{" +
                "brand='" + brand + '\'' +
                ", price=" + price +
                ", color='" + color + '\'' +
                '}';
    }
}

• 第二步：创建3个汽车对象，使用键盘接收汽车属性，并把3个汽车对象存入数组中

public class CarsTest {

    public static void main(String[] args) {
        //1.创建一个汽车数组
        Cars[] cars = new Cars[3];
        //2.创建3个汽车对象，使用键盘接收汽车属性，并把3个汽车对象存入数组中
        Scanner scanner = new Scanner(System.in);
        for (int i = 0; i < cars.length; i++) {
            //创建汽车对象，通过键盘接收汽车属性数据
            Cars car = new Cars();//创建汽车对象一定要写在for循环的里面，因为为我们要创建3和不同的对象
            System.out.println("请输入汽车的品牌：");
            String brand = scanner.next();
            car.setBrand(brand);
            System.out.println("请输入汽车的价格：");
            int price = scanner.nextInt();
            car.setPrice(price);
            System.out.println("请输入汽车的颜色：");
            String color = scanner.next();
            car.setColor(color);
            //把创建的汽车对象存入数组中
            cars[i] = car;
        }
        //3.遍历数组
        for (int i = 0; i < cars.length; i++) {
            System.out.println(cars[i].toString());
        }
    }
}

• 以上练习中需掌握键盘输入的两套体系
• 第一套体系:
  • nextInt();接收整数
  • nextDouble();接收小数
  • next();接收字符串
  • 遇到空格，制表符，回车就停止接受。这些符号后面的数据就不会接受了
• 第二套体系:
  • nextLine();接收字符串
  • 可以接收空格，制表符，遇到回车才停止接受数据
• 以上练习中还需要注意
• Cars car = new Cars();创建汽车对象一定要写在for循环的里面，因为为我们要创建3和不同的对象；

训练03：两个对象数组练习-判断并统计

• 对象数组练习3
  • 定义数组存储3部手机对象
  • 手机的属性:品牌，价格，颜色。
  • 要求，计算出三部手机的平均价格
• 第一步：创建手机javabean类

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

    @Override
    public String toString() {
        return "Phone{" +
                "brand='" + brand + '\'' +
                ", price=" + price +
                ", color='" + color + '\'' +
                '}';
    }
}

• 第一步：定义数组存储3部手机对象，并计算出三部手机的平均价格

public class PhoneTest {
    public static void main(String[] args) {
        //1.创建一个大小为3的手机数组
        Phone[] phones = new Phone[3];
        //2.创建3个手机对象
        Phone p1 = new Phone("小米",3999,"黑色");
        Phone p2 = new Phone("华为",5999,"蓝色");
        Phone p3 = new Phone("苹果",7999,"白色");
        //3.把3个手机对象存入数组中
        phones[0] = p1;
        phones[1] = p2;
        phones[2] = p3;
        int sum = 0;
        for (int i = 0; i < phones.length; i++) {
            sum = sum + phones[i].getPrice();
        }
        int vag = sum / phones.length;
        System.out.println(vag);
    }
}

• 对象数组练习4
  • 定义数组存储4个女朋友的对象
  • 女朋友的属性:姓名、年龄、性别、爱好
  • 要求1:计算出四个女朋友的平均年龄
  • 要求2:统计年龄比平均值低的女朋友有几个?并把她们的所有信息打印出来
    第一步：创建女朋友的javabean类

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

    @Override
    public String toString() {
        return "GirlFriend{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", gender='" + gender + '\'' +
                ", hobby='" + hobby + '\'' +
                '}';
    }
}

第二步：创建GirlFriendTest类实现功能

public class GirlFriendTest {
    public static void main(String[] args) {
        //1.定义数 组存储4个女朋友对象
        GirlFriend[] girlFriends = new GirlFriend[4];
        //2.创建4个女朋对象
        GirlFriend gf1 = new GirlFriend("小诗诗",18,"萌妹子","吃零食");
        GirlFriend gf2 = new GirlFriend("小丹丹",19,"萌妹子","睡觉");
        GirlFriend gf3 = new GirlFriend("小慧慧",20,"萌妹子","看书");
        GirlFriend gf4 = new GirlFriend("小艳艳",21,"萌妹子","运动");
        //3.将4个对象添加到数组
        girlFriends[0] = gf1;
        girlFriends[1] = gf2;
        girlFriends[2] = gf3;
        girlFriends[3] = gf4;
        //4.计算4个女朋友的年龄之和
        int sum = 0;
        for (int i = 0; i < girlFriends.length; i++) {
            sum += girlFriends[i].getAge();
        }
        //5.求平均年龄
        int vag = sum / girlFriends.length;
        System.out.println(vag);
        //6.统计低于平均年龄的女朋友个数，并打印出来
        int count = 0;
        for (int i = 0; i < girlFriends.length; i++) {
            if (girlFriends[i].getAge() < vag){
                count++;
                System.out.println(girlFriends[i].toString());
            }
        }
        System.out.println(count);
    }
}

训练05/06：复杂对象数练习-添加、遍历、修改、删除

定义一个长度为3的数组，数组存储1~3名学生对象作为初始数据，
学生对象的学号，姓名各不相同学生的属性:学号，姓名，年龄。
要求1:再次添加一个学生对象，并在添加的时候进行学号的唯一性判断。
要求2:添加完毕之后，遍历所有学生信息。
要求3:通过id删除学生信息,如果存在，则删除，如果不存在，则提示删除失败。
要求4:删除完毕之后，遍历所有学生信息。
要求5:查询数组id为"2"的学生，如果存在，则将他的年龄+1岁。

• 代码示例：

public class StudentTest {
    /*
    定义一个长度为3的数组，数组存储1~3名学生对象作为初始数据，学生对象的学号，姓名各不相同学生的属性:学号，姓名，年龄。
    要求1:再次添加一个学生对象，并在添加的时候进行学号的唯一性判断。
    要求2:添加完毕之后，遍历所有学生信息。
    要求3:通过id删除学生信息,如果存在，则删除，如果不存在，则提示删除失败。
    要求4:删除完毕之后，遍历所有学生信息。
    要求5:查询数组id为"2"的学生，如果存在，则将他的年龄+1岁。
    */
    public static void main(String[] args) {
        //1.定义一个长度为3的数组
        Student[] students = new Student[3];
        //2.创建3个学生对象
        Student s1 = new Student(1, "张三", 23);
        Student s2 = new Student(2, "李四", 24);
        Student s3 = new Student(3, "王五", 24);
        //3.将3个学生对象存入数组中
        students[0] = s1;
        students[1] = s2;
        students[2] = s3;
        //4.创建一个新的学生对象
        Student s4 = new Student(5, "赵六", 26);
        //5.判断新创建学生对象学号的唯一性（设计一个方法判断新创建的学生对象的id，是否包含在老数组中）
        if (contains(students, s4.getId())) {
            //5.1已存在----提示id重复，添加失败
            System.out.println("学生id重复，添加失败");
        } else {
            //5.2不存在---添加新的学生对象
            //6.判断老数组是否已经存满数据（设计一个方法判断来老数组数据是否已经存满）
            int count = getCount(students);
            System.out.println(count);
            if (count == students.length) {
                //6.1数组已满，则对创建比原数组空间大1个的新数组，将新的学生对象存入其中；
                students = createArr(students);
                students[count] = s4;
                //打印数组
                printArr(students);
            } else {
                //6.2数组没有存满，直接将新学生对象存入其中
                students[count] = s4;
                //打印数组
                printArr(students);
            }
        }
        //要求3:通过id删除学生信息,如果存在，则删除，如果不存在，则提示删除失败。
        int index = getIndex(students, 5);
        if (index >= 0) {
            //如果存在，则删除
            students[index] = null;
            System.out.println("删除成功");
            //要求4:删除完毕之后，遍历所有学生信息。
            printArr(students);
        } else {
            //如果不存在，则提示学生id不存在，删除失败
            System.out.println("学生id不存在，删除失败");
        }
        //要求5:查询数组id为"2"的学生，如果存在，则将他的年龄+1岁。
        int index1 = getIndex(students, 2);
        if (index1 >= 0) {
            //id为2的学生存在,则将他的年龄+1岁
            Student stu = students[index1];
            int newAge = stu.getAge() + 1;
            stu.setAge(newAge);
            System.out.println("年龄+1岁成功");
            printArr(students);
        } else {
            //id为2的学生不存在
            System.out.println("学生信息不存在，修改失败");
        }
    }

    //设计一个方法获取待删除学生在数组中的位置
    /*
    1.我要个干嘛？ 答：通过id获取学生对象在数组中的数组下标
    2.我需要什么？ 答：需要数组，学生id
    3.方法的调用处是否需要继续使用方法的结果？ 答：需要，如果存在则返回学生对象的数组下标，如果不存在返回-1
     */
    public static int getIndex(Student[] arr, int id) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] != null) {
                if (arr[i].getId() == id) {
                    return i;
                }
            }
        }
        return -1;
    }

    //设计一个方法遍历数组元素
    public static void printArr(Student[] arr) {
        for (Student student : arr) {
            if (student != null) {
                System.out.println(student);
            }
        }
    }

    //设计一个方法，创建比原数组空间大1个的新数组
    /*
    1.我要个干嘛？ 答：创建一个新数组，比老数组空间大1，并复制老数组元素到新数组中
    2.我需要什么？ 答：需要老数组
    3.方法的调用处是否需要继续使用方法的结果？ 答：需要，需要返回新创建的数组
     */
    public static Student[] createArr(Student[] arr) {
        Student[] newStudents = new Student[arr.length + 1];
        for (int i = 0; i < arr.length; i++) {
            newStudents[i] = arr[i];
        }
        return newStudents;
    }

    //设计一个方法判断新创建的学生对象的id，是否包含在老数组中
        /*
        1.我要个干嘛？ 答：判断新创建的学生对象的id，是否包含在老数组中
        2.我需要什么？ 答：需要老数组，需要新创建学生对象的id
        3.方法的调用处是否需要继续使用方法的结果？ 答：需要判断的结果
         */
    public static boolean contains(Student[] arr, int id) {
        for (Student student : arr) {
            if (student != null) {
                if (student.getId() == id) {
                    return true;
                }
            }
        }
        return false;
    }

    //设计一个方法判断来老数组数据已经存了几个数据
    /*
    1.我要个干嘛？ 答：判断老数组数据已经存了几个数据
    2.我需要什么？ 答：需要来老数组
    3.方法的调用处是否需要继续使用方法的结果？ 答：需要返回已存入数据的数量
     */
    public static int getCount(Student[] arr) {
        //创建一个统计变量
        int count = 0;
        //判断数组中元素的值是否为null，如果不是null则说明存在一个数据，count加1
        for (Student student : arr) {
            if (student != null) {
                count++;
            }
        }
        //循环结束后返回数组中已添加元素的个数
        return count;
    }
}