利用Java實(shí)現(xiàn)玩家打怪小游戲的完整過程

更新時(shí)間：2024年12月27日 09:36:32 作者：星跡日

這篇文章主要介紹了如何使用Java創(chuàng)建一個(gè)簡(jiǎn)單的“打怪小游戲”,游戲中的角色分為法師、戰(zhàn)士、BOSS和一個(gè)Team類,代碼展示了如何通過面向?qū)ο缶幊虂韺?shí)現(xiàn)一個(gè)基本的戰(zhàn)斗系統(tǒng),需要的朋友可以參考下

前言

今天，我們嘗試用Java來做一個(gè)“打怪小游戲”，聽名字就知道，我們是應(yīng)該創(chuàng)建幾個(gè)成員和怪物，還有知道知道成員和怪物的血量，一次攻擊的傷害等等。。當(dāng)然我們的游戲攻擊模式是“回合制”（其實(shí)是別的方法，我也不會(huì)。。。)。

一.成員的創(chuàng)建

首先我將需要?jiǎng)?chuàng)建的類先展示出來：

1.Role抽象類（父類）

首先，我們要?jiǎng)?chuàng)建一個(gè)抽象類作為父類，在當(dāng)中我們放入名字，血量，和攻擊方法，返回方法，至于為什么是抽象類，是因?yàn)槲覀兿胍獙⒎◣煹膫υO(shè)置為等級(jí)的5倍，所以我們要將攻擊方法設(shè)置為抽象方法。（抽象類和抽象方法需要用 abstract關(guān)鍵字修飾）

代碼實(shí)現(xiàn)：

public abstract class Role {//創(chuàng)建一個(gè)角色類作為父類
    private String name;
    private int hp;
    public abstract int attack();
    public void setName(String name){
        this.name = name;
    }

    public String getName(){
        return name;
    }

    public void setHp(int hp){
        this.hp=hp;
    }

    public int getHp(){
        return hp;
    }

    public String toString(){
        return "name="+name+","+"hp="+hp;
    }
}

2.Magicer子類

繼承Role父類，在其中創(chuàng)建一個(gè)等級(jí)變量，并在其中重寫攻擊方法和返回方法，對(duì)于重寫的返回方法我們要返回法師的名字和等級(jí)，所以我們可以根據(jù)super關(guān)鍵字，調(diào)用super.toString()方法，得到父類中的返回方法，并加上等級(jí)形成新的返回。

代碼實(shí)現(xiàn)：

public class Magicer extends Role {
    private int level;
    public void setLevel(int level){
        this.level = level;
    }

    public int getLevel(){
        return level;
    }

    //創(chuàng)建一個(gè)法師傷害方法，傷害為等級(jí)的5倍
    public int attack() {
        return level*5;
    }
    public String toString(){
        return "Magicer={"+super.toString()+"Level="+level+"}";
    }
}

3.Soldier子類

繼承Role父類，在其中創(chuàng)建一個(gè)傷害變量，并在其中重寫攻擊方法和返回方法，對(duì)于重寫的返回方法我們要返回戰(zhàn)士的名字和傷害，所以我們可以根據(jù)super關(guān)鍵字，調(diào)用super.toString()方法，得到父類中的返回方法，并加上傷害形成新的返回

public class Soldier extends Role {
    private int hurt;
    public void setHurt(int hurt){
        this.hurt = hurt;
    }

    public int getHurt(){
        return hurt;
    }
    //創(chuàng)建一個(gè)戰(zhàn)士傷害方法
    public int attack(){
        return hurt;
    }

    public String toString(){
        return "Soldier={"+super.toString()+"hurt="+hurt+"}";
    }
}

4.Boss子類

同樣繼承Role父類，在其中創(chuàng)建一個(gè)傷害變量，并在其中重寫攻擊方法和返回方法，對(duì)于重寫的返回方法我們要返回BOSS的名字和傷害，所以我們可以根據(jù)super關(guān)鍵字，調(diào)用super.toString()方法，得到父類中的返回方法，并加上傷害形成新的返回

public class Boss extends Role{
    private int hurt;
    public void setHurt(int hurt){
        this.hurt=hurt;
    }

    public int getHurt(){
        return hurt;
    }
    public int attack(){
        return hurt;
    }

    public String toString() {
        return "Boss={" + super.toString() + "hurt=" + hurt + "}";
    }
}

5.Team類

設(shè)計(jì)一個(gè)addMember方法，最大添加6個(gè)成員（算怪物）

設(shè)計(jì)一個(gè)members方法，用于統(tǒng)計(jì)成員

