Java基于类与对象做的游戏

        在学习完类和对象之后就可以开始着手做一些文字小游戏了，下面是我做的一个文字小游戏，感谢大家观看。

链接：https://pan.baidu.com/s/1L05Q3pWWZ3XTYM30jXs4PA 
提取码：bpnb

---

一、基础工作——创建多个对象

1、首先创建一个用户的对象

        这个用户对象主要是主角的属性，有主角的血量、剩余血量、蓝量、剩余蓝量、名字、性别、经验、当前经验、等级、攻击力和6个技能，并为这些属性添加set和get方法。

public class User {
    private int blood;  //血量
    private int remainingBlood; //剩余血量
    private int remainingBlueDose; //剩余蓝量
    private int blueDose;   //蓝量
    private String gender;  //性别
    private String name;    //名字
    private int EXP;    //经验
    private int remainingEXP;   //剩余经验
    private int Lv; //等级
    private int attack; //攻击力
    static final String still1;
    static final String still2;
    static final String still3;
    static final String still4;
    static final String still5;
    static final String still6;

    static {
        still1 = "洞虚气";
        still2 = "花雨刀";
        still3 = "弄雾劲";
        still4 = "一元爪";
        still5 = "九天劲";
        still6 = "噬魂玄女六阳枪";
    }

    public User() {
    }

    public User(int remainingEXP, int remainingBlueDose, int remainingBlood, int blood, int blueDose, String gender, String name, int EXP, int lv, int attack) {
        this.remainingEXP = remainingEXP;
        this.remainingBlueDose = remainingBlueDose;
        this.remainingBlood = remainingBlood;
        this.blood = blood;
        this.blueDose = blueDose;
        this.gender = gender;
        this.name = name;
        this.EXP = EXP;
        Lv = lv;
        this.attack = attack;
    }

    public int getRemainingEXP() {
        return remainingEXP;
    }

    public void setRemainingEXP(int remainingEXP) {
        this.remainingEXP = remainingEXP;
    }

    public int getRemainingBlueDose() {
        return remainingBlueDose;
    }

    public void setRemainingBlueDose(int remainingBlueDose) {
        this.remainingBlueDose = remainingBlueDose;
    }

    public int getRemainingBlood() {
        return remainingBlood;
    }

    public void setRemainingBlood(int remainingBlood) {
        this.remainingBlood = remainingBlood;
    }

    public int getBlood() {
        return blood;
    }

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

    public int getBlueDose() {
        return blueDose;
    }

    public void setBlueDose(int blueDose) {
        this.blueDose = blueDose;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public String getName() {
        return name;
    }

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

    public int getEXP() {
        return EXP;
    }

    public void setEXP(int EXP) {
        this.EXP = EXP;
    }

    public int getLv() {
        return Lv;
    }

    public void setLv(int lv) {
        Lv = lv;
    }

    public int getAttack() {
        return attack;
    }

    public void setAttack(int attack) {
        this.attack = attack;
    }

    @Override
    public String toString() {
        return "User{" +
                "blood=" + blood +
                ", blueDose=" + blueDose +
                ", gender='" + gender + '\'' +
                ", name='" + name + '\'' +
                ", EXP=" + EXP +
                ", Lv=" + Lv +
                ", attack=" + attack +
                '}';
    }
}

2.创建一个小怪的对象

        这是一个名为Monster_one的类，表示一个怪物角色。它有三个私有属性：name（名称）、blood（血量）、attack（攻击力），以及三个静态的final属性：skill1、skill2、skill3（技能名称）。

        类中有两个构造方法：一个是默认的无参构造方法，另一个是带有name、blood、attack三个参数的构造方法。

        还有一些getter和setter方法用于获取和设置属性的数值。

        最后，还有一个重写的toString方法，用于返回该怪物角色的属性信息。（这个主要是之前用于代码调试的）

public class Monster_one {
    private String name;
    private int blood;
    private int attack;
    static final String skill1;
    static final String skill2;
    static final String skill3;

    static {
        skill1 = "勾魂拳";
        skill2 = "无极神通";
        skill3 = "天山劲";
    }

    public Monster_one() {
    }

    public Monster_one(String name, int blood, int attack) {
        this.attack = attack;
        this.name = name;
        this.blood = blood;
    }

    public int getAttack() {
        return attack;
    }

    public void setAttack(int attack) {
        this.attack = attack;
    }

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

    @Override
    public String toString() {
        return "Monster_one{" +
                "name='" + name + '\'' +
                ", blood=" + blood +
                ", attack=" + attack +
                '}';
    }
}

3.创建一个boss对象

        这段代码定义了一个Boss类，包含了Boss的姓名、血量和攻击力等属性，以及三个静态常量still1、still2、still3，分别表示Boss的三种攻击技能。其中，静态常量是在类加载时就被初始化的，且不可修改。

        该类还提供了默认构造方法和带参数的构造方法，以及相应的getter和setter方法。

        最后，该类还重写了toString()方法，用于输出Boss对象的属性信息。

public class Boss {
    private String name;
    private int blood;
    private int attack;
     static final String still1;
     static final String still2;
     static final String still3;

    static {
        still1 = "无色诛妖导引术";
        still2 = "洞虚若愚青竹棍";
        still3 = "中孚护仙诛龙吐纳术";
    }

    @Override
    public String toString() {
        return "Boss{" +
                "name='" + name + '\'' +
                ", blood=" + blood +
                ", attack=" + attack +
                '}';
    }


    public Boss() {
    }

    public Boss(String name, int blood, int attack) {
        this.name = name;
        this.blood = blood;
        this.attack = attack;
    }

    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 int getAttack() {
        return attack;
    }

    public void setAttack(int attack) {
        this.attack = attack;
    }
}

4.创建物品类

        这是一个名为Item的类，其中定义了12个字符串类型的物品名称，分别表示不同种类的游戏道具。同时，还定义了一个长度为12的整型数组arr，用于表示每种道具的数量。数组中的每个元素对应着相应道具的数量，例如arr[0]表示item1的数量，arr[1]表示item2的数量，依此类推

public class Item {
      String item1 = "小型回复水";
      String item2 = "中型回复水";
      String item3 = "大型回复水";
      String item4 = "小型经验丹";
      String item5 = "中兴经验丹";
      String item6 = "大型经验丹";
      String item7 = "小型蓝瓶";
      String item8 = "中型蓝屏";
      String item9 = "大型蓝屏";
      String item10 = "小型血瓶";
      String item11 = "中型血瓶";
      String item12 = "大型血瓶";

     int []arr = {1,0,0,1,0,0,1,0,0,1,0,0};

}

二、主程序的代码

1.给游戏添加故事背景

        这个故事背景是我自己随便乱写的，大家当啊看那个乐子哈

    //游戏背景
    public static void background() {
        Scanner sc = new Scanner(System.in);
        System.out.println("在远古时期，魔神入侵了这方世界，人们四方溃散。");
        System.out.println("魔神抓住人们献祭以获得强大的力量");
        System.out.println("就在人类快要毁灭之际，他们召唤了你出来，勇者。");
        System.out.println("你和魔王大战了两年半，最终将魔王封印了");
        System.out.println("不过你也受了重伤，最后等级变成了最初的等级");
        System.out.println("魔王在百年后将再次冲破封印，加油吧，勇士！");
        System.out.println("------------------------");
        System.out.println("游戏介绍：继续下面的剧情随机按键盘并回车");
        System.out.println("------------------------");
    }

2.添加小怪的样子

//小怪样子
    public static void monstrosity() {
        System.out.println("        _____\n");
        System.out.println("     ,-:` \\;',`'-, \n");
        System.out.println("  .'-;_,;  ':-;_,'.\n");
        System.out.println(" /;   '/    ,  _`.-\\\n");
        System.out.println("| '`. (`     /` ` ` '|\n");
        System.out.println("|:.  `\\`-.   \\_   `,'\n");
        System.out.println("`-.._)`\\__/  _.--\\   \\\n");
        System.out.println("        /`   /        (`\\\n");
        System.out.println("       /`,   \\         |\\\n");
        System.out.println("      / /     \\        ) )\n");
        System.out.println("     \\ \\      `._,-' / /\n");
        System.out.println("      `-/           `-'`\n");
        System.out.println("         \n");
    }

3.添加boss样子

