精华内容
下载资源
问答
  • 二、解析 1. 硬件层的并发优化基础知识 存储器... 以及最后为大家准备的福利时间:简历模板+Java面试题+热门技术系列教程视频 戳这里免费领取文中资料 1624179637295)] [外链图片转存中…(img-hrQKxEmZ-1624179637296)]

    二、解析

    1. 硬件层的并发优化基础知识

    存储器的层次结构图如下:

    各级缓存耗时对比:

    采用分层缓存的层次结构会带来数据不一致问题,如下图:

    那么如何保证数据的一致性,现代CPU处理办法有两种:

    (1) 锁系统总线;

    (2) 利用缓存一致性协议MESI(Intel处理器用的比较多,还有很多其他的缓存一致性协议),大致结构如下图:

    2. CPU的乱序执行

    CPU中有个乱序执行的概念,概念图如下:

    CPU在执行指令的时候,往往不是顺序执行,但是会遵守as-if-serial原则,也就是最终一致性原则。CPU为了提高指令执行效率,会在一条指令执行过程中(比如去内存读数据),去同时执行另一条指令,前提是这两条指令没有依赖关系。虽然指令执行顺序发生改变,但是不会影响单线程执行结果。多线程情况下为了不让CUP进行指令重排序,则需要用到Volatile关键字,因为Volatile的重要作用之一就是防止指令重排序。

    CPU还会存在合并写的现象。当第一条指令往上级缓存写入数据时,由于上级缓存访问速度比较慢,可能第二条指令又对上一条指令的结果进行了修改,那么CPU将这两条指令合并的最终结果一次性的写入到缓存中,这就成为合并写。

    3. 如何保证不乱序执行

    (1) 内存屏障:java采用的是内存屏障,内存屏障其实就是一个CPU指令,在硬件层面上来说可以扥为两种:Load Barrier 和 Store Barrier即读屏障和写屏障。主要有两个作用:

    a. 阻止屏障两侧的指令重排序;

    b. 强制把写缓冲区/高速缓存中的脏数据等写回主内存,让缓存中相应的数据失效。

    总结

    至此,文章终于到了尾声。总结一下,我们谈论了简历制作过程中需要注意的以下三个部分,并分别给出了一些建议:

    1. 技术能力:先写岗位所需能力,再写加分能力,不要写无关能力;
    2. 项目经历:只写明星项目,描述遵循 STAR 法则;
    3. 简历印象:简历遵循三大原则:清晰,简短,必要,要有的放矢,不要海投;

    以及最后为大家准备的福利时间:简历模板+Java面试题+热门技术系列教程视频
    戳这里免费领取文中资料

    在这里插入图片描述

    在这里插入图片描述

    在这里插入图片描述

    1624179637295)]

    [外链图片转存中…(img-hrQKxEmZ-1624179637296)]

    展开全文
  • Java打怪游戏

    万次阅读 多人点赞 2017-09-06 22:01:42
    Java文字小游戏 人类杀死怪物后会获得经验升级,升级会回复血量,提高攻击力. 怪物分为四个类型: 超级丧尸/变异丧尸/普通丧尸/吸血鬼. 不同类别的怪物具有不同的攻击力,防御力,躲避以及特殊属性等等.

    Java文字小游戏

    怪物分为四个类型:
    超级丧尸/变异丧尸/普通丧尸/吸血鬼.
    不同类别的怪物具有不同的攻击力,防御力,躲避以及特殊属性等等.
    人类杀死僵尸后会获得经验升级,升级会回复血量,提高攻击力.
    下面是运行截图
    运行截图

    运行截图
    下面是代码

    game.java

    public class game {
        public static void main(String[] args){
            new GameStart().start();
        }
    }

    GameStart.java

    package one;
    
    public class GameStart {
        Hunter hunter;
        Monster m1,m2,m3,m4,m5;
    
        public GameStart(){
            hunter = new Hunter("小何佩","大冰棒");
            m1 = new Monster(3);
            m2 = new Monster(3);
            m3 = new Monster(3);
            m4 = new Monster(2);
            m5 = new Monster(4);
        }
        public void start(){
    
            while(hunter.isLive && (m1.isLive || m2.isLive || m3.isLive || m4.isLive || m5.isLive)){
                System.out.println("------------------对手寻找中---------------------"); 
                /**让程序休息3秒钟**/
                try{
                    Thread.sleep(3000);         
                    }
                catch(Exception e)
                {}  
                int ran = GameUtil.randomaRange(1,6);     // 产生随机数,随机寻找僵尸进行战斗
                switch(ran){
                case 1: hunter.fight(m1);   break;
                case 2: hunter.fight(m2);   break;
                case 3: hunter.fight(m3);   break;
                case 4: hunter.fight(m4);   break;
                case 5: hunter.fight(m5);   break;
                default:System.out.println("拜托啊!你要找个正常一点的战斗");     break;   //rand到不存在的僵尸; 
                }
            }
            end();
        }
        public void end(){
            if(hunter.isLive == true){
                System.out.println("来自李俊标的祝贺,恭喜你!过关啦");
            }else{
                System.out.println("哈哈哈哈哈哈,被僵尸打死了吧");
            }
        }
    }

    GameUtil.java

    package one;
    
    public class GameUtil {
        public static int randomaRange(int start,int end){
            return (int)(Math.random()*(end-start)+start);
        }
        public static boolean hidden(int agile,int hideRate){
            int sucRate = agile*hideRate/100;
            int ran = GameUtil.randomaRange(1,101);
            if(ran<sucRate){
                return true;
            }
            return false;
        }
        static int lostBasicLife = 10;
        public static int calLostLife(int attack,int defend){
            int lostLife = attack-defend;
            int rel = 0;
            if(lostLife<=0){
                rel = lostBasicLife;
            }else{
                rel = (lostLife+lostBasicLife);
            }
            return rel;
        }
    }

    Hunter.java

    package one;
    
    public class Hunter {   //爱丽丝
        String name;
        int maxLife;
        int curLife;
        boolean isLive;
        String weapon;
        int attack;         //攻击力
        int defend;         //防御力
        int level;
        int exp;
        int agile;
        int hideRate;
    
        public Hunter(String name,String weapon){
            this.name = name;
            this.weapon = weapon;
            maxLife = 100;
            curLife = maxLife;
            isLive = true;
            attack = 25;
            defend = 8;
            level = 1;
            exp = 0;
            agile = 35;
            hideRate = 60;
        }
        public void fight(Monster monster){     //战斗
            if(monster.isLive){
            if(isLive){
            System.out.println("--------->"+name+"无情的拿起"+weapon+"杀向"+monster.type+"<----------------");
            monster.injured(this);
            }else{
                System.out.println("--------->"+"我们的主角"+name+"已经牺牲了"+"<----------------");
            }
            }else
            {
                System.out.println("拜托啊!这个丧尸已经被你打死啦!");
            }
        }
    
        public void injured(Monster monster){   //掉血
            //增加躲避的判断
            if(monster.type == "吸血鬼"){
                if(GameUtil.hidden(this.agile,this.hideRate)){
                    System.out.println("--------"+name+":小样,打不到我");
                    show();
                    fight(monster);
                    return;
                }
                System.out.println("--------->"+name+":疼死了,打死你个龟孙"+"<---------");
                int lostLife = GameUtil.calLostLife(monster.attack, this.defend);
                curLife-=lostLife;
                if(curLife<0){
                    curLife=0;
                    died();
                    return;
                }
                monster.curLife+=this.curLife/10;
                show();
                fight(monster);
            }else{
            if(GameUtil.hidden(this.agile,this.hideRate)){
                System.out.println("--------"+name+":小样,打不到我");
                show();
                fight(monster);
                return;
            }
            System.out.println("--------->"+name+":疼死了,打死你个龟孙"+"<---------");
            int lostLife = GameUtil.calLostLife(monster.attack, this.defend);
            curLife-=lostLife;
            if(curLife<0){
                curLife=0;
                died();
                return;
            }
            show();
            fight(monster);
            }
        }
        public void expAdd(Monster monster){
            this.exp+=monster.maxLife;
            int needExp = 0;
            for(int i=1;i<=level;i++){
                needExp+=i*50;
            }
            if(exp>=needExp){
                upgrade();
            }
    
        }
        public void upgrade(){
            attack+=4;
            defend+=3;
            maxLife+=20;
            curLife+=maxLife;
            level++;
            System.out.println("--------------------------分割线-------------------------");
            System.out.println("系统提示:升级啦,目前等级"+level+"血量"+curLife+"攻击力"+attack+"防御力"+defend);
        }
        public void died(){
            System.out.println("**********"+name+"被丧尸咬死了"+"**********");
            isLive = false;
            show();
        }
        public void show(){
            System.out.println("---------->"+name+"  "+"生命值:"+curLife+"  "+
        "生命状态"+isLive+"   "+"等级"+level+"   "
        +"<-------------");
        }
    
    }

    Monster.java

    package one;
    
    public class Monster{
            int curLife;
            int maxLife;
            String type;
            boolean isLive = true;
            int attack;         //攻击力
            int defend;         //防御力
            int agile;          //敏捷
            int hideRate;       //躲避率
            public Monster(int mt){
                switch(mt){
                case 1: type = "超级丧尸";maxLife = 80; curLife = 80;   attack = 25;defend = 15;    agile = 30;hideRate = 80;   break;
                case 2: type = "变异丧尸";maxLife = 80; curLife = 60;   attack = 28;defend = 10;    agile = 40;hideRate = 70;   break;
                case 3: type = "普通丧尸";maxLife = 80; curLife = 40;   attack = 10;defend = 5;     agile = 30;hideRate = 60;   break;
                case 4: type = "吸血鬼"; maxLife = 80; curLife = 60; attack = 20; defend = 8; agile = 30;hideRate = 60;
                }
            }
    
            public void injured(Hunter hunter){   //掉血
                //增加躲避的判断
                if(GameUtil.hidden(this.agile,this.hideRate)){
                    System.out.println("*********"+type+":lueluelue,砍不到我");
                    show();
                    kill(hunter);
                    return;
                }
                System.out.println("**********"+type+"又被砍了一刀"+"***********");
                int lostLife = GameUtil.calLostLife(hunter.attack, this.defend);
                curLife-=lostLife;
                if(curLife<0){
                    curLife=0;
                    died(hunter);
                    return;
                }
                show();
                kill(hunter);
            }
            public void died(Hunter hunter){
                this.isLive = false;
                System.out.println("**********"+type+"被砍的四分五裂了"+"**********"+isLive);
                hunter.expAdd(this);    //this
            }
            public void kill(Hunter hunter){
                if(isLive){
                System.out.println("**********>"+type+"冲上去咬了"+hunter.name+"一大口"+"***********");
                hunter.injured(this);
                }else{
                    System.out.println("**********"+type+"已经被砍的四分五裂了"+"**********");
                }
            }
            public void show(){
                System.out.println("**********"+type+"  "+"生命值"+curLife+"  "+"生命状态"+isLive+"***************");
            }
        }
    
    展开全文
  • Java控制台游戏~600行代码实现打怪游戏(多图预警) 一,先放个启动界面(一些英雄,怪物技能介绍跟装备属性都写在里边): 二,在这个简单的小游戏里,你可以体验到: 1.打怪:2.随机玩法寻宝: 3.英雄/Boos怪物/...

    Java控制台游戏~600行代码实现打怪小游戏(多图预警)

    一,先放个启动界面(一些英雄,怪物技能介绍跟装备属性都写在里边):
    在这里插入图片描述在这里插入图片描述

    二,在这个简单的小游戏里,你可以体验到:

    1.打怪:

    在这里插入图片描述

    2.随机玩法寻宝:
    在这里插入图片描述在这里插入图片描述
    3.英雄/Boos怪物/装备技能:
    在这里插入图片描述
    在这里插入图片描述在这里插入图片描述and其他
    三,实现过程:
    1.创建Hero类定义英雄属性

    String name;//名称
        int hp;//生命值
        int MaxHp;//最大生命值
        int attackNum;//攻击力
        int skillType;//技能标号
        String skill;//技能描述
        int skillTimes;//技能可用次数
        boolean enable;//是否可用
        boolean Luckly;//幸运属性(曹操专属)
        String skillName;//技能名
        int weaponSkill;//武器技能标号(寒冰剑专属)
        boolean zqUsed;//再起是否可用(孟获专属)
    

    2.创建Monster类定义怪物属性:

    String name;//名称
        int hp;//生命值
        int MaxHp;//最大生命值
        int attackNum;//攻击力
        int skillType;//技能标号
        String skill;//技能描述
        String skillName;//技能名
        int skillTimes;//技能可用次数
        boolean sfUsed;//神愤是否可用(神鬼无双吕布专属)
    

    3,创建Weapon类定义装备属性:

    String name;//名称
        int damage;//伤害
        int addHp;//血量增值
        int addVihp;//村庄血量增值
        String skill;//技能描述
        String skillName;//技能名
        int skillType;//技能标号
    

    4,创建Village类定义村庄属性:

    int hp;
    

    5,Hero类,Monster类,Weapon类分别实现相关攻击和技能方法

    //英雄攻击方法
        public void attack(int hattackNum, Monster mo, Hero he, Weapon[] arrWeapon, Village vi, Monster[] arrMonster){
            Scanner sc = new Scanner(System.in);
            Random r = new Random();
            if (he.weaponSkill!=0){//不为默认值0则说明该英雄被拥有技能的武器赋过值(weaponType),则执行该武器技能(weaponSkill);
                switch (he.weaponSkill){
                    case 1:
                        System.out.println("您是否发动"+arrWeapon[4].name+"技能【"+arrWeapon[4].skill+"】?(键入“Q”发动技能,或按回车取消)");
                        String w = sc.nextLine();
                        int addVhp;
                        if ("Q".equals(w) || "q".equals(w)) {//执行技能
                            if ((attackNum/2)>50){
                                addVhp=50;
                            }else {
                                addVhp=(attackNum/2);
                            }
                            vi.hp=vi.hp+addVhp;
                            System.out.println("您取消了伤害并为村庄回复"+(he.Luckly==false? addVhp:addVhp/2)+"点生命值");//判断是否触发曹操技能
                            System.out.println("!!!现在村庄的生命值是"+vi.hp);
                        } else {
                            mo.hp = mo.hp - hattackNum;
                            System.out.println(mo.name + "受到" + hattackNum + "点伤害,血量为" + mo.hp + "...");
                            if (mo.skillType==1){//神吕布技能时机
                                mo.skills(mo, arrMonster);
                                int damage = r.nextInt(51);
                                he.hp=he.hp-damage;
                                System.out.println(he.name + "受到" + damage + "点伤害,血量为" + he.hp + "...");
                            }
                        }
                }
            }else {
                mo.hp = mo.hp - hattackNum;
                System.out.println(mo.name + "受到" + hattackNum + "点伤害,血量为" + mo.hp + "...");
                if (mo.skillType==1){//神吕布技能时机
                    mo.skills(mo, arrMonster);
                    int damage = r.nextInt(51);
                    he.hp=he.hp-damage;
                    System.out.println(he.name + "受到" + damage + "点伤害,血量为" + he.hp + "...");
                }
            }
        }
    
        //英雄技能方法
        public void skills(Hero he,Monster mo){
            switch (skillType){
                case 1:
                    System.out.println(he.name+"发动了技能"+he.skillName);
                    System.out.println(he.skill);
                    int AddAttack=((mo.MaxHp-mo.hp)/100)*50;
                    mo.hp=mo.hp-(AddAttack+300);
                    System.out.println(mo.name+"受到"+(AddAttack+300)+"点伤害,血量为"+mo.hp+"...");
                    he.skillTimes=0;//技能次数用尽
                    break;
                case 2:
                    System.out.println(he.name+"发动了技能"+he.skillName);
                    System.out.println(he.skill);
                    int Attack= (int)((he.MaxHp)*0.4);
                    mo.hp=mo.hp-Attack;
                    he.hp=he.hp-(Attack/2);
                    System.out.println("黄忠扣除了"+(Attack/2)+"点生命值,血量为"+he.hp+"...");
                    System.out.println(mo.name+"受到"+Attack+"点伤害,血量为"+mo.hp+"...");
                    he.skillTimes--;//技能次数减一
                    break;
                case 3:
                    System.out.println(he.name+"发动了技能"+he.skillName);
                    System.out.println(he.skill);
                    break;
                case 4:
                    System.out.println(he.name+"发动了技能"+he.skillName);
                    System.out.println(he.skill);
                    he.hp=500;
                    he.attackNum=120;
                    he.zqUsed=false;//再起技能用尽
                    break;
            }
    

    6,定义Play类写入循环实现回合制

    int num = 1;//回合数
            while(true) {
                if (mo.hp<=0&&mo.sfUsed==false) {
                    System.out.println("您的英雄" + he.name + "战胜了怪物,成功守卫村庄!!!");
                    isWin = true;
                    break;
                }else if (mo.hp<=0&&mo.sfUsed==true){//神愤技能时机
                    mo.skills(mo, arrMonster);
                    System.out.println("您的对手"+mo.name+"已替换成"+arrMonster[2].name);
                    mo.sfUsed=false;
                    mo=arrMonster[2];
                }
                if(vi.hp<=0||he.hp<=0){
                    break;
                }else{
                    if (he.hp > 0 && vi.hp > 0||he.zqUsed==true) {
                        System.out.println("*******************************************************************************");
                        System.out.println("第" + num + "回合");
    

    7,循环体内调用相关攻击,技能方法

    public void skills(Hero he,Monster mo){
            switch (skillType){
                case 1:
                    System.out.println(he.name+"发动了技能"+he.skillName);
                    System.out.println(he.skill);
                    int AddAttack=((mo.MaxHp-mo.hp)/100)*50;
                    mo.hp=mo.hp-(AddAttack+300);
                    System.out.println(mo.name+"受到"+(AddAttack+300)+"点伤害,血量为"+mo.hp+"...");
                    he.skillTimes=0;//技能次数用尽
                    break;
                case 2:
                    System.out.println(he.name+"发动了技能"+he.skillName);
                    System.out.println(he.skill);
                    int Attack= (int)((he.MaxHp)*0.4);
                    mo.hp=mo.hp-Attack;
                    he.hp=he.hp-(Attack/2);
                    System.out.println("黄忠扣除了"+(Attack/2)+"点生命值,血量为"+he.hp+"...");
                    System.out.println(mo.name+"受到"+Attack+"点伤害,血量为"+mo.hp+"...");
                    he.skillTimes--;//技能次数减一
                    break;
                case 3:
                    System.out.println(he.name+"发动了技能"+he.skillName);
                    System.out.println(he.skill);
                    break;
                case 4:
                    System.out.println(he.name+"发动了技能"+he.skillName);
                    System.out.println(he.skill);
                    he.hp=500;
                    he.attackNum=120;
                    he.zqUsed=false;//再起技能用尽
                    break;
            }
    

    8,利用生成随机数制作搜寻宝物随机事件

    Random ra = new Random();
    int ran1 = ra.nextInt(x);//生成0~x(不包含x)的随机数
    

    9,循环嵌套中写入各种技能时机

     he.weaponSkill=we.skillType;//为英雄装备技能赋初值,这个值会在Hero类attack方法被调用时,先判断改英雄是否拥有we.skillType这个值,以便确定是否拥有武器寒冰剑及其技能
    System.out.println("&&您的英雄搜寻到了武器" + we.name + "攻击力加"+ (he.Luckly==false?/*判断是否为英雄曹操,若是则增益减半*/ we.damage:we.damage/2)+ "!");
    he.attackNum = he.attackNum + (he.Luckly==false? we.damage:we.damage/2);
    System.out.println("现在"+he.name+"的攻击力是"+he.attackNum);
    

    10,编写启动界面,英雄,怪物,装备列表,使用数组保存参数

    Monster mo3 = new Monster();
            arrMonster[3]=mo3;
            mo3.hp=2000;
            mo3.MaxHp=mo3.hp;
            mo3.name="【Boos】神吕布";
            mo3.attackNum=60;
            mo3.skillName="神愤";//技能名
            mo3.skillType=1;
            mo3.sfUsed=true;
            mo3.skill="【神愤:神吕布每次受到攻击,会对英雄反弹0~50点随机伤害;当神吕布战死,游戏不会结束,他会替换成吕布继续战斗!】";
    
    Hero he4=new Hero();
            arrHero[4]=he4;
            he4.hp=200;
            he4.MaxHp=he4.hp;
            he4.name ="孟获";
            he4.attackNum=30;
            he4.enable=true;
            he4.skillName="再起";
            he4.skillType=4;
            he4.zqUsed=true;
            he4.skill="【再起:(限定技)当孟获处于濒死阶段,令其恢复生命值至500,调整攻击力为120;之后的每个英雄的结束阶段,孟获流失70点生命值】";
    
    Hero he3=new Hero();
            arrHero[3]=he3;
            he3.hp=400;
            he3.MaxHp=he3.hp;
            he3.name ="曹操";
            he3.attackNum=30;
            he3.enable=true;
            he3.skillName="奸雄";
            he3.skillType=3;
            he3.skillTimes=0;
            he3.Luckly=true;
            he3.skill="【奸雄:(被动技)曹操搜寻到物品的概率提升为100%,但受到宝物的增益效果减半】";
    
    Weapon we5 = new Weapon();
            arrWeapon[4]=we5;
            we5.name = "寒冰剑";
            we5.damage = 10;  //  5/33
            we5.skillName="寒冰";
            we5.skill="当您的英雄造成伤害后,您可以取消该伤害,改为为村庄回复基于该伤害50%的生命值";
            we5.skillType=1;
    

    11,修饰完善

    四,效果预览
    在这里插入图片描述
    没打过…(这个Boss得开个小挂,调一下参数才好打…)

    五,代码
    1.Hero类:

    package com.bai.demo05;
    
    import java.util.Random;
    import java.util.Scanner;
    
    public class Hero {
        String name;//名称
        int hp;//生命值
        int MaxHp;//最大生命值
        int attackNum;//攻击力
        int skillType;//技能标号
        String skill;//技能描述
        int skillTimes;//技能可用次数
        boolean enable;//是否可用
        boolean Luckly;//幸运属性(曹操专属)
        String skillName;//技能名
        int weaponSkill;//武器技能标号(寒冰剑专属)
        boolean zqUsed;//再起是否可用(孟获专属)
    
    
    
        //英雄攻击方法
        public void attack(int hattackNum, Monster mo, Hero he, Weapon[] arrWeapon, Village vi, Monster[] arrMonster){
            Scanner sc = new Scanner(System.in);
            Random r = new Random();
            if (he.weaponSkill!=0){//不为默认值0则说明该英雄被拥有技能的武器赋过值(weaponType),则执行该武器技能(weaponSkill);
                switch (he.weaponSkill){
                    case 1:
                        System.out.println("您是否发动"+arrWeapon[4].name+"技能【"+arrWeapon[4].skill+"】?(键入“Q”发动技能,或按回车取消)");
                        String w = sc.nextLine();
                        int addVhp;
                        if ("Q".equals(w) || "q".equals(w)) {//执行技能
                            if ((attackNum/2)>50){
                                addVhp=50;
                            }else {
                                addVhp=(attackNum/2);
                            }
                            vi.hp=vi.hp+addVhp;
                            System.out.println("您取消了伤害并为村庄回复"+(he.Luckly==false? addVhp:addVhp/2)+"点生命值");//判断是否触发曹操技能
                            System.out.println("!!!现在村庄的生命值是"+vi.hp);
                        } else {
                            mo.hp = mo.hp - hattackNum;
                            System.out.println(mo.name + "受到" + hattackNum + "点伤害,血量为" + mo.hp + "...");
                            if (mo.skillType==1){//神吕布技能时机
                                mo.skills(mo, arrMonster);
                                int damage = r.nextInt(51);
                                he.hp=he.hp-damage;
                                System.out.println(he.name + "受到" + damage + "点伤害,血量为" + he.hp + "...");
                            }
                        }
                }
            }else {
                mo.hp = mo.hp - hattackNum;
                System.out.println(mo.name + "受到" + hattackNum + "点伤害,血量为" + mo.hp + "...");
                if (mo.skillType==1){//神吕布技能时机
                    mo.skills(mo, arrMonster);
                    int damage = r.nextInt(51);
                    he.hp=he.hp-damage;
                    System.out.println(he.name + "受到" + damage + "点伤害,血量为" + he.hp + "...");
                }
            }
        }
    
        //英雄技能方法
        public void skills(Hero he,Monster mo){
            switch (skillType){
                case 1:
                    System.out.println(he.name+"发动了技能"+he.skillName);
                    System.out.println(he.skill);
                    int AddAttack=((mo.MaxHp-mo.hp)/100)*50;
                    mo.hp=mo.hp-(AddAttack+300);
                    System.out.println(mo.name+"受到"+(AddAttack+300)+"点伤害,血量为"+mo.hp+"...");
                    he.skillTimes=0;//技能次数用尽
                    break;
                case 2:
                    System.out.println(he.name+"发动了技能"+he.skillName);
                    System.out.println(he.skill);
                    int Attack= (int)((he.MaxHp)*0.4);
                    mo.hp=mo.hp-Attack;
                    he.hp=he.hp-(Attack/2);
                    System.out.println("黄忠扣除了"+(Attack/2)+"点生命值,血量为"+he.hp+"...");
                    System.out.println(mo.name+"受到"+Attack+"点伤害,血量为"+mo.hp+"...");
                    he.skillTimes--;//技能次数减一
                    break;
                case 3:
                    System.out.println(he.name+"发动了技能"+he.skillName);
                    System.out.println(he.skill);
                    break;
                case 4:
                    System.out.println(he.name+"发动了技能"+he.skillName);
                    System.out.println(he.skill);
                    he.hp=500;
                    he.attackNum=120;
                    he.zqUsed=false;//再起技能用尽
                    break;
            }
        }
    }
    
    

    2.HeroMonsterAndWeapon类:

    package com.bai.demo05;
    import java.util.Scanner;
    public class HeroMonsterAndWeapon {
        public  void HAndM() {
            Hero[] arrHero=new Hero[10]; Monster[] arrMonster=new Monster[10]; Weapon[] arrWeapon=new Weapon[10];
            //英雄
            Hero he0 = new Hero();
            arrHero[0]=he0;
            he0.hp = 10000;
            he0.MaxHp=he0.hp;
            he0.name = "测试";
            he0.attackNum=70;
            he0.enable=true;
            he0.skillName="null";
            he0.skillType=0;
            he0.skillTimes=0;
            he0.skill="【测试技能为空】";//用于测试,不参与选择列表
    
            Hero he1 = new Hero();
            arrHero[1]=he1;
            he1.hp = 1500;
            he1.MaxHp=he1.hp;
            he1.name = "甘宁";
            he1.attackNum=70;
            he1.enable=true;
            he1.skillName="奇袭";
            he1.skillType=1;
            he1.skillTimes=1;
            he1.skill="【奇袭:(限定技)甘宁发出蓄力一击,扣除怪物300点生命值,怪物已损失生命值每超过100,这个伤害将追加50】";
    
            Hero he2=new Hero();
            arrHero[2]=he2;
            he2.hp=500;
            he2.MaxHp=he2.hp;
            he2.name ="黄盖";
            he2.attackNum=40;
            he2.enable=true;
            he2.skillName="苦肉";
            he2.skillType=2;
            he2.skillTimes=3;
            he2.skill="【苦肉:扣除自身最大生命值的20%,对怪物造成双倍于这个数值的伤害!】";
    
            Hero he3=new Hero();
            arrHero[3]=he3;
            he3.hp=400;
            he3.MaxHp=he3.hp;
            he3.name ="曹操";
            he3.attackNum=30;
            he3.enable=true;
            he3.skillName="奸雄";
            he3.skillType=3;
            he3.skillTimes=0;
            he3.Luckly=true;
            he3.skill="【奸雄:(被动技)曹操搜寻到物品的概率提升为100%,但受到宝物的增益效果减半】";
    
            Hero he4=new Hero();
            arrHero[4]=he4;
            he4.hp=200;
            he4.MaxHp=he4.hp;
            he4.name ="孟获";
            he4.attackNum=30;
            he4.enable=true;
            he4.skillName="再起";
            he4.skillType=4;
            he4.zqUsed=true;
            he4.skill="【再起:(限定技)当孟获处于濒死阶段,令其恢复生命值至500,调整攻击力为120;之后的每个英雄的结束阶段,孟获流失70点生命值】";
    
            //怪物
            Monster mo0 = new Monster();
            arrMonster[0]=mo0;
            mo0.hp = 10000;
            mo0.MaxHp=mo0.hp;
            mo0.name = "无名小卒";
            mo0.attackNum = 1;//用于测试,不参与选择列表
    
            Monster mo1 = new Monster();
            arrMonster[1]=mo1;
            mo1.hp = 1500;
            mo1.MaxHp=mo1.hp;
            mo1.name = "沙摩柯";
            mo1.attackNum = 30;
    
            Monster mo2 = new Monster();
            arrMonster[2]=mo2;
            mo2.hp=1200;
            mo2.MaxHp=mo2.hp;
            mo2.name="吕布";
            mo2.attackNum=40;
    
            Monster mo3 = new Monster();
            arrMonster[3]=mo3;
            mo3.hp=2000;
            mo3.MaxHp=mo3.hp;
            mo3.name="【Boos】神吕布";
            mo3.attackNum=60;
            mo3.skillName="神愤";//技能名
            mo3.skillType=1;
            mo3.sfUsed=true;
            mo3.skill="【神愤:神吕布每次受到攻击,会对英雄反弹0~50点随机伤害;当神吕布战死,游戏不会结束,他会替换成吕布继续战斗!】";
    
            //村庄
            Village vi = new Village();
            vi.hp = 1000;
    
            //宝物
            Weapon we1 = new Weapon();
            arrWeapon[0]=we1;
            we1.name = "麒麟弓";
            we1.damage = 30;  //  15/33
    
            Weapon we2 = new Weapon();
            arrWeapon[1]=we2;
            we2.name="白银狮子";
            we2.addHp=200;  //  5/33
    
            Weapon we3 = new Weapon();
            arrWeapon[2]=we3;
            we3.name="折戟";
            we3.damage=10;  //  3/33
    
            Weapon we4 = new Weapon();
            arrWeapon[3]=we4;
            we4.name="家园守卫";
            we4.addVihp=200;  //  5/33
    
            Weapon we5 = new Weapon();
            arrWeapon[4]=we5;
            we5.name = "寒冰剑";
            we5.damage = 10;  //  5/33
            we5.skillName="寒冰";
            we5.skill="当您的英雄造成伤害后,您可以取消该伤害,改为为村庄回复基于该伤害50%的生命值";
            we5.skillType=1;
    
    
    
            SelsctHAndM se = new SelsctHAndM();
            se.select(arrHero,arrMonster,arrWeapon,vi);
            //se.select(he1,he2,he3,he4,mo0,mo1,mo2,mo3,vi,we1,we2,we3,we4);
        }
    }
    
    

    3.Monster类:

    package com.bai.demo05;
    
    public class Monster {
        String name;//名称
        int hp;//生命值
        int MaxHp;//最大生命值
        int attackNum;//攻击力
        int skillType;//技能标号
        String skill;//技能描述
        String skillName;//技能名
        int skillTimes;//技能可用次数
        boolean sfUsed;//神愤是否可用(神鬼无双吕布专属)
    
        public void attack(int mattackNum,Hero he){
            int damage=mattackNum;//伤害值=初始伤害
            he.hp=he.hp-damage;
            System.out.println("^你的英雄"+he.name+"受到"+damage+"点伤害,血量为"+he.hp+"...");
        }
    
        public void destory(int mattackNum,Village vi){
            int damage=mattackNum*2;//对村庄造成双倍伤害
            vi.hp=vi.hp-damage;
            System.out.println("^村庄受到"+damage+"点伤害,血量为"+vi.hp+"...");
        }
    
        public void skills(Monster mo,Monster[] arrMonster){
            switch (skillType) {
                case 1://神吕布技能
                System.out.println(mo.name + "发动了技能" + mo.skillName);
                System.out.println(mo.skill);
                break;
    
            }
        }
    }
    
    

    4.Play类:

    package com.bai.demo05;
    
    import java.util.Random;
    import java.util.Scanner;
    
    public class Play {
        public void play(Monster mo, Hero he, Village vi, Weapon[] arrWeapon, Hero[] arrHero, Monster[] arrMonster){
            Random r = new Random();
            boolean isWin = false;
            Scanner sc = new Scanner(System.in);
            int num = 1;//回合数
            while(true) {
                if (mo.hp<=0&&mo.sfUsed==false) {
                    System.out.println("您的英雄" + he.name + "战胜了怪物,成功守卫村庄!!!");
                    isWin = true;
                    break;
                }else if (mo.hp<=0&&mo.sfUsed==true){//神愤技能时机
                    mo.skills(mo, arrMonster);
                    System.out.println("您的对手"+mo.name+"已替换成"+arrMonster[2].name);
                    mo.sfUsed=false;
                    mo=arrMonster[2];
                }
                if(vi.hp<=0||he.hp<=0){
                    break;
                }else{
                    if (he.hp > 0 && vi.hp > 0||he.zqUsed==true) {
                        System.out.println("*******************************************************************************");
                        System.out.println("第" + num + "回合");
                        if (num % 2 != 0) {//英雄回合
                            System.out.println("您的回合");
                            System.out.println("在本回合,您可以选择搜寻宝物或者直接攻击怪物(键入“1”搜寻宝物,或按回车直接攻击怪物)");
                            Scanner sc2 = new Scanner(System.in);
                            String q = sc2.nextLine();
                            if ("1".equals(q)) {
                                System.out.println("搜寻中......");
                                int ran1 = r.nextInt(1000);
                                int ran2 = r.nextInt(321);
                                if (he.Luckly==true){//曹操技能时机
                                    he.skills(he,mo);
                                    ran1=ran2;
                                }
                                if (ran1 <=320) {
                                    if (ran1<149) {
                                        Weapon we=arrWeapon[0];
                                        System.out.println("&&您的英雄搜寻到了武器" + we.name + "攻击力加"+ (he.Luckly==false? we.damage:we.damage/2)+ "!");
                                        he.attackNum = he.attackNum + (he.Luckly==false? we.damage:we.damage/2);
                                        System.out.println("现在"+he.name+"的攻击力是"+he.attackNum);
                                    }else if (ran1>=150&&ran1<=199){
                                        Weapon we=arrWeapon[4];
                                        he.weaponSkill=we.skillType;//为英雄装备技能赋初值,这个值会在Hero类attack方法被调用时,先判断改英雄是否拥有we.skillType这个值,以便确定是否拥有武器寒冰剑及其技能
                                        System.out.println("&&您的英雄搜寻到了武器" + we.name + "攻击力加"+ (he.Luckly==false?/*判断是否为英雄曹操,若是则增益减半*/ we.damage:we.damage/2)+ "!");
                                        he.attackNum = he.attackNum + (he.Luckly==false? we.damage:we.damage/2);
                                        System.out.println("现在"+he.name+"的攻击力是"+he.attackNum);
                                    }
    
                                    else if (ran1>=200&&ran1<=249) {
                                        Weapon we = arrWeapon[1];
                                        System.out.println("&&您的英雄搜寻到了装备" + we.name + "生命值增加" +(he.Luckly==false? we.addHp:we.addHp/2) + "!");
                                        he.hp=he.hp+(he.Luckly==false? we.addHp:we.addHp/2);
                                        System.out.println("现在"+he.name+"的生命值是"+he.hp);
                                       }
    
                                    else if(ran1>=250&&ran1<=279) {
                                        Weapon we = arrWeapon[2];
                                        System.out.println("&&您的英雄搜寻到了糟糕的武器" + we.name + "攻击力重置为" + we.damage + "!");
                                        he.attackNum = we.damage;
                                        System.out.println("现在"+he.name+"的攻击力是"+he.attackNum);
                                    }
    
                                    else if(ran1>=280&&ran1<=320) {
                                        Weapon we = arrWeapon[3];
                                        System.out.println("&&您的英雄搜寻到了宝物" + we.name + "为村庄恢复" +(he.Luckly==false? we.addVihp:we.addVihp/2)+"点生命值!");
                                        vi.hp=vi.hp+(he.Luckly==false? we.addVihp:we.addVihp/2);
                                        System.out.println("!!!现在村庄的生命值是"+vi.hp);
                                    }
                                    //技能时机
                                    if (he.skillTimes==0){
                                        System.out.println("回合结束...");
                                        if ("孟获".equals(he.name)&&he.zqUsed==false){//孟获技能【再起】负面效果时机
                                            he.hp=he.hp-70;
                                            System.out.println("孟获流失了70点生命值,血量为:"+he.hp);
                                        }
                                        num++;
                                    } else{
                                    System.out.println("您的技能剩余次数为"+he.skillTimes);
                                    System.out.println("您是否发动您的技能?(键入“Q”发动技能,或按回车取消)");
                                    String w = sc.nextLine();
                                    if ("Q".equals(w) || "q".equals(w)) {
                                        he.skills(he, mo);//发动技能
                                        System.out.println("回合结束...");
                                        if ("孟获".equals(he.name)&&he.zqUsed==false){//孟获技能【再起】负面效果时机
                                            he.hp=he.hp-70;
                                            System.out.println("孟获流失了70点生命值,血量为:"+he.hp);
                                        }
                                        num++;
                                    } else {
                                        System.out.println("回合结束...");
                                        if ("孟获".equals(he.name)&&he.zqUsed==false){//孟获技能【再起】负面效果时机
                                            he.hp=he.hp-70;
                                            System.out.println("孟获流失了70点生命值,血量为:"+he.hp);
                                        }
                                        num++;
                                    }
                                }
                            }
                                else {
                                    System.out.println("搜寻了个寂寞...没有找到任何宝物...");
                                    //}
                                    //技能时机
                                    if (he.skillTimes==0){
                                        if ("孟获".equals(he.name)&&he.zqUsed==false){//孟获技能【再起】负面效果时机
                                            he.hp=he.hp-70;
                                            System.out.println("孟获流失了70点生命值,血量为:"+he.hp);
                                        }
                                        System.out.println("回合结束...");
                                        num++;
                                    } else{
                                        System.out.println("您的技能剩余次数为"+he.skillTimes);
                                        System.out.println("您是否发动您的技能?(键入“Q”发动技能,或按回车取消)");
                                        String w = sc.nextLine();
                                        if ("Q".equals(w) || "q".equals(w)) {
                                            he.skills(he, mo);//发动技能
                                            System.out.println("回合结束...");
                                            if ("孟获".equals(he.name)&&he.zqUsed==false){//孟获技能【再起】负面效果时机
                                                he.hp=he.hp-70;
                                                System.out.println("孟获流失了70点生命值,血量为:"+he.hp);
                                            }
                                            num++;
                                        } else {
                                            System.out.println("回合结束...");
                                            if ("孟获".equals(he.name)&&he.zqUsed==false){//孟获技能【再起】负面效果时机
                                                he.hp=he.hp-70;
                                                System.out.println("孟获流失了70点生命值,血量为:"+he.hp);
                                            }
                                            num++;
                                        }
                                    }
                                }
                            }
                                else {
                                System.out.println("&&您的英雄" + he.name + "发起了攻击");
                                he.attack(he.attackNum,mo,he,arrWeapon,vi,arrMonster);
                                //技能时机
                                if (he.skillTimes==0){
                                    System.out.println("回合结束...");
                                    if ("孟获".equals(he.name)&&he.zqUsed==false){//孟获技能【再起】负面效果时机
                                        he.hp=he.hp-70;
                                        System.out.println("孟获流失了70点生命值,血量为:"+he.hp);
                                    }
                                    num++;
                                } else{
                                    System.out.println("您的技能剩余次数为"+he.skillTimes);
                                    System.out.println("您是否发动您的技能?(键入“Q”发动技能,或按回车取消)");
                                    String w = sc.nextLine();
                                    if ("Q".equals(w) || "q".equals(w)) {
                                        he.skills(he, mo);//发动技能
                                        System.out.println("回合结束...");
                                        if ("孟获".equals(he.name)&&he.zqUsed==false){//孟获技能【再起】负面效果时机
                                            he.hp=he.hp-70;
                                            System.out.println("孟获流失了70点生命值,血量为:"+he.hp);
                                        }
                                        num++;
                                    } else {
                                        System.out.println("回合结束...");
                                        if ("孟获".equals(he.name)&&he.zqUsed==false){//孟获技能【再起】负面效果时机
                                            he.hp=he.hp-70;
                                            System.out.println("孟获流失了70点生命值,血量为:"+he.hp);
                                        }
                                        num++;
                                    }
                                }
                            }
                        }
                        else {//怪兽回合
                            System.out.println("怪物" + mo.name + "回合");
                            int ran2 = r.nextInt(2);
                            if (ran2 == 0) {
                                System.out.println("##怪物" + mo.name + "对村庄发起了攻击");
                                mo.destory(mo.attackNum,vi);
                                num++;
                            } else {
                                System.out.println("##怪物" + mo.name + "对英雄" + he.name + "发起了攻击");
                                mo.attack(mo.attackNum,he);
                                if (he.hp<=0){
                                    if (he.zqUsed==true){//再起技能时机
                                        he.skills(he, mo);
                                    }
                                }
                                num++;
                            }
                        }
                    }
                }
            }
            if (isWin==false){
                System.out.println("===============================================================================");
                System.out.println("战败...");
                System.out.println("很遗憾,您输给了自大...");
                System.out.println("按Enter继续尝试...");
                sc.nextLine();
                new Start().main(null);
            }else {
                System.out.println("按Enter再来一局...");
                sc.nextLine();
                new Start().main(null);
            }
        }
    }
    
    

    5.SelsctHAndM类:

    package com.bai.demo05;
    
    public class Start {
        public static void main(String[] args) {
            //规则介绍
            System.out.println("游戏规则:回合制游戏,您胜利的条件是:在怪物" +
                    "摧毁村庄前击败他,如果您死亡或村庄被摧毁,则游戏失败...");
            System.out.println("【怪物】:每回合会随机攻击英雄或者村庄," +
                    "注意:怪物对村庄造成双倍伤害");
            System.out.println("【村庄】:这里住着您的子民,请一定保护村庄不被摧毁!");
            System.out.println("【搜寻】:每个你的回合,您可以选择搜寻宝物或者直接攻击怪兽," +
                    "每次搜寻都有有30%的几率搜寻到宝物," +
                    "也会有3%概率搜寻到糟糕的物品(糟糕的物品会造成一定的减益效果)," +
                    "搜寻到宝物会为您提供增益,但也会浪费您一个回合!物品掉落概率及其效果如下:");
            System.out.println("1.您有15%的几率搜寻到麒麟弓并使攻击力增加30;");
            System.out.println("2.您有3%的几率搜寻到折戟,这是一件糟糕的武器,会将您的攻击力减少至10;");
            System.out.println("3.您有5%的几率搜寻到白银狮子,恢复您的英雄200生命值;");
            System.out.println("4.您有5%的几率搜寻到家园守卫,恢复您的村庄200生命值;");
            System.out.println("5.您有5%的几率搜寻到寒冰剑,寒冰剑拥有装备技能:当您的英雄造成伤害后,您可以取消该伤害," +
                    "改为为村庄回复基于该伤害50%的生命值;");
            System.out.println("技能:您可以在任意您的结束回合使用您的技能," +
                    "但技能有使用次数限制(限定技甚至只能用一次),请合理利用");
    
            System.out.println("===============================================================================");
            System.out.println("游戏开始......");
            new HeroMonsterAndWeapon().HAndM();
        }
    }
    
    

    6.Village类:

    package com.bai.demo05;
    
    public class Village {
        int hp;
    }
    
    

    7.Weapon类:

    package com.bai.demo05;
    public class Weapon {
        String name;//名称
        int damage;//伤害
        int addHp;//血量增值
        int addVihp;//村庄血量增值
        String skill;//技能描述
        String skillName;//技能名
        int skillType;//技能标号
    }
    
    
    展开全文
  • java打怪小程序可运行

    2018-03-08 10:25:27
    面向对象,java打怪小案例,面向对象,java打怪小案例
  • java模拟回合打怪游戏

    2021-04-01 20:12:35
    java模拟回合打怪游戏 玩家的血值:w = 315 怪物的血值:g = 500 玩家和怪物互打 玩家每次攻击怪物产生5-8点伤害 怪物每次攻击玩家产生3-5点伤害 采用回合制,一方血量<=0游戏结束 用java程序模拟战斗过程...

    java模拟回合打怪游戏

    玩家的血值:w = 315

    怪物的血值:g = 500

    玩家和怪物互打

    玩家每次攻击怪物产生5-8点伤害

    怪物每次攻击玩家产生3-5点伤害

    采用回合制,一方血量<=0游戏结束

    用java程序模拟战斗过程:(用文字先写个草稿)

    int w = 315;

    int g = 500;

     

    while(玩家和怪物都活着)

    {

    生成玩家攻击力5-8

    怪物血值减少

    输出,玩家攻击了怪物,怪物掉了多少点血,还剩多少点血

     

    生成怪物攻击力3-5

    玩家血值减少

    输出怪物攻击玩家,玩家掉了多少点血,还剩多少点血

    }

     

    输出,游戏结束

     

    public class Test13 {
        public static void main(String[] args) {
            int w = 315;
            int g = 500;
            int h = 1;
            while(true){
                System.out.println("-------第"+h+"回合--------");
                h++;
                //生成玩家攻击力
                int wg = (int)(Math.random()*4)+5;
                //怪物被攻击,减少血量
                g-=wg;
                //输出结果
                System.out.println("玩家攻击力怪物,怪物掉了"+wg+"点血");
                //判断怪物是否死掉
                if (g<=0){
                    //输出结果
                    System.out.println("怪物死掉,玩家胜利!");
                    break;
                }
    
                //生成怪物攻击力
                int gg = (int)(Math.random()*3)+3;
                //玩家血值减少
                w-=gg;
                //输出玩家剩余血量
                System.out.println("怪物攻击力玩家,玩家掉了"+gg+"点血");
                //判断玩家是否死掉
                if (w<=0){
                    //输出结果
                    System.out.println("玩家死掉,怪物胜利!");
                    //停止循环
                    break;
                }
            }
        }
    }
    

    执行代码结果:

    展开全文
  • 这是刚学习java2星期自己写的一个 实现地下城“文字”打怪游戏,比较适合新手,提高对java的学习兴趣和巩固基础。
  • JAVA打怪之路 - IO流

    2020-02-18 20:50:34
    IO流是Java处理设备之间的数据传输的重要方式,文件的读取和写入实现数据的获取和存储,按照不同的划分标准流可以分为输入流和输出流、字节流和字符流,节点流和处理流。系统的学习IO流的原理对于数据的写入和写出有...
  • 【五年】Java打怪升级之路

    千次阅读 多人点赞 2016-11-28 18:05:41
    之前写过一篇帖子,就是...多看书,多看别人写的代码,多看别人的问题,多看相关技术书,多看文档,多看..... 很多东西都需要我们用双眼来看,当然,很多人肯定会说,哪有那么多时间来做这些事,我只能回答:挤时间。
  • 小编经过这么多次的面试,这两天整理了一份面试清单分享给大家,希望能给大家一点帮助(java方向),觉得有帮助的同学可以转发点个赞哦~~ 准备过程 先说说我自己的情况,我2016先在蚂蚁实习了将近三个月,然后去了我...
  • 这里我推荐几本:《重构-改善既有代码的设计模式》、《架构探险——从零开始写Java Web框架》、《java编程思想》(这个确实是很好的基础的书,虽然我也没看完..)、《深入解析Spring架构与设计原理》 ,如果对...
  • 写在最后 以上分享的全部资料都可免费分享领取—— 【点击这里下载】 还有一份JAVA核心知识点整理(PDF):JVM,JAVA集合,JAVA多线程并发,JAVA基础,Spring原理,微服务,Netty与RPC,网络,日志,Zookeeper,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,433
精华内容 573
热门标签
关键字:

java打怪游戏代码

java 订阅