設(shè)計(jì)一個(gè)attackSum方法，用來統(tǒng)計(jì)一次攻擊所有人造成的傷害

設(shè)計(jì)一個(gè)attackNum方法，返回boss造成的傷害

設(shè)計(jì)一個(gè)injured方法，返回boss受到傷害的的剩余血量

設(shè)計(jì)一個(gè)injures1方法，返回magicer受到傷害后的血量。

設(shè)計(jì)一個(gè)injures2方法，返回soldier受到傷害后的血量。

6.Player類

實(shí)例化：

數(shù)據(jù)的傳入：

調(diào)用添加方法：

打印成員和一次造成的傷害：

創(chuàng)建一個(gè)循環(huán)，形成回合制攻擊模式：

隊(duì)伍造成傷害-》boss剩余血量打印-》boss造成傷害-》成員剩余血量打印

我們知道當(dāng)一個(gè)角色陣亡時(shí)，我們的總的傷害會(huì)減少，所以我們可以當(dāng)成員陣亡時(shí)，就讓這時(shí)boss的血量加上這個(gè)成語(yǔ)造成的傷害，這樣就相當(dāng)于我們只造成了沒死成員的傷害，但是由于我們時(shí)先成員進(jìn)行攻擊在boss進(jìn)行攻擊，所以當(dāng)我們成員血量第一次為0時(shí)，之前會(huì)造成傷害，所以在第一次成員血量為0時(shí)，我們不能將boss的血量改變，只有在第二次血量為0時(shí)，才會(huì)開始改變血量，所以我們可以設(shè)計(jì)一個(gè)血量為0的標(biāo)志，當(dāng)這個(gè)標(biāo)志大于等于2時(shí) ，才會(huì)開始改變血量，

最后進(jìn)行各個(gè)成員的血量判斷：

<strong>當(dāng)法師和戰(zhàn)士都陣亡，并且boss血量不為0時(shí)擊殺失敗</strong>

<strong>當(dāng)boss血量小于等于并且有一個(gè)成員存活時(shí)時(shí)，結(jié)束循環(huán)并顯示boss血量為0</strong>

<strong>全員為0時(shí)，同歸于盡</strong>

讓我們來看一下運(yùn)行的結(jié)果吧

最后讓我奉上完整的代碼吧：

完整代碼：

.Role抽象類：

public abstract class Role {//創(chuàng)建一個(gè)角色類作為父類
    private String name;
    private int hp;
    public abstract int attack();
    public void setName(String name){
        this.name = name;
    }

    public String getName(){
        return name;
    }

    public void setHp(int hp){
        this.hp=hp;
    }

    public int getHp(){
        return hp;
    }

    public String toString(){
        return "name="+name+","+"hp="+hp;
    }
}

Magicer子類：

public class Magicer extends Role {
    private int level;
    public void setLevel(int level){
        this.level = level;
    }

    public int getLevel(){
        return level;
    }

    //創(chuàng)建一個(gè)法師傷害方法，傷害為等級(jí)的5倍
    public int attack() {
        return level*5;
    }
    public String toString(){
        return "Magicer={"+super.toString()+"Level="+level+"}";
    }
}

Soldier子類：

public class Soldier extends Role {
    private int hurt;
    public void setHurt(int hurt){
        this.hurt = hurt;
    }

    public int getHurt(){
        return hurt;
    }
    //創(chuàng)建一個(gè)戰(zhàn)士傷害方法
    public int attack(){
        return hurt;
    }

    public String toString(){
        return "Soldier={"+super.toString()+"hurt="+hurt+"}";
    }
}

Boss子類：

public class Boss extends Role{
    private int hurt;
    public void setHurt(int hurt){
        this.hurt=hurt;
    }

    public int getHurt(){
        return hurt;
    }
    public int attack(){
        return hurt;
    }

    public String toString() {
        return "Boss={" + super.toString() + "hurt=" + hurt + "}";
    }
}

Team類：

public class Team {
    private Role[] roles = new Role[6];//創(chuàng)建一個(gè)能容納6個(gè)成員的數(shù)組
    private int i=0;//定義一個(gè)計(jì)數(shù)標(biāo)志
    //創(chuàng)建一個(gè)添加成員的方法
    public void addMember(Role role){
        //做一個(gè)判斷防止它超過6個(gè)成員
        if(i <= 6){
            roles[i]=role;
            i++;
        }else{
            System.out.println("只能添加6個(gè)成員");
        }
    }