    //boss样子
    public static void bossAppearance() {
        System.out.println("           ___..-.---.-.___\n");
        System.out.println("    _..---` .---.-.   `   ``--.__\n");
        System.out.println("   .        `     `  }` ` _        `.\n");
        System.out.println("         ,_  /    ,_  .  -` `--.   \\\n");
        System.out.println("           `//     / /   `,    \\   .\n");
        System.out.println("    -..:::::::`-..`_\\ _-\\ /     \\   \\\n");
        System.out.println(" .-'::::::::::::::::``  /```\\/\\_   \\`. ))\n");
        System.out.println("/:::::;;::::;:;;:;:;` / /        `---`{}}}\n");
        System.out.println(" `-.._:::::/  /\\_/ / /   `.__,         ){}}}\n");
        System.out.println("      `'-::<`  <` <`-;\\      \\          ){}}/              _..._\n");
        System.out.println("               `\\   /`|      /   `\\     /{{{/   _       /    ,   \\\n");
        System.out.println("               `\\   /`|      /   `\\     /{{{/   _       /    ,     \\\n");
        System.out.println("                 `\\` `\\;\\__  /_ _ _`\\  /{{{/  _;M;_____/_   /    .\\`.\n");
        System.out.println("                   `\\        `      \\'`\"{{;*\"\"\"\"\"\"      `,._     \\M\n");
        System.out.println("                     `\\                                            `\n");
        System.out.println("                       `\\                                          ` \n");
    }

4.技能

        这里应该可以用方法简化，大家可以尝试下

    //通过判断角色等级是否输出技能
    public static void still(User u) {
        if (u.getLv() >= 5 && u.getLv() < 10) {
            System.out.println("*技能1：" + User.still1 + ",造成100点伤害");
        } else if (u.getLv() >= 10 && u.getLv() < 15) {
            System.out.println("*技能1：" + User.still1 + ",造成100点伤害");
            System.out.println("*技能2：" + User.still2 + ",造成120点伤害");
        } else if (u.getLv() >= 15 && u.getLv() < 20) {
            System.out.println("*技能1：" + User.still1 + ",造成100点伤害");
            System.out.println("*技能2：" + User.still2 + ",造成120点伤害");
            System.out.println("*技能3：" + User.still3 + ",造成140点伤害");
        } else if (u.getLv() >= 20 && u.getLv() < 25) {
            System.out.println("*技能1：" + User.still1 + ",造成100点伤害");
            System.out.println("*技能2：" + User.still2 + ",造成120点伤害");
            System.out.println("*技能3：" + User.still3 + ",造成140点伤害");
            System.out.println("*技能4：" + User.still4 + ",造成160点伤害");
        } else if (u.getLv() >= 25 && u.getLv() < 30) {
            System.out.println("*技能1：" + User.still1 + ",造成100点伤害");
            System.out.println("*技能2：" + User.still2 + ",造成120点伤害");
            System.out.println("*技能3：" + User.still3 + ",造成140点伤害");
            System.out.println("*技能4：" + User.still4 + ",造成160点伤害");
            System.out.println("*技能5：" + User.still5 + ",造成180点伤害");
        } else if (u.getLv() >= 30) {
            System.out.println("*技能1：" + User.still1 + ",造成100点伤害");
            System.out.println("*技能2：" + User.still2 + ",造成120点伤害");
            System.out.println("*技能3：" + User.still3 + ",造成140点伤害");
            System.out.println("*技能4：" + User.still4 + ",造成160点伤害");
            System.out.println("*技能5：" + User.still5 + ",造成180点伤害");
            System.out.println("*技能6：" + User.still6 + ",造成200点伤害");
        }
    }

5.个人属性

        该方法用于显示用户的角色属性面板。首先，使用Scanner类创建一个Scanner对象sc，用于接收用户输入。然后，使用System.out.println()方法打印角色属性面板的标题。接着，使用u对象的getter方法获取用户的姓名、攻击力、性别、等级、血量、剩余血量、蓝量、剩余蓝量、经验和剩余经验，并将其打印出来。接着调用still()方法，然后打印提示信息，等待用户输入。用户输入1后，方法结束。

        需要注意的是，该方法使用了User对象u的getter方法获取用户的属性信息，并使用System.out.println()方法打印出来。在最后，使用Scanner类的next()方法等待用户输入，以便返回上一级菜单。

    //查看个人属性栏
    public static void charactersStats(User u) {
        Scanner sc = new Scanner(System.in);
        System.out.println("--------角色属性面板------");
        System.out.print("*姓名：" + u.getName() + "\t\t");
        System.out.println("*攻击力：" + u.getAttack());
        System.out.print("*性别：" + u.getGender() + "\t\t");
        System.out.println("*等级：" + u.getLv());
        System.out.print("*血量：" + u.getBlood() + "\t\t");
        System.out.println("*剩余血量：" + u.getRemainingBlood() + "\t\t");
        System.out.print("*蓝量：" + u.getBlueDose() + "\t\t");
        System.out.println("*剩余蓝量：" + u.getRemainingBlueDose());
        System.out.print("*经验：" + u.getEXP() + "\t\t");
        System.out.println("*当前经验：" + u.getRemainingEXP());
        still(u);
        System.out.println();
        System.out.println("按1+回车键返回");
        sc.next();
    }

6.物品栏 

        输出打印12件物品，并通过用户的输入是否使用，如果数量不足则会使用失败

