Day10：面向对象练习

浩#

已于 2024-03-25 21:48:38 修改

阅读量9

点赞数

分类专栏： Java入门文章标签： java 开发语言

于 2022-12-08 12:59:48 首次发布

原文链接：https://www.bilibili.com/video/BV17F411T7Ao?p=94&vd_source=d65345bb4b8e99f3e8a164b57f703b27

版权

Java入门专栏收录该内容

13 篇文章 0 订阅

订阅专栏

一：文字格斗游戏

人物对象代码：

package com.it.test4;

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[] attacks_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 blood, char gender) {
        this.name = name;
        this.blood = blood;
        this.gender = gender;

        //初始化face
        Random r = new Random();

        //对不同的性别随即一张脸
        if (gender == '男'){
            //在男性外表中随机一张脸
            int faceIndex = r.nextInt(boyfaces.length);
            this.face = boyfaces[faceIndex];
        } else if (gender == '女') {
            //在女性外表中随机一张脸
            int faceIndex = r.nextInt(girlfaces.length);
            this.face = girlfaces[faceIndex];
        } else {
            this.face = "惨不忍睹";
        }
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return blood
     */
    public int getBlood() {
        return blood;
    }

    /**
     * 设置
     * @param blood
     */
    public void setBlood(int blood) {
        this.blood = blood;
    }

    /**
     * 获取
     * @return gender
     */
    public char getGender() {
        return gender;
    }

    /**
     * 设置
     * @param gender
     */
    public void setGender(char gender) {
        this.gender = gender;
    }

    /**
     * 获取
     * @return face
     */
    public String getFace() {
        return face;
    }

    //攻击方法  玩家1调用，攻击玩家2，传入玩家2的对象地址
    public void attack(Role role){

        Random r = new Random();

        //定义随机变量，对玩家1的攻击进行描述
        String KungFu = attacks_desc[r.nextInt(attacks_desc.length)];
        System.out.printf(KungFu,this.getName(),role.getName());
        System.out.println();

        //生成玩家1的攻击数值
        int attackNum = r.nextInt(20)+1;

        //计算玩家2的剩余血量，小于0，则清零
        int remainBlood = role.getBlood()-attackNum;

        remainBlood = remainBlood <= 0 ? 0 : remainBlood;

        //根据玩家2剩余血量输出受伤描述
        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 >50) {
            System.out.printf(injureds_desc[4],role.getName());
        }else if (remainBlood >40) {
            System.out.printf(injureds_desc[5],role.getName());
        }else if (remainBlood >20) {
            System.out.printf(injureds_desc[6],role.getName());
        }else if (remainBlood >10) {
            System.out.printf(injureds_desc[7],role.getName());
        }else if (remainBlood >=0) {
            System.out.printf(injureds_desc[1],role.getName());
        }
        System.out.println();

        //调整玩家2的剩余血量
        role.setBlood(remainBlood);


    }

}

测试代码：

package com.it.test4;

public class RoleTest {
    public static void main(String[] args) {
        Role r1 = new Role("浩",100,'男');
        System.out.println(r1.getFace());

        Role r2 = new Role("森",100,'女');
        System.out.println(r2.getFace());

        //开始回合制攻击
        while(true) {
            //r1先攻击
            r1.attack(r2);
            if (r2.getBlood() == 0) {
                System.out.println(r1.getName()+"K.0了"+r2.getName());
                break;
            }

            //r2再攻击
            r2.attack(r1);
            if (r1.getBlood() == 0) {
                System.out.println(r2.getName()+"K.0了"+r1.getName());
                break;
            }



        }
    }
}

ps：占位输出语句

System.out.printf("你好%s" , "世界") //这里输出的就是你好世界

%s是占位符，这里的占位就用后面的第一个字符串来填。前面用了几个占位就要填几个

二：对象数组练习

汽车对象的定义

package com.it.test5;

public class Car {
    //汽车的属性
    private String brand;
    private int price;
    private String clour;

    //汽车的无参数初始化
    public Car() {
    }

    //汽车的全参数初始化
    public Car(String brand, int price, String clour) {
        this.brand = brand;
        this.price = price;
        this.clour = clour;
    }

    //brand,price和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 getClour() {
        return clour;
    }

    public void setClour(String clour) {
        this.clour = clour;
    }
}

汽车对象录入数组

