【黑马程序员java笔记】面向对象综合训练

于 2024-09-06 10:06:21 发布
阅读量485 收藏 8
点赞数 3
分类专栏： Java学习 文章标签： java 笔记 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_48165967/article/details/141933528
版权

文字版格斗游戏

题目

  1. 角色类：
    变量： 姓名：一维数组
    性别：一维数组
    外貌：二维数组
    攻击方式：一维数组
    血量：一维数组
    构造： 将上述变量合成一个角色
    方法： 设置角色的各种信息
    展示角色的信息
    攻击和受伤
  2. 测试类：
    变量：角色
    方法： 展示角色信息
    进行回合制攻击
    代码：
    角色类的代码：
package com.oop.demo04;
import java.util.Random;

/**
 * @author soso
 * @PackageName:com.oop.demo04
 * @ClassName:Role
 * @Description:根据性别随机给予外貌和攻击方式
 * @date 2024/9/516:24
 */
public class Role {
    //	变量： 姓名：一维数组
    //				性别：一维数组
    //				外貌：二维数组
    //				攻击方式：一维数组
    //				血量：一维数组
    private String name;
    private int blood;
    private char gender;
    private String appearance;

    String[][] appearances = {{"武力值高","长得漂亮","反应迅速"},{"高大强壮","灵活应变","聪明机智"}};
    //攻击和受伤描述
    String[] attackWays = {
        "%s利用回旋踢，踢向%s的头顶",
        "%s利用滑铲，将%s铲翻",
        "%s利用毒针，刺向%s的胸口"
    };
    String[] hurtWays = {
      "结果%s躲过，毫发无伤",
      "结果%s受重伤",
      "%s倒地不起"
    };