    //查看物品栏
    public static void inventoryPanel(Item i, User u) {
        int a = 0;
        System.out.println("-----------------------------物品栏--------------------------");
        System.out.print("1." + i.item1 + "：" + i.arr[0] + "\t\t\t");
        System.out.print("2." + i.item2 + "：" + i.arr[1] + "\t\t\t");
        System.out.println("3." + i.item3 + "：" + i.arr[2]);
        System.out.print("4." + i.item4 + "：" + i.arr[3] + "\t\t\t");
        System.out.print("5." + i.item5 + "：" + i.arr[4] + "\t\t\t");
        System.out.println("6." + i.item6 + "：" + i.arr[5]);
        System.out.print("7." + i.item7 + "：" + i.arr[6] + "\t\t\t\t");
        System.out.print("8." + i.item8 + "：" + i.arr[7] + "\t\t\t\t");
        System.out.println("9." + i.item9 + "：" + i.arr[8]);
        System.out.print("10." + i.item10 + "：" + i.arr[9] + "\t\t\t");
        System.out.print("11." + i.item11 + "：" + i.arr[10] + "\t\t\t");
        System.out.println("12." + i.item12 + "：" + i.arr[11]);
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("是否要使用物品（1/0）：");
            String number = sc.next();
            if (number.equals("1")) {
                System.out.println("请输入选择的药剂：");
                System.out.println("排序为1-12(横向排序)");
                String index = sc.next();
                switch (index) {
                    case "1":
                        if (i.arr[0] > 0) {
                            if (u.getRemainingBlood() + 30 > u.getBlood()) {
                                u.setRemainingBlood(u.getBlood());
                            } else {
                                a = u.getRemainingBlood();
                                u.setRemainingBlood(a + 30);
                            }
                            if (u.getRemainingBlueDose() + 20 > u.getBlueDose()) {
                                u.setRemainingBlood(u.getBlueDose());
                            } else {
                                a = u.getRemainingBlueDose();
                                u.setRemainingBlood(a + 20);
                            }
                            i.arr[0]--;
                            System.out.println(i.item1 + "使用成功");
                        } else {
                            System.out.println("数量不足");
                        }
                        break;
                    case "2":
                        if (i.arr[1] > 0) {
                            if (u.getRemainingBlood() + 50 > u.getBlood()) {
                                u.setRemainingBlood(u.getBlood());
                            } else {
                                a = u.getRemainingBlood();
                                u.setRemainingBlood(a + 50);
                            }
                            if (u.getRemainingBlueDose() + 40 > u.getBlueDose()) {
                                u.setRemainingBlood(u.getBlueDose());
                            } else {
                                a = u.getRemainingBlueDose();
                                u.setRemainingBlood(a + 40);
                            }
                            i.arr[1]--;
                            System.out.println(i.item2 + "使用成功");
                        } else {
                            System.out.println("数量不足");
                        }

                        break;
                    case "3":
                        if (i.arr[2] > 0) {
                            if (u.getRemainingBlood() + 100 > u.getBlood()) {
                                u.setRemainingBlood(u.getBlood());
                            } else {
                                a = u.getRemainingBlood();
                                u.setRemainingBlood(a + 100);
                            }
                            if (u.getRemainingBlueDose() + 80 > u.getBlueDose()) {
                                u.setRemainingBlood(u.getBlueDose());
                            } else {
                                a = u.getRemainingBlueDose();
                                u.setRemainingBlood(a + 80);
                            }
                            i.arr[2]--;
                            System.out.println(i.item3 + "使用成功");
                        } else {
                            System.out.println("数量不足");
                        }

                        break;
                    case "4":
                        if (i.arr[3] > 0) {
                            a = u.getRemainingEXP();
                            u.setRemainingEXP(a + 30);
                            upgrades(u);
                            i.arr[3]--;
                            System.out.println(i.item4 + "使用成功");
                        } else {
                            System.out.println("数量不足");
                        }
                        break;
                    case "5":
                        if (i.arr[4] > 0) {
                            a = u.getRemainingEXP();
                            u.setRemainingEXP(a + 60);
                            upgrades(u);
                            i.arr[4]--;
                            System.out.println(i.item5 + "使用成功");
                        } else {
                            System.out.println("数量不足");
                        }
                        break;
                    case "6":
                        if (i.arr[5] > 0) {
                            a = u.getRemainingEXP();
                            u.setRemainingEXP(a + 120);
                            upgrades(u);
                            i.arr[5]--;
                            System.out.println(i.item6 + "使用成功");
                        } else {
                            System.out.println("数量不足");
                        }
                        break;
                    case "7":
                        if (i.arr[6] > 0) {
                            if (u.getRemainingBlueDose() + 20 > u.getBlueDose()) {
                                u.setRemainingBlood(u.getBlueDose());
                            } else {
                                a = u.getRemainingBlueDose();
                                u.setRemainingBlood(a + 20);
                            }
                            i.arr[6]--;
                            System.out.println(i.item7 + "使用成功");
                        } else {
                            System.out.println("数量不足");
                        }
                        break;
                    case "8":
                        if (i.arr[7] > 0) {
                            if (u.getRemainingBlueDose() + 40 > u.getBlueDose()) {
                                u.setRemainingBlood(u.getBlueDose());
                            } else {
                                a = u.getRemainingBlueDose();
                                u.setRemainingBlood(a + 40);
                            }
                            i.arr[7]--;
                            System.out.println(i.item8 + "使用成功");
                        } else {
                            System.out.println("数量不足");
                        }
                        break;
                    case "9":
                        if (i.arr[8] > 0) {
                            if (u.getRemainingBlueDose() + 80 > u.getBlueDose()) {
                                u.setRemainingBlood(u.getBlueDose());
                            } else {
                                a = u.getRemainingBlueDose();
                                u.setRemainingBlood(a + 80);
                            }
                            i.arr[8]--;
                            System.out.println(i.item9 + "使用成功");
                        } else {
                            System.out.println("数量不足");
                        }
                        break;
                    case "10":
                        if (i.arr[9] > 0) {
                            if (u.getRemainingBlood() + 30 > u.getBlood()) {
                                u.setRemainingBlood(u.getBlood());
                            } else {
                                a = u.getRemainingBlood();
                                u.setRemainingBlood(a + 30);
                            }

                            i.arr[9]--;
                            System.out.println(i.item10 + "使用成功");
                        } else {
                            System.out.println("数量不足");
                        }
                        break;
                    case "11":
                        if (i.arr[10] > 0) {
                            if (u.getRemainingBlood() + 60 > u.getBlood()) {
                                u.setRemainingBlood(u.getBlood());
                            } else {
                                a = u.getRemainingBlood();
                                u.setRemainingBlood(a + 60);
                            }

                            i.arr[10]--;
                            System.out.println(i.item11 + "使用成功");
                        } else {
                            System.out.println("数量不足");
                        }
                        break;
                    case "12":
                        if (i.arr[11] > 0) {
                            if (u.getRemainingBlood() + 120 > u.getBlood()) {
                                u.setRemainingBlood(u.getBlood());
                            } else {
                                a = u.getRemainingBlood();
                                u.setRemainingBlood(a + 120);
                            }

                            i.arr[11]--;
                            System.out.println(i.item12 + "使用成功");
                        } else {
                            System.out.println("数量不足");
                        }
                        break;
                    default:
                        System.out.println("输入错误！");
                }
            } else if (number.equals("0")) {
                System.out.println("好的,未使用药剂");
                return;
            } else {
                System.out.println("输入错误！");
            }

        }
    }

 7.判断用户是否可以升级

        这段代码用于判断用户的经验是否能够升级，并在满足条件时进行升级操作。首先判断用户剩余经验是否大于当前经验，如果是，则进行升级操作。升级操作包括将用户等级加1，更新剩余经验为剩余经验减去当前经验，更新当前经验为当前经验加30。同时，血量和蓝量也会根据升级进行提升，并回满。

    //判断经验能不能升级
    public static void upgrades(User u) {
        if (u.getRemainingEXP() > u.getEXP()) {
            int a = u.getRemainingEXP()-u.getEXP();
            u.setLv(u.getLv() + 1);
            u.setRemainingEXP(a);
            u.setEXP(u.getEXP() + 30);
            //血量提升并回满
            u.setBlood(u.getBlood() + 50);
            u.setRemainingBlood(u.getBlood());
            //蓝量提升并回满
            u.setBlueDose(u.getBlueDose() + 30);
            u.setRemainingBlueDose(u.getBlueDose());
        }
    }

8.用户选择

        这段代码实现了用户在游戏中做出选择的功能。用户可以选择向上、向左、向右、向下四个方向，并根据随机生成的事件类型进行相应的处理。事件类型包括宝箱、小怪、精英怪、前进。用户还可以选择查看角色属性面板、查看物品栏或退出游戏。

        在循环中，首先通过随机数生成事件类型，并将其存储在数组arr中。然后根据用户的选择，执行相应的事件处理函数。如果用户选择查看属性面板或物品栏，则执行相应的函数进行显示。如果用户选择退出游戏，则调用System.exit(0)退出程序。

        总体来说，这段代码实现了用户在游戏中进行选择和交互的功能，根据用户的选择执行相应的操作。

    //用户选择
    public static void selection(User u, Item it) {
        Random r = new Random();
        String[] name = {"宝箱", "小怪", "精英怪", "前进"};
        int[] arr = new int[name.length];

        Scanner sc = new Scanner(System.in);
        while (true) {
            for (int i = 0; i < 4; i++) {
                int index1 = r.nextInt(200);
                if (index1 <= 10) {
                    arr[i] = 0;
                } else if (index1 <= 150) {
                    arr[i] = 1;
                } else if (index1 <= 160) {
                    arr[i] = 2;
                } else {
                    arr[i] = 3;
                }
            }
            System.out.println("------------------------------------------");
            System.out.println("1.向上--" + name[arr[0]]);
            System.out.println("2.向左--" + name[arr[1]]);
            System.out.println("3.向右--" + name[arr[2]]);
            System.out.println("4.向下--" + name[arr[3]]);
            System.out.println("5.查看属性面板");
            System.out.println("6.查看物品栏");
            System.out.println("7.退出游戏");
            System.out.println("请做出你的选择：");
            System.out.println("------------------------------------------");
            String number = sc.next();
            switch (number) {
                case "1":
                    switch (name[arr[0]]) {
                        case "宝箱" -> incident1(it);
                        case "小怪" -> incident2(it, u);
                        case "精英怪" -> incident3(it, u);
                        default -> System.out.println("什么也没有发生");
                    }
                    break;
                case "2":
                    switch (name[arr[1]]) {
                        case "宝箱" -> incident1(it);
                        case "小怪" -> incident2(it, u);
                        case "精英怪" -> incident3(it, u);
                        default -> System.out.println("什么也没有发生");
                    }
                    break;
                case "3":
                    switch (name[arr[2]]) {
                        case "宝箱" -> incident1(it);
                        case "小怪" -> incident2(it, u);
                        case "精英怪" -> incident3(it, u);
                        default -> System.out.println("什么也没有发生");
                    }
                    break;
                case "4":
                    switch (name[arr[3]]) {
                        case "宝箱" -> incident1(it);
                        case "小怪" -> incident2(it, u);
                        case "精英怪" -> incident3(it, u);
                        default -> System.out.println("什么也没有发生");
                    }
                    break;
                case "5":
                    charactersStats(u);
                    break;
                case "6":
                    inventoryPanel(it, u);
                    break;
                case "7":
                    System.exit(0);
                default:
                    System.out.println("输入错误，请重新输入！");
            }
        }
    }

