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

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

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

前言

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

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

首先我將需要創(chuàng)建的類先展示出來：

1.Role抽象類（父類）

首先，我們要創(chuàng)建一個抽象類作為父類，在當中我們放入名字，血量，和攻擊方法，返回方法，至于為什么是抽象類，是因為我們想要將法師的傷害設(shè)置為等級的5倍，所以我們要將攻擊方法設(shè)置為抽象方法。（抽象類和抽象方法需要用 abstract關(guān)鍵字修飾）

代碼實現(xiàn)：

public abstract class Role {//創(chuàng)建一個角色類作為父類
    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)建一個等級變量，并在其中重寫攻擊方法和返回方法，對于重寫的返回方法我們要返回法師的名字和等級，所以我們可以根據(jù)super關(guān)鍵字，調(diào)用super.toString()方法，得到父類中的返回方法，并加上等級形成新的返回。

代碼實現(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)建一個法師傷害方法，傷害為等級的5倍
    public int attack() {
        return level*5;
    }
    public String toString(){
        return "Magicer={"+super.toString()+"Level="+level+"}";
    }
}

3.Soldier子類

繼承Role父類，在其中創(chuàng)建一個傷害變量，并在其中重寫攻擊方法和返回方法，對于重寫的返回方法我們要返回戰(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)建一個戰(zhàn)士傷害方法
    public int attack(){
        return hurt;
    }

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

4.Boss子類

同樣繼承Role父類，在其中創(chuàng)建一個傷害變量，并在其中重寫攻擊方法和返回方法，對于重寫的返回方法我們要返回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è)計一個addMember方法，最大添加6個成員（算怪物）

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

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

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

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

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

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

6.Player類

實例化：

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

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

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

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

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

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

最后進行各個成員的血量判斷：

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

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

<strong>全員為0時，同歸于盡</strong>

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

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

完整代碼：

.Role抽象類：

public abstract class Role {//創(chuàng)建一個角色類作為父類
    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)建一個法師傷害方法，傷害為等級的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)建一個戰(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)建一個能容納6個成員的數(shù)組
    private int i=0;//定義一個計數(shù)標志
    //創(chuàng)建一個添加成員的方法
    public void addMember(Role role){
        //做一個判斷防止它超過6個成員
        if(i <= 6){
            roles[i]=role;
            i++;
        }else{
            System.out.println("只能添加6個成員");
        }
    }

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

    public int attackSum(){
        int sum=0;//創(chuàng)建一個變量用來存儲一次的總傷害
        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變量就可以進行調(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變量就可以進行調(diào)用
                sum+=soldier.attack();//將soldier造成的傷害加到sum中
            }else{
                break;
            }
        }
        return sum;//返回一次攻擊的總傷害
    }

    public int attackNum(){//創(chuàng)建一個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)建一個boss所受傷害的方法
    public int injured(){//創(chuàng)建一個boss受傷方法返回boss受傷后的血量
        int blood=0;  //創(chuàng)建一個變量用來存儲剩余血量
        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){//當boss的血量為0時返回剩余血量為0
                    return 0;
                }
            }
        }
        return blood;//返回剩余的血量
    }

    public int injures1(){//創(chuàng)建一個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){//當magicer的血量為0時返回剩余血量為0
                   return 0;
               }
            }
        }
        return blood1;
    }

    public int injures2(){//創(chuàng)建一個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){//當soldier1的血量為0時返回剩余血量為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的標志
        int y=0;//soldier血量小于等于0的標志

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

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

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

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

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

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

        while(boss.getHp()>0){//創(chuàng)建一個while循環(huán)，條件為boss血量大于0
            System.out.println("隊伍造成傷害：");
            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成語血量：");
            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){//當一個陣亡一個沒有陣亡時
                x++;//血量歸零時，標志加1，之前會造成傷害
                if(x>=2){//當血量第二次歸零時，不會造成傷害
                    boss.setHp(boss.getHp()+ magicer.attack());//所以我們要將boss血量加回來
                }
            }

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


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