package com.it.test5;

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

            //输入品牌
            System.out.println("请输入第"+(i+1)+"台汽车的品牌");
            String brand = sc.next();
            c.setBrand(brand);

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

            //输入颜色
            System.out.println("请输入第"+(i+1)+"台汽车的颜色");
            String color = sc.next();
            c.setClour(color);

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

        //3.遍历汽车对象，输出品牌，价格和颜色
        for (int i = 0; i < arr.length; i++) {
            System.out.println("品牌："+arr[i].getBrand()+" 价格："+arr[i].getPrice()+" 颜色："+arr[i].getPrice());
        }
    }

}

ps：键盘录入的两套体系

第一套体系：nextInt () 接受整数

nextDouble () 接受小数

next() 接受字符串

注意：第一套体系接收到空格，制表符和回车就停止接受数据

第二套体系：nextLine () 接受字符串

注意：第二套体系可以接受空格和制表符，遇到回车才停止接受数据。

三：复杂对象数组练习

练习要求如下：

学生类代码：

package com.it.test6;

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.it.test6;

import java.util.Scanner;

public class StudentTest {
    public static void main(String[] args) {
        //1.创建学生数组
        Student [] arr = new Student[3];

        //2.创建三个学生对象并存储在数组中
        Student stu1 = new Student(1,"赵",18);
        Student stu2 = new Student(2,"钱",18);
        Student stu3 = new Student(3,"孙",18);

        arr[0] = stu1;
        arr[1] = stu2;
        arr[2] = stu3;

        //3，再次创建一个学生对象，并添加在初始数组中
        Student stu4 = new Student(4,"李",18);

        //判断新建对象学号是否重复
        boolean flag = contains(arr,stu4);


        if (flag){
            //学号重复则报错
            System.out.println("学号重复，重新输入");
        } else {
            //判断数组是否存满
            boolean flag0 = jugArr(arr);

            if (flag0) {
                //如果存满，则扩展
                Student [] arrNew = extendArr(arr);

                //扩展后存放新学生
                arrNew[arrNew.length-1] = stu4;
                arr = arrNew;
            } else {
                //没有存满则直接存
                arr[arr.length-1] = stu4;
            }
        }


        //4.存完之后，遍历所有学生
        for (int i = 0; i < arr.length; i++) {
            Student stu = arr[i];
            System.out.println(stu.getId()+" "+stu.getName()+" "+stu.getAge());
        }

        //5.通过id删除学生

        //获得输入id的索引
        Scanner sc =new Scanner(System.in);
        System.out.println("输入一个id");
        int idIn = sc.nextInt();

        int index = getIndex(arr,idIn);

        //通过id删除学生信息
        if (index >= 0){
            arr[index] = null;
            System.out.println("删除成功");
        } else {
            System.out.println("删除失败");
        }

        //遍历所有学生信息
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] != null){
                Student stu = arr[i];
                System.out.println(stu.getId()+" "+stu.getName()+" "+stu.getAge());
            } else{
                System.out.println((i+1)+"已经被删了");
            }

        }
    }

    //函数1：判断学生id是否存在
    public static boolean contains(Student [] arr,Student stu){

        //判断学生id是否已经存在
        for (int i = 0; i < arr.length; i++) {
            Student stu0 = arr[i];
            if (stu0.getId() == stu.getId()){
                return true;
            }
        }

        //如果不存在则返回flase
        return false;
    }

    //函数2：判断数组是否已满
    public static boolean jugArr(Student [] arr){
        //定义判断指针
        int count=0;

        for (int i = 0; i < arr.length; i++) {
            if (arr[i] != null){
                count++;
            }
        }

        //count等于数组长度，则数组已满
        if (count ==arr.length){
            return true;
        } else {
            return false;
        }
    }

    //函数3：数组扩展
    public static Student[] extendArr(Student [] arr) {
        //定义扩展后数组，长度+1
        Student [] arr0 = new Student[arr.length+1];

        for (int i = 0; i < arr0.length-1; i++) {
            arr0[i] = arr[i];
        }
        return arr0;
    }

    //函数4：获得学生索引
    public static int getIndex(Student [] arr, int id){
        for (int i = 0; i < arr.length; i++) {
            Student stu = arr[i];
            if (stu.getId() == id ){
                return i;
            }
        }

        return -1;
    }
}