9.宝箱收获

        这段代码是一个事件处理的方法，接受一个Item对象作为参数。在方法中，使用Random类生成一个随机数index，然后根据index的取值范围来决定给Item对象的数组arr中的对应索引位置加一，并输出获得的物品信息。最后，使用Scanner类等待用户输入1来继续执行。

    //宝箱收获
    public static void incident1(Item i) {
        Random r = new Random();
        int[] arr = new int[12];
        int index = r.nextInt(113) + 1;
        if (index <= 20) {
            i.arr[0]++;
            System.out.println("获得了小型回复水");
        } else if (index <= 40) {
            System.out.println("获得了小型经验丹");
            i.arr[3]++;
        } else if (index <= 60) {
            System.out.println("获得了小型蓝瓶");
            i.arr[6]++;
        } else if (index <= 80) {
            System.out.println("获得了小型血瓶");
            i.arr[9]++;
        } else if (index <= 85) {
            System.out.println("获得了中型回复水");
            i.arr[1]++;
        } else if (index <= 90) {
            System.out.println("获得了中型经验丹");
            i.arr[4]++;
        } else if (index <= 95) {
            System.out.println("获得了中型蓝瓶");
            i.arr[7]++;
        } else if (index <= 100) {
            System.out.println("获得了中型血瓶");
            i.arr[10]++;
        } else if (index <= 103) {
            System.out.println("获得了大瓶回复水");
            i.arr[2]++;
        } else if (index <= 106) {
            System.out.println("获得了大型经验丹");
            i.arr[5]++;
        } else if (index <= 109) {
            System.out.println("获得了大瓶蓝瓶");
            i.arr[8]++;
        } else if (index <= 112) {
            System.out.println("获得了大瓶血瓶");
            i.arr[11]++;
        }
        Scanner sc = new Scanner(System.in);
        System.out.println("按1+回车键继续");
        sc.next();
    }

10.boss的初始化 

        此代码是一个静态方法，用于初始化一个大怪对象。首先定义了一个包含大怪名称的字符串数组，然后使用Random类生成一个随机数作为大怪的初始血量，再次使用Random类生成一个随机数作为大怪的初始攻击力。最后返回一个新的大怪对象，包括随机选择的名称、初始血量和初始攻击力。

    //大怪的初始化
    public static Boss boss() {
        String[] name = {"移星古狼", "浮花乌鬼鹰", "大衍狐", "戮魔犰狳", "守神白参", "无色古鹌鹑",
                "九天鹈鹕", "移星鳄", "晶炎古蛤蟆", "绝天虫", "暗神鸬鹚", "化煞貔貅", "火仙蛟"};
        Random r = new Random();
        int index = r.nextInt(30) + 10;
        int number = r.nextInt(name.length);
        return new Boss(name[number], 400, index);
    }

11.小怪的初始化

        如上

    //小怪的初始化
    public static Monster_one monster() {
        String[] name = {"五阴蚕", "黑野草", "护魔猫", "心意熊", "乌玄蝾螈", "太始墨鱼",
                "灰野蛤", "雌雄豚", "灰灵蛇", "天雷鳄", "封魂灰树"};
        Random r = new Random();
        int index = r.nextInt(10) + 1;
        int number = r.nextInt(name.length);
        return new Monster_one(name[number], 200, index);
    }

12.与怪兽之间的战斗

        这段代码是一个游戏中的战斗事件处理方法，接受一个物品和用户作为参数。在战斗中，会随机生成一个怪物，并不断循环进行战斗，直到怪物的生命值小于等于0为止。在战斗中，用户可以选择攻击、使用技能、查看物品、逃跑等操作。同时，怪物也会进行攻击，造成一定的伤害。战斗结束后，用户会获得经验值，并进行升级处理。最后会调用另一个事件处理方法incident1。

        其中涉及到用户的属性和方法，怪物的属性和方法，技能的选择和使用，物品的查看和使用等。整个方法实现了一个完整的战斗流程，并且与其他游戏内容进行了交互。

 public static void incident2(Item i, User u) {
        Scanner sc = new Scanner(System.in);
        Random r = new Random();
        int index = r.nextInt(10) + 1;
        Monster_one m = monster();
        while (m.getBlood() > 0) {
            if (u.getRemainingBlood() > 0) {
                monstrosity();
                System.out.println("名字：" + m.getName() + "\t\t" +
                        "生命值：" + m.getBlood() + "\t\t" +
                        "攻击力：" + m.getAttack());
                System.out.println("你获得先手优势！");
                System.out.println("请做出你的选择：(1-4)");
                System.out.println("1.攻击");
                System.out.println("2.技能");
                System.out.println("3.物品");
                System.out.println("4.逃跑");
                String number = sc.next();
                switch (number) {
                    case "1":
                        System.out.println(m.getName() + "受到了" + u.getAttack() + "点伤害");
                        m.setBlood(m.getBlood() - u.getAttack());
                        break;
                    case "2":
                        if (u.getLv() < 5) {
                            System.out.println("您的等级没有开启技能，请继续努力！");
                        } else {
                            still(u);
                            System.out.println("请选择你使用的技能：(默认使用1技能)");
                            String skill = sc.next();
                            switch (skill) {
                                case "1":
                                    still(m, u, "洞虚气", 100, 8);
                                    break;
                                case "2":
                                    still(m, u, "花雨刀", 120, 9);
                                    break;
                                case "3":
                                    still(m, u, "弄雾劲", 140, 10);
                                    break;
                                case "4":
                                    still(m, u, "一元爪", 160, 11);
                                    break;
                                case "5":
                                    still(m, u, "九天劲", 180, 12);
                                    break;
                                case "6":
                                    still(m, u, "噬魂玄女六阳枪", 200, 13);
                                    break;
                            }
                        }
                        break;
                    case "3":
                        inventoryPanel(i, u);
                        break;
                    case "4":
                        return;
                }
                if (m.getBlood()<=0){
                    break;
                }
                String[] arr = {
                        m.getName() + "向前递出一拳，直击你的面门而来，造成了" + (m.getAttack() + index) + "点伤害",
                        m.getName() + "轰的一拳，往你身上砸去，造成了" + (m.getAttack() + index) + "点伤害",
                        m.getName() + "趁你不备，一脚向下扫出，造成了" + (m.getAttack() + index) + "点伤害",
                        m.getName() + "向前递出一拳，直击你的面门而来，造成了" + (m.getAttack() + index) + "点伤害",
                        m.getName() + "双手蓄力，一个巨大的拳罡向你袭来，造成了" + (m.getAttack() + index) + "点伤害",
                        m.getName() + "双手撑地，双腿狠狠的踢向你的胸口，造成了" + (m.getAttack() + index) + "点伤害",
                        m.getName() + "双拳袭来，直击你的面门而来，但是被你躲过，没有造成伤害",
                };
                int index1 = r.nextInt(10) + 1;
                int index2 = r.nextInt(arr.length);
                if (index1 <= 8) {
                    System.out.println(arr[index2]);
                    int attack = index + u.getAttack();
                    u.setRemainingBlood(u.getRemainingBlood() - attack);
                } else {
                    int monsterStill = r.nextInt(3) + 1;
                    if (monsterStill == 1) {
                        System.out.println(m.getName() + "使用了" + Monster_one.skill1
                                + "，造成了" + (20 + index1) + "点伤害");
                        u.setRemainingBlood(u.getRemainingBlood() - 20 + index1);
                    } else if (monsterStill == 2) {
                        System.out.println(m.getName() + "使用了" + Monster_one.skill1
                                + "，造成了" + (30 + index1) + "点伤害");
                        u.setRemainingBlood(u.getRemainingBlood() - 30 + index1);
                    } else {
                        System.out.println(m.getName() + "使用了" + Monster_one.skill1
                                + "，造成了" + (40 + index1) + "点伤害");
                        u.setRemainingBlood(u.getRemainingBlood() - 40 + index1);
                    }
                }
            } else {
                System.out.println("血量不足，无法挑战！");
            }
            System.out.println("按1+回车键继续");
            sc.next();
        }
        System.out.println("你杀死了"+m.getName());
        int a = r.nextInt(30)+30;
        System.out.println("经验值+"+a);
        upgrades(u);
        u.setRemainingEXP(u.getRemainingEXP()+a);
        incident1(i);
    }