    //	构造： 将上述变量合成一个角色
    public Role(String name,int blood,char gender) {
        this.name = name;
        this.blood = blood;
        this.gender = gender;
        setAppearance(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 getAppearance() {
        return appearance;
    }

    public void setAppearance(char gender) {
        Random rand = new Random();
        if (gender == 'm') {
            int r = rand.nextInt(appearances.length);
            this.appearance = appearances[1][r];
        }else if (gender == 'f') {
            int r = rand.nextInt(appearances.length);
            this.appearance = appearances[0][r];
        }else{
            //默认长相
            this.appearance = appearances[0][0];
        }
    }

    //				展示角色的信息
    public void showRoleInfo(){
        System.out.println("Name: " + getName());
        System.out.println("Blood: " + getBlood());
        System.out.println("Gender: " + getGender());
        System.out.println("Appearance: " + getAppearance());
    }
    //				攻击和受伤
    public void attack(Role role){
        Random rand = new Random();
        int index = rand.nextInt(attackWays.length);
        String realAttack = attackWays[index];

        //输出攻击效果
        System.out.printf(realAttack,this.getName(),role.getName());
        System.out.println();

        //计算收到的伤害
        int hurt = rand.nextInt(30)+1;

        //剩余血量
        int remainBoold =role.getBlood()-hurt;
        //对剩余血量进行判断，为负则改为零
        remainBoold =remainBoold < 0 ? 0 : remainBoold;
        //修改剩余血量
        role.setBlood(remainBoold);

        //受伤描述
        if (remainBoold > 90){
            System.out.printf(hurtWays[0],role.getName());
        }else if (remainBoold > 60){
            System.out.printf(hurtWays[1],role.getName());
        }else{
            System.out.printf(hurtWays[2],role.getName());
        }
        System.out.println();
    }


}

测试类的代码：

package com.oop.demo04;

/**
 * @author soso
 * @PackageName:com.oop.demo04
 * @ClassName:GameTest
 * @Description:两个角色进行格斗
 * @date 2024/9/516:24
 */
public class GameTest {
    public static void main(String[] args) {
        //	变量：角色
        Role r1 = new Role("大乔",100,'f');
        Role r2 = new Role("悟空",100,'m');

        //	方法： 展示角色信息
        r1.showRoleInfo();
        r2.showRoleInfo();
        //				进行攻击
        int i = 0;
        while(true) {
            //r1攻击r2
            r1.attack(r2);
            i++;
            //判断r2的剩余血量
            if(r2.getBlood() == 0){
                System.out.println(r1.getName()+ "K.O.了" +r2.getName());
                break;
            }else{
                System.out.println(r2.getName()+"第"+i+"血");
            }
            //r2攻击r1
            r2.attack(r1);
            //判断r1的剩余血量
            if(r1.getBlood() == 0){
                System.out.println(r2.getName()+ "K.O.了" +r1.getName());
                break;
            }else{
                System.out.println(r1.getName()+"第"+i+"血");
            }
        }
    }
}

结果图：
回合攻击

外貌描述
重点：理清楚每一类中需要有什么变量、构造和方法；
问题：
如何构造实现测试类中通过输入来选择角色？
如何将攻击方式扣除的血量固定？

两个对象数组

数组的添加、遍历、删除和修改
题目

  1. 学生类：
    变量：学号，姓名，年龄。
    构造：获得学号，姓名和年龄
    方法：展示学生信息
  2. 测试类：
    变量：定义一个数组用于存储学生
    方法：
    1. 定义一个数组，用于存储初始学生
    2. 添加一个学生对象，可以从键盘读入
    3. 进行学号唯一性判断
    3.1 判断学生对象的学号是否包含于已经存在的数组中
    3.2 如果存在，则提示重复不加入数组。否则，加入数组
    3.2.1 利用数组中是否存在null值判断数组是否存储满
    3.2.2 如果存储满了，则定义一个新的数组，长度为原数组长度加一，将新的学生对象存储
    3.2.3 否则，直接加入原数组
    3.2.4 导出添加好学生对象的数组
    4. 遍历学生信息，注意判断数组中是否存在空值，存在则不打印
    5. 键盘读入要删除的学生id
    5.1 判断是否存在（可用3.1的方法）
    5.2 不存在则提示该学生不存在
    5.3 存在则删除
    5.3.1 获得该id在数组中的索引，利用方法导出索引
    5.3.2 定义一个新的数组为原数组长度减一
    5.3.3 该索引前原数组赋值给新数组，该索引后原数组全部往前移一个给新数组
    5.3.4 导出删除后的数组
    6. 再次遍历数组学生信息
    7. 判断id为“A02”的学生是否存在，存在则利用setAge将其年龄加一岁，否则打印不存在该学生
    学生类：
package com.oop.demo06;

/**
 * @author soso
 * @PackageName:com.oop.demo06
 * @ClassName:student
 * @Description:定义学生对象
 * @date 2024/9/521:26
 */
public class Student {
    private String id;
    private String name;
    private int age;

    //构造
    public Student() {

    }
    public Student(String id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

    //方法
    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 int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    //方法
    public void display() {
        System.out.println("ID: " + getId() + " Name: " + getName() + " Age: " + getAge());
    }
}

测试类：

package com.oop.demo06;
import java.util.Scanner;

/**
 * @author soso
 * @PackageName:com.oop.demo06
 * @ClassName:studentTest
 * @Description:对学生数组进行添加、遍历、修改和删除
 * @date 2024/9/521:27
 */
public class StudentTest {
    public static void main(String[] args) {
        //1. 定义一个数组，用于存储初始学生
        Student[] students = new Student[3];
        Student s1 = new Student("A01","Mary",18);
        Student s2 = new Student("A02","Jane",18);
        Student s3 = new Student("A03","Frede",18);

        students[0] = s1;
        students[1] = s2;
        students[2] = s3;

        //		2. 添加一个学生对象，可以从键盘读入
        Student s4 = new Student("A04","soso",18);
        //		3. 进行学号唯一性判断并添加，只能一个一个添加，尚未实现批量添加
        students = insertStudents(students,s4);

        //		4. 遍历学生信息，注意判断数组中是否存在空值，存在则不打印
        for (int i = 0; i < students.length; i++) {
            students[i].display();
        }
        //		5. 键盘读入要删除的学生id
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter student ID: ");
        String deleteId = sc.nextLine();
        students = deleteStudents(students,deleteId);
        sc.close();

        //		6. 再次遍历数组学生信息
        for (int i = 0; i < students.length; i++) {
            students[i].display();
        }
        //		7. 判断id为“A02”的学生是否存在，存在则利用setAge将其年龄加一岁，否则打印不存在该学生
        changeStudent(students,"A02");

    }
    //3.
    public static Student[] insertStudents(Student[] students, Student s) {
        //			3.1 判断学生对象的学号是否包含于已经存在的数组中
        //			3.2 如果存在，则提示重复不加入数组。否则，加入数组
        if(!isId(s.getId(), students)){
            //加入数组
            return insertStudent(students, s);

        }else{
            System.out.println("Student with id "+s.getId()+" already exists");
        }
        return students;
    }
    //3.1
    public static boolean isId(String id, Student[] students) {
        for (int i = 0; i < students.length; i++) {
            if (students[i].getId().equals(id)) {
                return true;
            }
        }
        return false;
    }
    //3.2
    public static Student[] insertStudent(Student[] students,Student s) {
        //				3.2.1 利用数组中是否存在null值判断数组是否存储满
        for (int i = 0; i < students.length; i++) {
            if (students[i].getId() == null){
                //				3.2.3 否则，直接加入原数组
                students[i] = s;
                //				3.2.4 导出添加好学生对象的数组
                return students;
            }
        }
        //				3.2.2 如果存储满了，则定义一个新的数组，长度为原数组长度加一，将新的学生对象存储
        Student[] newStudents = new Student[students.length+1];
        for (int i = 0; i < students.length; i++) {
            newStudents[i] = students[i];
        }
        newStudents[newStudents.length-1] = s;
        //				3.2.4 导出添加好学生对象的数组
        return newStudents;
    }
    //5.
    public static Student[] deleteStudents(Student[] students, String deleteId) {
        //			5.1 判断是否存在（可用3.1的方法）
        if(isId(deleteId, students)){
            //			5.3 存在则删除
            return deleteStudent(students, deleteId);
        }else{
            //			5.2 不存在则提示该学生不存在
            System.out.println("Student with id "+deleteId+" does not exist");
        }
        return students;
    }
    //5.3
    public static Student[] deleteStudent(Student[] students,String deleteId) {
        //				5.3.1 获得该id在数组中的索引，利用方法导出索引
        int index = getIndex(students,deleteId);
        //				5.3.2 定义一个新的数组为原数组长度减一
        Student[] newStudents = new Student[students.length-1];
        //				5.3.3 该索引前原数组赋值给新数组，该索引后原数组全部往前移一个给新数组
        for (int i = 0; i < index; i++) {
            newStudents[i] = students[i];
        }
        for (int i = index+1; i < students.length; i++) {
            newStudents[i-1] = students[i];
        }
        //				5.3.4 导出删除后的数组
        return newStudents;
    }
    //5.3.1
    public static int getIndex(Student[] students, String deleteId) {
        for (int i = 0; i < students.length; i++) {
            if (students[i].getId().equals(deleteId)){
                return i;
            }
        }
        return -1;
    }
    //7.
    public static void changeStudent(Student[] students, String changeId) {
        int flag = 0;
        for (int i = 0; i < students.length; i++) {
            if (students[i].getId().equals(changeId)){
                int newAge = students[i].getAge() + 1;
                students[i].setAge(newAge);
                System.out.println("The age of the student "+students[i].getId()+" has been changed to "+newAge);
                students[i].display();
                flag = 1;
                break;
            }
        }
        if (flag == 0){
            System.out.println("Student with id "+changeId+" does not exist");
        }
    }
}

结果图：
不能删除
可以删除

soso（找实习版
关注
专栏目录
Java学习 - 黑马 - 随堂笔记 - 第一部分总目录
qq_43104872的博客
04-17 921
Java学习 - 黑马 - 随堂笔记 - 第一部分总目录 本内容仅为个人看视频记录的随手笔记，部分内容可能不全面，，可以作为学习黑马程序员Java基础视频参考使用或者看完之后进行复习巩固使用。 Java学习 - 黑马 - 随堂笔记 - 01_ Java概述 Java学习 - 黑马 - 随堂笔记 - 02_第一个程序 Java学习 - 黑马 - 随堂笔记 - 03_基础语法 Java学习 - 黑马 - 随堂笔记 - 04_运算符 Java学习 - 黑马 - 随堂笔记 - 05_数据输入 Java学习 - 黑马
java黑马学习笔记
02-21
是我从黑马资源中抓出来的每天教师上课的笔记,对于基础学习者帮助还是很大的,毕竟视频太多了,不可能全部看完,但是笔记就不一样.
【学习笔记】黑马程序员Java课程学习笔记（更新至第12章---集合）
热门推荐
weixin_47626968的博客
11-28 3万+
黑马课程Java学习笔记（1. Java概述）1. Java概述1.1 Java语言发展史1.2 Java语言跨平台原理1.3 JRE和JDK1.4 JDK的下载和安装 1. Java概述 1.1 Java语言发展史 Java语言是美国Sun公司（Stanford University Network）在1995年推出的计算机语言， 2009年Oracle甲骨文公司收购Sun公司。Java之父：詹姆斯·高斯林（James Gosling）。 1.2 Java语言跨平台原理 Java可以在任意操作系统上运行，
黑马java教程知识点笔记整理
02-04
之前收藏的一个大牛的知识点总结，结合黑马java视频看效果较好，希望能帮助到需要的人
黑马程序员Java笔记
m0_68735537的博客
03-14 2209
输出打印、参与运算、修改记录的值。
黑马程序员Javase笔记
01-18
Java是世界上最流行的编程语言之一，尤其在...总结来说，"黑马程序员Javase笔记"涵盖了Java的基础语法、内存管理、面向对象编程、集合框架以及泛型和Map等内容，这些都是成为一名合格Java开发者必须掌握的核心知识。
黑马程序员–Java多线程讲解笔记
12-22
两种方式的对比中，实现Runnable接口更优，因为它可以实现多继承，更好地体现面向对象设计，且代码和数据独立，有利于线程间共享资源。 线程有四种基本状态：新建、就绪、运行、阻塞和死亡。在多线程环境中，线程的...
2018年黑马程序员全套教程java基础第1天笔记+讲义
07-19
《2018年黑马程序员全套教程java基础第1天笔记+讲义》是一份针对初学者精心编排的Java编程教程，旨在帮助新手快速掌握Java编程的基础知识。本教程结合了JDK9的新特性以及IntelliJ IDEA的实用技巧，为学习者提供了一...
黑马程序员java笔记思维导图
06-06
黑马程序员java笔记思维导图是一份基于Java编程语言的笔记和思维导图，它涵盖了Java编程语言的核心概念、常用类库、面向对象编程、集合框架、IO流、多线程、反射、注解、网络编程等方面的知识点。它是一份非常全面且...
黑马java基础笔记
m0_49808352的博客
03-15 794
List(接口,有序、可重复、有索引,for循环) set(接口，无序、不可重复、无索引，对象不重复(若认为两个内容一样的对象重复，即重写equals()和hashCode()))数据源(集合、数组)[获取stream流] ---> 常见的中间方法(过滤，去重，排序) ---> 获取结果(常见的终结方法，遍历，统计，收集)乐观锁：一开始不上锁，认为是没有问题的，大家一起跑，等要出现线程安全问题的时候才开始控制。
黑马java学习笔记2(阶段一 第一章1-4 13~1-5 07)
最新发布
xiaozhuzhu__的博客
07-17 327
注：在实际开发过程中建议使用“数据类型[] 数组名”的格式来写代码。// 方式一：静态初始化数组// 1.完整格式：// 数据类型[] 数组名 = new 数据类型[]{元素1, 元素2, ……};// 存储的是数组在内存中的地址，所以是输出地址而不是值// 2.简化格式：// 推荐写法：数据类型[] 数组名 = {元素1, 元素2, ……};// 还可写成：数据类型 数组名[] = {元素1, 元素2, ……};// 方式二：动态初始化数组。
JAVA 黑马学习笔记记录 Java基本语法
wifiuuu的博客
07-20 278
运算符对常量或者变量进行操作的符号表达式用运算符把常量或者变量连接起来符合java语法的式子就可以称为表达式。不同运算符连接的表达式体现的是不同类型的表达式。
黑马程序员 JAVA基础学习笔记
toughboy的专栏
05-01 366
用FOR循环的++运算输出三角形时，想要尖头在上，一般动条件，让内循环如j BREAK跳出的循环，循环不会再继续； 循环外可以通过aaa:for....这样的标志，跳出到外层循环：如break aaa; continue也可以使用标志，如continue aaa ; 这倆语句的下面语句都执行不到，成了没有意义的语句； 在JAVA中，函数和方法是一个意思； 主函数只能调用静态函数，因为主
JAVA基础知识(黑马java笔记)
qq_73270720的博客
06-30 169
Java核心类库里面封装的java源码用于输出。若在java.lang中，则直接使用。给类，变量，方法取名字的一些符号。对数据的处理交给其他类来完成。jdk API 帮助文档。Java赋予特殊含义的单词。若不在，要用导包代码导入包。数据在代码中的书写格式。2.给class命名。
黑马java学习笔记1(阶段一 第一章1-1~1-4 08)
xiaozhuzhu__的博客
07-09 1272
黑马程序员Java学习路线：Java基础 → JavaWeb → 热门框架 → 苍穹外卖 → 服务框架 → 天机学堂 → 立可得→ 面试专题
【最新】Java基础学习笔记（20天学会java黑马）（一）
一位养猪专业户
01-07 1196
【最新】Java基础学习笔记(20天学会java黑马)（一）
【学习笔记/自用】黑马程序员javase2023版-基础
qq_41014040的博客
02-22 3721
黑马程序员2023版笔记，省略简单内容，笔记大部分为易错的地方。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值