    public void members(){
        int i=0;
        Role[] roles1 = new Role[6];//建立一個(gè)數(shù)組roles1用來存儲(chǔ)數(shù)據(jù)
        for(Role role : this.roles){//利用for each循環(huán)，得到在這個(gè)類中輸入的成員，并賦給role
            if(role instanceof Magicer){//利用intstanceof關(guān)鍵字判斷role得到的數(shù)據(jù)，是否屬于Magicer類型
                Magicer magicer = (Magicer)role;//如果屬于Magicer類型，利用向下轉(zhuǎn)型，將role賦給magicer變量，根據(jù)magicer變量就可以進(jìn)行打印
                roles1[i]=magicer;//將magicer賦給數(shù)組roles1
                i++;//去到數(shù)組下一位
            }else if(role instanceof Soldier){//利用intstanceof關(guān)鍵字判斷role得到的數(shù)據(jù)，是否屬于Soldier類型
                Soldier soldier = (Soldier)role;//如果屬于Soldier類型，利用向下轉(zhuǎn)型，將role賦給soldier變量，根據(jù)soldier變量就可以進(jìn)行打印
                roles1[i]=soldier;//將soldier賦給數(shù)組roles1
                i++;//去到數(shù)組下一位
            }else{
               break;
            }
        }
        for(Role role1 : roles1){//利用for each循環(huán)，得到在這個(gè)類中roles1數(shù)組剛得到的值，并賦給role
            if (role1!=null) {//如果不等于空就進(jìn)行打印
                System.out.println(role1);//會(huì)將剛才得到的變量，代入其中，并打印變量的值
            }else {
                break;
            }
        }
    }

    public int attackSum(){
        int sum=0;//創(chuàng)建一個(gè)變量用來存儲(chǔ)一次的總傷害
        for(Role role : this.roles){//以來for each循環(huán)得到輸入的成員
            if(role instanceof Magicer){//利用intstanceof關(guān)鍵字判斷role得到的數(shù)據(jù)，是否屬于Magicer類型
                Magicer magicer = (Magicer) role;//利用向下轉(zhuǎn)型，將role賦給magicer變量，根據(jù)magicer變量就可以進(jìn)行調(diào)用
                sum+=magicer.attack();//將magicer造成的傷害加到sum中
            }else if(role instanceof Soldier){//利用intstanceof關(guān)鍵字判斷role得到的數(shù)據(jù)，是否屬于Soldier類型
                Soldier soldier = (Soldier) role;//利用向下轉(zhuǎn)型，將role賦給soldier變量，根據(jù)soldier變量就可以進(jìn)行調(diào)用
                sum+=soldier.attack();//將soldier造成的傷害加到sum中
            }else{
                break;
            }
        }
        return sum;//返回一次攻擊的總傷害
    }

    public int attackNum(){//創(chuàng)建一個(gè)boss攻擊力的方法，返回boss造成的傷害
        int num=0;
        for(Role role : this.roles){
            if(role instanceof Boss) {
                Boss boss = (Boss) role;
                num += boss.attack();
            }
        }
            return num;
    }

    //創(chuàng)建一個(gè)boss所受傷害的方法
    public int injured(){//創(chuàng)建一個(gè)boss受傷方法返回boss受傷后的血量
        int blood=0;  //創(chuàng)建一個(gè)變量用來存儲(chǔ)剩余血量
        for(Role role : this.roles){//以來for each循環(huán)得到輸入的成員
            if(role instanceof Boss){//找到Boss類型的數(shù)據(jù)
                Boss boss = (Boss) role;//得到boss變量
                blood=boss.getHp()-attackSum();//利用boss變量得到boss的血量再去減去一次所收到的傷害，得到剩余的血量
                if(blood<=0){//當(dāng)boss的血量為0時(shí)返回剩余血量為0
                    return 0;
                }
            }
        }
        return blood;//返回剩余的血量
    }

    public int injures1(){//創(chuàng)建一個(gè)magicer受傷方法，通過總生命減受到的傷害，從而返回magicer受傷后的血量
        int blood1=0;
        for(Role role :this.roles){
            if(role instanceof Magicer){
                Magicer magicer = (Magicer) role;
               blood1 = magicer.getHp()-attackNum();
               if(blood1<=0){//當(dāng)magicer的血量為0時(shí)返回剩余血量為0
                   return 0;
               }
            }
        }
        return blood1;
    }