13.角色和怪兽的技能

        这段代码定义了两个重载的still方法，用于对怪物和Boss使用技能造成伤害。参数包括怪物或Boss的对象m，用户的对象u，技能名称skillName，伤害值heart和消耗的蓝量blueDose。方法中打印了技能名称和对怪物或Boss造成的伤害，并更新了用户剩余的蓝量。对于Boss的方法还更新了Boss的血量。

    //1-6个技能
    public static void still(Monster_one m, User u, String skillName, int heart, int blueDose) {
        System.out.println("你使用了" + skillName + "," + m.getName() +
                "受到了" + heart + "点伤害");
        u.setRemainingBlueDose(u.getRemainingBlueDose() - blueDose);
        m.setBlood(m.getBlood() - heart);
        System.out.println("你还剩余"+u.getRemainingBlueDose()+"点蓝量");
    }
    public static void still(Boss m, User u, String skillName, int heart, int blueDose) {
        System.out.println("你使用了" + skillName + "," + m.getName() +
                "受到了" + heart + "点伤害");
        u.setRemainingBlueDose(u.getRemainingBlueDose() - blueDose);
        m.setBlood(m.getBlood() - heart);
    }

三、主程序完整代码

import javax.xml.transform.Source;
import java.util.Random;
import java.util.Scanner;

public class Game {
    public static void main(String[] args) {
        background();
        Scanner sc = new Scanner(System.in);
        sc.next();
        System.out.println("好的，勇士，请问你的名字是：");
        User u = new User();
        u.setName(sc.next());
        System.out.println("你的性别是：");
        u.setGender(sc.next());
        System.out.println("好的，我知道了，开始游戏吧");
        u.setAttack(70);
        u.setBlood(300);
        u.setLv(36);
        u.setBlueDose(100);
        u.setRemainingBlood(300);
        u.setRemainingBlueDose(100);
        u.setEXP(50);
        Item i = new Item();
        selection(u, i);

    }

    //游戏背景
    public static void background() {
        Scanner sc = new Scanner(System.in);
        System.out.println("在远古时期，魔神入侵了这方世界，人们四方溃散。");
        System.out.println("魔神抓住人们献祭以获得强大的力量");
        System.out.println("就在人类快要毁灭之际，他们召唤了你出来，勇者。");
        System.out.println("你和魔王大战了两年半，最终将魔王封印了");
        System.out.println("不过你也受了重伤，最后等级变成了最初的等级");
        System.out.println("魔王在百年后将再次冲破封印，加油吧，勇士！");
        System.out.println("------------------------");
        System.out.println("游戏介绍：继续下面的剧情随机按键盘并回车");
        System.out.println("------------------------");
    }

    //用户选择
    public static void selection(User u, Item it) {
        Random r = new Random();
        String[] name = {"宝箱", "小怪", "精英怪", "前进"};
        int[] arr = new int[name.length];

        Scanner sc = new Scanner(System.in);
        while (true) {
            for (int i = 0; i < 4; i++) {
                int index1 = r.nextInt(200);
                if (index1 <= 10) {
                    arr[i] = 0;
                } else if (index1 <= 150) {
                    arr[i] = 1;
                } else if (index1 <= 160) {
                    arr[i] = 2;
                } else {
                    arr[i] = 3;
                }
            }
            System.out.println("------------------------------------------");
            System.out.println("1.向上--" + name[arr[0]]);
            System.out.println("2.向左--" + name[arr[1]]);
            System.out.println("3.向右--" + name[arr[2]]);
            System.out.println("4.向下--" + name[arr[3]]);
            System.out.println("5.查看属性面板");
            System.out.println("6.查看物品栏");
            System.out.println("7.退出游戏");
            System.out.println("请做出你的选择：");
            System.out.println("------------------------------------------");
            String number = sc.next();
            switch (number) {
                case "1":
                    switch (name[arr[0]]) {
                        case "宝箱" -> incident1(it);
                        case "小怪" -> incident2(it, u);
                        case "精英怪" -> incident3(it, u);
                        default -> System.out.println("什么也没有发生");
                    }
                    break;
                case "2":
                    switch (name[arr[1]]) {
                        case "宝箱" -> incident1(it);
                        case "小怪" -> incident2(it, u);
                        case "精英怪" -> incident3(it, u);
                        default -> System.out.println("什么也没有发生");
                    }
                    break;
                case "3":
                    switch (name[arr[2]]) {
                        case "宝箱" -> incident1(it);
                        case "小怪" -> incident2(it, u);
                        case "精英怪" -> incident3(it, u);
                        default -> System.out.println("什么也没有发生");
                    }
                    break;
                case "4":
                    switch (name[arr[3]]) {
                        case "宝箱" -> incident1(it);
                        case "小怪" -> incident2(it, u);
                        case "精英怪" -> incident3(it, u);
                        default -> System.out.println("什么也没有发生");
                    }
                    break;
                case "5":
                    charactersStats(u);
                    break;
                case "6":
                    inventoryPanel(it, u);
                    break;
                case "7":
                    System.exit(0);
                default:
                    System.out.println("输入错误，请重新输入！");
            }
        }
    }

    //查看个人属性栏
    public static void charactersStats(User u) {
        Scanner sc = new Scanner(System.in);
        System.out.println("--------角色属性面板------");
        System.out.print("*姓名：" + u.getName() + "\t\t");
        System.out.println("*攻击力：" + u.getAttack());
        System.out.print("*性别：" + u.getGender() + "\t\t");
        System.out.println("*等级：" + u.getLv());
        System.out.print("*血量：" + u.getBlood() + "\t\t");
        System.out.println("*剩余血量：" + u.getRemainingBlood() + "\t\t");
        System.out.print("*蓝量：" + u.getBlueDose() + "\t\t");
        System.out.println("*剩余蓝量：" + u.getRemainingBlueDose());
        System.out.print("*经验：" + u.getEXP() + "\t\t");
        System.out.println("*当前经验：" + u.getRemainingEXP());
        still(u);
        System.out.println();
        System.out.println("按1+回车键返回");
        sc.next();
    }

    //查看物品栏
    public static void inventoryPanel(Item i, User u) {
        int a = 0;
        System.out.println("-----------------------------物品栏--------------------------");
        System.out.print("1." + i.item1 + "：" + i.arr[0] + "\t\t\t");
        System.out.print("2." + i.item2 + "：" + i.arr[1] + "\t\t\t");
        System.out.println("3." + i.item3 + "：" + i.arr[2]);
        System.out.print("4." + i.item4 + "：" + i.arr[3] + "\t\t\t");
        System.out.print("5." + i.item5 + "：" + i.arr[4] + "\t\t\t");
        System.out.println("6." + i.item6 + "：" + i.arr[5]);
        System.out.print("7." + i.item7 + "：" + i.arr[6] + "\t\t\t\t");
        System.out.print("8." + i.item8 + "：" + i.arr[7] + "\t\t\t\t");
        System.out.println("9." + i.item9 + "：" + i.arr[8]);
        System.out.print("10." + i.item10 + "：" + i.arr[9] + "\t\t\t");
        System.out.print("11." + i.item11 + "：" + i.arr[10] + "\t\t\t");
        System.out.println("12." + i.item12 + "：" + i.arr[11]);
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("是否要使用物品（1/0）：");
            String number = sc.next();
            if (number.equals("1")) {
                System.out.println("请输入选择的药剂：");
                System.out.println("排序为1-12(横向排序)");
                String index = sc.next();
                switch (index) {
                    case "1":
                        if (i.arr[0] > 0) {
                            if (u.getRemainingBlood() + 30 > u.getBlood()) {
                                u.setRemainingBlood(u.getBlood());
                            } else {
                                a = u.getRemainingBlood();
                                u.setRemainingBlood(a + 30);
                            }
                            if (u.getRemainingBlueDose() + 20 > u.getBlueDose()) {
                                u.setRemainingBlood(u.getBlueDose());
                            } else {
                                a = u.getRemainingBlueDose();
                                u.setRemainingBlood(a + 20);
                            }
                            i.arr[0]--;
                            System.out.println(i.item1 + "使用成功");
                        } else {
                            System.out.println("数量不足");
                        }
                        break;
                    case "2":
                        if (i.arr[1] > 0) {
                            if (u.getRemainingBlood() + 50 > u.getBlood()) {
                                u.setRemainingBlood(u.getBlood());
                            } else {
                                a = u.getRemainingBlood();
                                u.setRemainingBlood(a + 50);
                            }
                            if (u.getRemainingBlueDose() + 40 > u.getBlueDose()) {
                                u.setRemainingBlood(u.getBlueDose());
                            } else {
                                a = u.getRemainingBlueDose();
                                u.setRemainingBlood(a + 40);
                            }
                            i.arr[1]--;
                            System.out.println(i.item2 + "使用成功");
                        } else {
                            System.out.println("数量不足");
                        }

                        break;
                    case "3":
                        if (i.arr[2] > 0) {
                            if (u.getRemainingBlood() + 100 > u.getBlood()) {
                                u.setRemainingBlood(u.getBlood());
                            } else {
                                a = u.getRemainingBlood();
                                u.setRemainingBlood(a + 100);
                            }
                            if (u.getRemainingBlueDose() + 80 > u.getBlueDose()) {
                                u.setRemainingBlood(u.getBlueDose());
                            } else {
                                a = u.getRemainingBlueDose();
                                u.setRemainingBlood(a + 80);
                            }
                            i.arr[2]--;
                            System.out.println(i.item3 + "使用成功");
                        } else {
                            System.out.println("数量不足");
                        }

                        break;
                    case "4":
                        if (i.arr[3] > 0) {
                            a = u.getRemainingEXP();
                            u.setRemainingEXP(a + 30);
                            upgrades(u);
                            i.arr[3]--;
                            System.out.println(i.item4 + "使用成功");
                        } else {
                            System.out.println("数量不足");
                        }
                        break;
                    case "5":
                        if (i.arr[4] > 0) {
                            a = u.getRemainingEXP();
                            u.setRemainingEXP(a + 60);
                            upgrades(u);
                            i.arr[4]--;
                            System.out.println(i.item5 + "使用成功");
                        } else {
                            System.out.println("数量不足");
                        }
                        break;
                    case "6":
                        if (i.arr[5] > 0) {
                            a = u.getRemainingEXP();
                            u.setRemainingEXP(a + 120);
                            upgrades(u);
                            i.arr[5]--;
                            System.out.println(i.item6 + "使用成功");
                        } else {
                            System.out.println("数量不足");
                        }
                        break;
                    case "7":
                        if (i.arr[6] > 0) {
                            if (u.getRemainingBlueDose() + 20 > u.getBlueDose()) {
                                u.setRemainingBlood(u.getBlueDose());
                            } else {
                                a = u.getRemainingBlueDose();
                                u.setRemainingBlood(a + 20);
                            }
                            i.arr[6]--;
                            System.out.println(i.item7 + "使用成功");
                        } else {
                            System.out.println("数量不足");
                        }
                        break;
                    case "8":
                        if (i.arr[7] > 0) {
                            if (u.getRemainingBlueDose() + 40 > u.getBlueDose()) {
                                u.setRemainingBlood(u.getBlueDose());
                            } else {
                                a = u.getRemainingBlueDose();
                                u.setRemainingBlood(a + 40);
                            }
                            i.arr[7]--;
                            System.out.println(i.item8 + "使用成功");
                        } else {
                            System.out.println("数量不足");
                        }
                        break;
                    case "9":
                        if (i.arr[8] > 0) {
                            if (u.getRemainingBlueDose() + 80 > u.getBlueDose()) {
                                u.setRemainingBlood(u.getBlueDose());
                            } else {
                                a = u.getRemainingBlueDose();
                                u.setRemainingBlood(a + 80);
                            }
                            i.arr[8]--;
                            System.out.println(i.item9 + "使用成功");
                        } else {
                            System.out.println("数量不足");
                        }
                        break;
                    case "10":
                        if (i.arr[9] > 0) {
                            if (u.getRemainingBlood() + 30 > u.getBlood()) {
                                u.setRemainingBlood(u.getBlood());
                            } else {
                                a = u.getRemainingBlood();
                                u.setRemainingBlood(a + 30);
                            }

                            i.arr[9]--;
                            System.out.println(i.item10 + "使用成功");
                        } else {
                            System.out.println("数量不足");
                        }
                        break;
                    case "11":
                        if (i.arr[10] > 0) {
                            if (u.getRemainingBlood() + 60 > u.getBlood()) {
                                u.setRemainingBlood(u.getBlood());
                            } else {
                                a = u.getRemainingBlood();
                                u.setRemainingBlood(a + 60);
                            }

                            i.arr[10]--;
                            System.out.println(i.item11 + "使用成功");
                        } else {
                            System.out.println("数量不足");
                        }
                        break;
                    case "12":
                        if (i.arr[11] > 0) {
                            if (u.getRemainingBlood() + 120 > u.getBlood()) {
                                u.setRemainingBlood(u.getBlood());
                            } else {
                                a = u.getRemainingBlood();
                                u.setRemainingBlood(a + 120);
                            }

                            i.arr[11]--;
                            System.out.println(i.item12 + "使用成功");
                        } else {
                            System.out.println("数量不足");
                        }
                        break;
                    default:
                        System.out.println("输入错误！");
                }
            } else if (number.equals("0")) {
                System.out.println("好的,未使用药剂");
                return;
            } else {
                System.out.println("输入错误！");
            }

        }
    }

    //判断经验能不能升级
    public static void upgrades(User u) {
        if (u.getRemainingEXP() > u.getEXP()) {
            int a = u.getRemainingEXP()-u.getEXP();
            u.setLv(u.getLv() + 1);
            u.setRemainingEXP(a);
            u.setEXP(u.getEXP() + 30);
            //血量提升并回满
            u.setBlood(u.getBlood() + 50);
            u.setRemainingBlood(u.getBlood());
            //蓝量提升并回满
            u.setBlueDose(u.getBlueDose() + 30);
            u.setRemainingBlueDose(u.getBlueDose());
        }
    }

    //宝箱收获
    public static void incident1(Item i) {
        Random r = new Random();
        int[] arr = new int[12];
        int index = r.nextInt(113) + 1;
        if (index <= 20) {
            i.arr[0]++;
            System.out.println("获得了小型回复水");
        } else if (index <= 40) {
            System.out.println("获得了小型经验丹");
            i.arr[3]++;
        } else if (index <= 60) {
            System.out.println("获得了小型蓝瓶");
            i.arr[6]++;
        } else if (index <= 80) {
            System.out.println("获得了小型血瓶");
            i.arr[9]++;
        } else if (index <= 85) {
            System.out.println("获得了中型回复水");
            i.arr[1]++;
        } else if (index <= 90) {
            System.out.println("获得了中型经验丹");
            i.arr[4]++;
        } else if (index <= 95) {
            System.out.println("获得了中型蓝瓶");
            i.arr[7]++;
        } else if (index <= 100) {
            System.out.println("获得了中型血瓶");
            i.arr[10]++;
        } else if (index <= 103) {
            System.out.println("获得了大瓶回复水");
            i.arr[2]++;
        } else if (index <= 106) {
            System.out.println("获得了大型经验丹");
            i.arr[5]++;
        } else if (index <= 109) {
            System.out.println("获得了大瓶蓝瓶");
            i.arr[8]++;
        } else if (index <= 112) {
            System.out.println("获得了大瓶血瓶");
            i.arr[11]++;
        }
        Scanner sc = new Scanner(System.in);
        System.out.println("按1+回车键继续");
        sc.next();
    }

    //小怪样子
    public static void monstrosity() {
        System.out.println("        _____\n");
        System.out.println("     ,-:` \\;',`'-, \n");
        System.out.println("  .'-;_,;  ':-;_,'.\n");
        System.out.println(" /;   '/    ,  _`.-\\\n");
        System.out.println("| '`. (`     /` ` ` '|\n");
        System.out.println("|:.  `\\`-.   \\_   `,'\n");
        System.out.println("`-.._)`\\__/  _.--\\   \\\n");
        System.out.println("        /`   /        (`\\\n");
        System.out.println("       /`,   \\         |\\\n");
        System.out.println("      / /     \\        ) )\n");
        System.out.println("     \\ \\      `._,-' / /\n");
        System.out.println("      `-/           `-'`\n");
        System.out.println("         \n");
    }

    //boss样子
    public static void bossAppearance() {
        System.out.println("           ___..-.---.-.___\n");
        System.out.println("    _..---` .---.-.   `   ``--.__\n");
        System.out.println("   .        `     `  }` ` _        `.\n");
        System.out.println("         ,_  /    ,_  .  -` `--.   \\\n");
        System.out.println("           `//     / /   `,    \\   .\n");
        System.out.println("    -..:::::::`-..`_\\ _-\\ /     \\   \\\n");
        System.out.println(" .-'::::::::::::::::``  /```\\/\\_   \\`. ))\n");
        System.out.println("/:::::;;::::;:;;:;:;` / /        `---`{}}}\n");
        System.out.println(" `-.._:::::/  /\\_/ / /   `.__,         ){}}}\n");
        System.out.println("      `'-::<`  <` <`-;\\      \\          ){}}/              _..._\n");
        System.out.println("               `\\   /`|      /   `\\     /{{{/   _       /    ,   \\\n");
        System.out.println("               `\\   /`|      /   `\\     /{{{/   _       /    ,     \\\n");
        System.out.println("                 `\\` `\\;\\__  /_ _ _`\\  /{{{/  _;M;_____/_   /    .\\`.\n");
        System.out.println("                   `\\        `      \\'`\"{{;*\"\"\"\"\"\"      `,._     \\M\n");
        System.out.println("                     `\\                                            `\n");
        System.out.println("                       `\\                                          ` \n");
    }

    //大怪的初始化
    public static Boss boss() {
        String[] name = {"移星古狼", "浮花乌鬼鹰", "大衍狐", "戮魔犰狳", "守神白参", "无色古鹌鹑",
                "九天鹈鹕", "移星鳄", "晶炎古蛤蟆", "绝天虫", "暗神鸬鹚", "化煞貔貅", "火仙蛟"};
        Random r = new Random();
        int index = r.nextInt(30) + 10;
        int number = r.nextInt(name.length);
        return new Boss(name[number], 400, index);
    }

    //小怪的初始化
    public static Monster_one monster() {
        String[] name = {"五阴蚕", "黑野草", "护魔猫", "心意熊", "乌玄蝾螈", "太始墨鱼",
                "灰野蛤", "雌雄豚", "灰灵蛇", "天雷鳄", "封魂灰树"};
        Random r = new Random();
        int index = r.nextInt(10) + 1;
        int number = r.nextInt(name.length);
        return new Monster_one(name[number], 200, index);
    }

    public static void incident2(Item i, User u) {
        Scanner sc = new Scanner(System.in);
        Random r = new Random();
        int index = r.nextInt(10) + 1;
        Monster_one m = monster();
        while (m.getBlood() > 0) {
            if (u.getRemainingBlood() > 0) {
                monstrosity();
                System.out.println("名字：" + m.getName() + "\t\t" +
                        "生命值：" + m.getBlood() + "\t\t" +
                        "攻击力：" + m.getAttack());
                System.out.println("你获得先手优势！");
                System.out.println("请做出你的选择：(1-4)");
                System.out.println("1.攻击");
                System.out.println("2.技能");
                System.out.println("3.物品");
                System.out.println("4.逃跑");
                String number = sc.next();
                switch (number) {
                    case "1":
                        System.out.println(m.getName() + "受到了" + u.getAttack() + "点伤害");
                        m.setBlood(m.getBlood() - u.getAttack());
                        break;
                    case "2":
                        if (u.getLv() < 5) {
                            System.out.println("您的等级没有开启技能，请继续努力！");
                        } else {
                            still(u);
                            System.out.println("请选择你使用的技能：(默认使用1技能)");
                            String skill = sc.next();
                            switch (skill) {
                                case "1":
                                    still(m, u, "洞虚气", 100, 8);
                                    break;
                                case "2":
                                    still(m, u, "花雨刀", 120, 9);
                                    break;
                                case "3":
                                    still(m, u, "弄雾劲", 140, 10);
                                    break;
                                case "4":
                                    still(m, u, "一元爪", 160, 11);
                                    break;
                                case "5":
                                    still(m, u, "九天劲", 180, 12);
                                    break;
                                case "6":
                                    still(m, u, "噬魂玄女六阳枪", 200, 13);
                                    break;
                            }
                        }
                        break;
                    case "3":
                        inventoryPanel(i, u);
                        break;
                    case "4":
                        return;
                }
                if (m.getBlood()<=0){
                    break;
                }
                String[] arr = {
                        m.getName() + "向前递出一拳，直击你的面门而来，造成了" + (m.getAttack() + index) + "点伤害",
                        m.getName() + "轰的一拳，往你身上砸去，造成了" + (m.getAttack() + index) + "点伤害",
                        m.getName() + "趁你不备，一脚向下扫出，造成了" + (m.getAttack() + index) + "点伤害",
                        m.getName() + "向前递出一拳，直击你的面门而来，造成了" + (m.getAttack() + index) + "点伤害",
                        m.getName() + "双手蓄力，一个巨大的拳罡向你袭来，造成了" + (m.getAttack() + index) + "点伤害",
                        m.getName() + "双手撑地，双腿狠狠的踢向你的胸口，造成了" + (m.getAttack() + index) + "点伤害",
                        m.getName() + "双拳袭来，直击你的面门而来，但是被你躲过，没有造成伤害",
                };
                int index1 = r.nextInt(10) + 1;
                int index2 = r.nextInt(arr.length);
                if (index1 <= 8) {
                    System.out.println(arr[index2]);
                    int attack = index + u.getAttack();
                    u.setRemainingBlood(u.getRemainingBlood() - attack);
                } else {
                    int monsterStill = r.nextInt(3) + 1;
                    if (monsterStill == 1) {
                        System.out.println(m.getName() + "使用了" + Monster_one.skill1
                                + "，造成了" + (20 + index1) + "点伤害");
                        u.setRemainingBlood(u.getRemainingBlood() - 20 + index1);
                    } else if (monsterStill == 2) {
                        System.out.println(m.getName() + "使用了" + Monster_one.skill1
                                + "，造成了" + (30 + index1) + "点伤害");
                        u.setRemainingBlood(u.getRemainingBlood() - 30 + index1);
                    } else {
                        System.out.println(m.getName() + "使用了" + Monster_one.skill1
                                + "，造成了" + (40 + index1) + "点伤害");
                        u.setRemainingBlood(u.getRemainingBlood() - 40 + index1);
                    }
                }
            } else {
                System.out.println("血量不足，无法挑战！");
            }
            System.out.println("按1+回车键继续");
            sc.next();
        }
        System.out.println("你杀死了"+m.getName());
        int a = r.nextInt(30)+30;
        System.out.println("经验值+"+a);
        upgrades(u);
        u.setRemainingEXP(u.getRemainingEXP()+a);
        incident1(i);
    }

    //boss
    public static void incident3(Item i, User u) {
        Scanner sc = new Scanner(System.in);
        Random r = new Random();
        int index = r.nextInt(10) + 1;
        Boss b = boss();
        while (b.getBlood() > 0) {
            if (u.getRemainingBlood() > 0) {
                bossAppearance();
                System.out.println("名字：" + b.getName() + "\t\t" +
                        "生命值：" + b.getBlood() + "\t\t" +
                        "攻击力：" + b.getAttack());
                System.out.println("你获得先手优势！");
                System.out.println("请做出你的选择：(1-4)");
                System.out.println("1.攻击");
                System.out.println("2.技能");
                System.out.println("3.物品");
                System.out.println("4.逃跑");
                String number = sc.next();
                switch (number) {
                    case "1":
                        System.out.println(b.getName() + "受到了" + u.getAttack() + "点伤害");
                        b.setBlood(b.getBlood() - u.getAttack());
                        break;
                    case "2":
                        if (u.getLv() < 5) {
                            System.out.println("您的等级没有开启技能，请继续努力！");
                        } else {
                            still(u);
                            System.out.println("请选择你使用的技能：(默认使用1技能)");
                            String skill = sc.next();
                            switch (skill) {
                                case "1":
                                    still(b, u, "洞虚气", 100, 8);
                                    break;
                                case "2":
                                    still(b, u, "花雨刀", 120, 9);
                                    break;
                                case "3":
                                    still(b, u, "弄雾劲", 140, 10);
                                    break;
                                case "4":
                                    still(b, u, "一元爪", 160, 11);
                                    break;
                                case "5":
                                    still(b, u, "九天劲", 180, 12);
                                    break;
                                case "6":
                                    still(b, u, "噬魂玄女六阳枪", 200, 13);
                                    break;
                                default:
                                    still(b, u, "洞虚气", 100, 8);
                            }
                        }
                        break;
                    case "3":
                        inventoryPanel(i, u);
                        break;
                    case "4":
                        return;
                }
                if (b.getBlood()<=0){
                    break;
                }
                String[] arr = {
                        b.getName() + "向前递出一拳，直击你的面门而来，造成了" + (b.getAttack() + index) + "点伤害",
                        b.getName() + "轰的一拳，往你身上砸去，造成了" + (b.getAttack() + index) + "点伤害",
                        b.getName() + "趁你不备，一脚向下扫出，造成了" + (b.getAttack() + index) + "点伤害",
                        b.getName() + "向前递出一拳，直击你的面门而来，造成了" + (b.getAttack() + index) + "点伤害",
                        b.getName() + "双手蓄力，一个巨大的拳罡向你袭来，造成了" + (b.getAttack() + index) + "点伤害",
                        b.getName() + "双手撑地，双腿狠狠的踢向你的胸口，造成了" + (b.getAttack() + index) + "点伤害",
                        b.getName() + "双拳袭来，直击你的面门而来，但是被你躲过，没有造成伤害",
                };
                int index1 = r.nextInt(10) + 1;
                int index2 = r.nextInt(arr.length);
                if (index1 <= 8) {
                    System.out.println(arr[index2]);
                    int attack = index + u.getAttack();
                    u.setRemainingBlood(u.getRemainingBlood() - attack);
                } else {
                    int monsterStill = r.nextInt(3) + 1;
                    if (monsterStill == 1) {
                        System.out.println(b.getName() + "使用了" + Boss.still1
                                + "，造成了" + (30 + index1) + "点伤害");
                        u.setRemainingBlood(u.getRemainingBlood() - 30 + index1);
                    } else if (monsterStill == 2) {
                        System.out.println(b.getName() + "使用了" + Boss.still2
                                + "，造成了" + (40 + index1) + "点伤害");
                        u.setRemainingBlood(u.getRemainingBlood() - 40 + index1);
                    } else {
                        System.out.println(b.getName() + "使用了" + Boss.still3
                                + "，造成了" + (50 + index1) + "点伤害");
                        u.setRemainingBlood(u.getRemainingBlood() - 50 + index1);
                    }
                }
                System.out.println("按1+回车键继续");
                sc.next();
            } else {
                System.out.println("血量不足，无法挑战！");
                return;
            }
        }
        System.out.println("你杀死了"+b.getName());
        int a = r.nextInt(40)+50;
        System.out.println("经验值+"+a);
        upgrades(u);
        u.setRemainingEXP(u.getRemainingEXP()+a);
        incident1(i);
    }

    //通过判断角色等级是否输出技能
    public static void still(User u) {
        if (u.getLv() >= 5 && u.getLv() < 10) {
            System.out.println("*技能1：" + User.still1 + ",造成100点伤害");
        } else if (u.getLv() >= 10 && u.getLv() < 15) {
            System.out.println("*技能1：" + User.still1 + ",造成100点伤害");
            System.out.println("*技能2：" + User.still2 + ",造成120点伤害");
        } else if (u.getLv() >= 15 && u.getLv() < 20) {
            System.out.println("*技能1：" + User.still1 + ",造成100点伤害");
            System.out.println("*技能2：" + User.still2 + ",造成120点伤害");
            System.out.println("*技能3：" + User.still3 + ",造成140点伤害");
        } else if (u.getLv() >= 20 && u.getLv() < 25) {
            System.out.println("*技能1：" + User.still1 + ",造成100点伤害");
            System.out.println("*技能2：" + User.still2 + ",造成120点伤害");
            System.out.println("*技能3：" + User.still3 + ",造成140点伤害");
            System.out.println("*技能4：" + User.still4 + ",造成160点伤害");
        } else if (u.getLv() >= 25 && u.getLv() < 30) {
            System.out.println("*技能1：" + User.still1 + ",造成100点伤害");
            System.out.println("*技能2：" + User.still2 + ",造成120点伤害");
            System.out.println("*技能3：" + User.still3 + ",造成140点伤害");
            System.out.println("*技能4：" + User.still4 + ",造成160点伤害");
            System.out.println("*技能5：" + User.still5 + ",造成180点伤害");
        } else if (u.getLv() >= 30) {
            System.out.println("*技能1：" + User.still1 + ",造成100点伤害");
            System.out.println("*技能2：" + User.still2 + ",造成120点伤害");
            System.out.println("*技能3：" + User.still3 + ",造成140点伤害");
            System.out.println("*技能4：" + User.still4 + ",造成160点伤害");
            System.out.println("*技能5：" + User.still5 + ",造成180点伤害");
            System.out.println("*技能6：" + User.still6 + ",造成200点伤害");
        }
    }

    //1-6个技能
    public static void still(Monster_one m, User u, String skillName, int heart, int blueDose) {
        System.out.println("你使用了" + skillName + "," + m.getName() +
                "受到了" + heart + "点伤害");
        u.setRemainingBlueDose(u.getRemainingBlueDose() - blueDose);
        m.setBlood(m.getBlood() - heart);
        System.out.println("你还剩余"+u.getRemainingBlueDose()+"点蓝量");
    }
    public static void still(Boss m, User u, String skillName, int heart, int blueDose) {
        System.out.println("你使用了" + skillName + "," + m.getName() +
                "受到了" + heart + "点伤害");
        u.setRemainingBlueDose(u.getRemainingBlueDose() - blueDose);
        m.setBlood(m.getBlood() - heart);
    }
}

四、缺点和改进

        1.代码有很多地方可以简化，但是本人实力不够，还请见谅

        2.代码中我发现了一个小bug，不知道大家课发现吗，如果大家刚兴趣，踢我一下，我改好再发出来

        3.很多的问题我可能没有注意到，希望大家指正

        4.还没有学习怎么存档，所以叉掉就没有了

五、游戏运行视频

        

Java基于类与对象完成的一个小游戏