    public int injures2(){//創(chuàng)建一個(gè)soldier受傷方法，通過總生命減受到的傷害，從而返回soldier受傷后的血量
        int blood2=0;
        for(Role role :this.roles){
            if(role instanceof Soldier) {
                Soldier soldier = (Soldier) role;
                blood2 = soldier.getHp() - attackNum();
                if(blood2<=0){//當(dāng)soldier1的血量為0時(shí)返回剩余血量為0
                    return 0;
                }
            }
        }
        return blood2;
    }
}

Player類：

import java.util.Scanner;

public class Player {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int x=0;//magicer血量小于等于0的標(biāo)志
        int y=0;//soldier血量小于等于0的標(biāo)志

        Magicer  magicer = new  Magicer();//實(shí)例化一個(gè)法師類
        Soldier  soldier = new  Soldier();//實(shí)例化一個(gè)戰(zhàn)士類
        Boss boss = new Boss();//實(shí)例化一個(gè)boss類
        Team team = new Team();//實(shí)例化一個(gè)隊(duì)伍類

        magicer.setName("甘道夫");
        magicer.setHp(600);
        System.out.print("請(qǐng)輸入甘道夫等級(jí)：");
        int a = scan.nextInt();
        magicer.setLevel(a);

        soldier.setName("戰(zhàn)士");
        soldier.setHp(600);
        System.out.print("請(qǐng)輸入戰(zhàn)士一次的傷害：");
        int b = scan.nextInt();
        soldier.setHurt(b);

        boss.setName("魔王");
        System.out.println("魔王的血量為：1200");
        boss.setHp(1200);
        System.out.print("請(qǐng)輸入魔王一次的傷害為:");
        int c = scan.nextInt();
        boss.setHurt(c);

        team.addMember(magicer);
        team.addMember(soldier);
        team.addMember(boss);

        System.out.println("該小隊(duì)成員為：");
        team.members();
        System.out.print("該小隊(duì)傷害為：");
        System.out.println(team.attackSum());

        while(boss.getHp()>0){//創(chuàng)建一個(gè)while循環(huán)，條件為boss血量大于0
            System.out.println("隊(duì)伍造成傷害：");
            System.out.print("Boss剩余血量：");
            System.out.println(team.injured());//顯示boss剩余血量
            boss.setHp(team.injured());//將剩余血量，傳給boss

            System.out.println("魔王造成傷害：");
            System.out.print("magicer成員血量：");
            System.out.println(team.injures1());//通過調(diào)用team.injures1()顯示血量
            magicer.setHp(team.injures1());//將血量傳給magicer.setHp()重新輸入magicer成員的血量

            System.out.print("soldier成語(yǔ)血量：");
            System.out.println(team.injures2());//通過調(diào)用team.injures2()顯示血量
            soldier.setHp(team.injures2());//將血量傳給soldier.setHp()重新輸入soldier成員的血量
            System.out.println("---------------");

            if(soldier.getHp()>0 &&magicer.getHp()<=0){//當(dāng)一個(gè)陣亡一個(gè)沒有陣亡時(shí)
                x++;//血量歸零時(shí)，標(biāo)志加1，之前會(huì)造成傷害
                if(x>=2){//當(dāng)血量第二次歸零時(shí)，不會(huì)造成傷害
                    boss.setHp(boss.getHp()+ magicer.attack());//所以我們要將boss血量加回來
                }
            }

            if(magicer.getHp()>0 &&soldier.getHp()<=0){
                y++;血量歸零時(shí)，標(biāo)志加1，之前會(huì)造成傷害
                if(y>=2){當(dāng)血量第二次歸零時(shí)，不會(huì)造成傷害
                    boss.setHp(boss.getHp()+ soldier.attack());//所以我們要將boss血量加回來
                }
            }


            if(magicer.getHp()<=0 && soldier.getHp()<=0 && boss.getHp()>0){//當(dāng)法師和戰(zhàn)士都陣亡，并且boss血量不為0時(shí)擊殺失敗
                System.out.println("所有成員剩余血量：0，全部陣亡！擊殺失敗");
                System.out.println("Boss剩余血量：");
                System.out.println(boss.getHp());//顯示boss剩余血量
                break;
            }else if((magicer.getHp()>0 || soldier.getHp()>0) && boss.getHp()<=0){//當(dāng)boss血量小于等于并且有一個(gè)成員存活時(shí)時(shí)，結(jié)束循環(huán)并顯示boss血量為0
                System.out.println("Boss剩余血量：0，擊殺成功");
                break;
            }else if(magicer.getHp()==0 && soldier.getHp()==0 && boss.getHp()==0){//全員為0時(shí)，同歸于盡
                System.out.println("同歸于盡");
                break;
            }
        }
    }
}