Java:玩家打怪小游戏

今天，我们尝试用Java来做一个“打怪小游戏”，听名字就知道，我们是应该创建几个成员和怪物，还有知道知道成员和怪物的血量，一次攻击的伤害等等。。当然我们的游戏攻击模式是“回合制”（其实是别的方法，我也不会。。。)。

一.成员的创建

首先我将需要创建的类先展示出来：

1.Role抽象类（父类）

首先，我们要创建一个抽象类作为父类，在当中我们放入名字，血量，和攻击方法，返回方法，至于为什么是抽象类，是因为我们想要将法师的伤害设置为等级的5倍，所以我们要将攻击方法设置为抽象方法。（抽象类和抽象方法需要用 abstract关键字修饰）

代码实现：

public abstract class Role {//创建一个角色类作为父类
    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父类，在其中创建一个等级变量，并在其中重写攻击方法和返回方法，对于重写的返回方法我们要返回法师的名字和等级，所以我们可以根据super关键字，调用super.toString()方法，得到父类中的返回方法，并加上等级形成新的返回。

代码实现：

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

    public int getLevel(){
        return level;
    }

    //创建一个法师伤害方法，伤害为等级的5倍
    public int attack() {
        return level*5;
    }
    public String toString(){
        return "Magicer={"+super.toString()+"Level="+level+"}";
    }
}

3.Soldier子类

继承Role父类，在其中创建一个伤害变量，并在其中重写攻击方法和返回方法，对于重写的返回方法我们要返回战士的名字和伤害，所以我们可以根据super关键字，调用super.toString()方法，得到父类中的返回方法，并加上伤害形成新的返回

public class Soldier 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 "Soldier={"+super.toString()+"hurt="+hurt+"}";
    }
}

4.Boss子类

同样继承Role父类，在其中创建一个伤害变量，并在其中重写攻击方法和返回方法，对于重写的返回方法我们要返回BOSS的名字和伤害，所以我们可以根据super关键字，调用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类

设计一个addMember方法，最大添加6个成员（算怪物）

设计一个members方法，用于统计成员

设计一个attackSum方法，用来统计一次攻击所有人造成的伤害

设计一个attackNum方法，返回boss造成的伤害

设计一个injured方法，返回boss受到伤害的的剩余血量

设计一个injures1方法，返回magicer受到伤害后的血量。

设计一个injures2方法，返回soldier受到伤害后的血量。

6.Player类

实例化：

数据的传入：

调用添加方法：

打印成员和一次造成的伤害：

创建一个循环，形成回合制攻击模式：

队伍造成伤害-》boss剩余血量打印-》boss造成伤害-》成员剩余血量打印

我们知道当一个角色阵亡时，我们的总的伤害会减少，所以我们可以当成员阵亡时，就让这时boss的血量加上这个成语造成的伤害，这样就相当于我们只造成了没死成员的伤害，但是由于我们时先成员进行攻击在boss进行攻击，所以当我们成员血量第一次为0时，之前会造成伤害，所以在第一次成员血量为0时，我们不能将boss的血量改变，只有在第二次血量为0时，才会开始改变血量，所以我们可以设计一个血量为0的标志，当这个标志大于等于2时，才会开始改变血量，

最后进行各个成员的血量判断：

当法师和战士都阵亡，并且boss血量不为0时击杀失败

当boss血量小于等于并且有一个成员存活时时，结束循环并显示boss血量为0

```
全员为0时，同归于尽
```

让我们来看一下运行的结果吧

最后让我奉上完整的代码吧：

完整代码：

.Role抽象类：

public abstract class Role {//创建一个角色类作为父类
    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;
    }

    //创建一个法师伤害方法，伤害为等级的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;
    }
    //创建一个战士伤害方法
    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];//创建一个能容纳6个成员的数组
    private int i=0;//定义一个计数标志
    //创建一个添加成员的方法
    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];//建立一个数组roles1用来存储数据
        for(Role role : this.roles){//利用for each循环，得到在这个类中输入的成员，并赋给role
            if(role instanceof Magicer){//利用intstanceof关键字判断role得到的数据，是否属于Magicer类型
                Magicer magicer = (Magicer)role;//如果属于Magicer类型，利用向下转型，将role赋给magicer变量，根据magicer变量就可以进行打印
                roles1[i]=magicer;//将magicer赋给数组roles1
                i++;//去到数组下一位
            }else if(role instanceof Soldier){//利用intstanceof关键字判断role得到的数据，是否属于Soldier类型
                Soldier soldier = (Soldier)role;//如果属于Soldier类型，利用向下转型，将role赋给soldier变量，根据soldier变量就可以进行打印
                roles1[i]=soldier;//将soldier赋给数组roles1
                i++;//去到数组下一位
            }else{
               break;
            }
        }
        for(Role role1 : roles1){//利用for each循环，得到在这个类中roles1数组刚得到的值，并赋给role
            if (role1!=null) {//如果不等于空就进行打印
                System.out.println(role1);//会将刚才得到的变量，代入其中，并打印变量的值
            }else {
                break;
            }
        }
    }

    public int attackSum(){
        int sum=0;//创建一个变量用来存储一次的总伤害
        for(Role role : this.roles){//以来for each循环得到输入的成员
            if(role instanceof Magicer){//利用intstanceof关键字判断role得到的数据，是否属于Magicer类型
                Magicer magicer = (Magicer) role;//利用向下转型，将role赋给magicer变量，根据magicer变量就可以进行调用
                sum+=magicer.attack();//将magicer造成的伤害加到sum中
            }else if(role instanceof Soldier){//利用intstanceof关键字判断role得到的数据，是否属于Soldier类型
                Soldier soldier = (Soldier) role;//利用向下转型，将role赋给soldier变量，根据soldier变量就可以进行调用
                sum+=soldier.attack();//将soldier造成的伤害加到sum中
            }else{
                break;
            }
        }
        return sum;//返回一次攻击的总伤害
    }

    public int attackNum(){//创建一个boss攻击力的方法，返回boss造成的伤害
        int num=0;
        for(Role role : this.roles){
            if(role instanceof Boss) {
                Boss boss = (Boss) role;
                num += boss.attack();
            }
        }
            return num;
    }

    //创建一个boss所受伤害的方法
    public int injured(){//创建一个boss受伤方法返回boss受伤后的血量
        int blood=0;  //创建一个变量用来存储剩余血量
        for(Role role : this.roles){//以来for each循环得到输入的成员
            if(role instanceof Boss){//找到Boss类型的数据
                Boss boss = (Boss) role;//得到boss变量
                blood=boss.getHp()-attackSum();//利用boss变量得到boss的血量再去减去一次所收到的伤害，得到剩余的血量
                if(blood<=0){//当boss的血量为0时返回剩余血量为0
                    return 0;
                }
            }
        }
        return blood;//返回剩余的血量
    }

    public int injures1(){//创建一个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(){//创建一个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();//实例化一个战士类
        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("战士");
        soldier.setHp(600);
        System.out.print("请输入战士一次的伤害：");
        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){//创建一个while循环，条件为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());//通过调用team.injures1()显示血量
            magicer.setHp(team.injures1());//将血量传给magicer.setHp()重新输入magicer成员的血量

            System.out.print("soldier成语血量：");
            System.out.println(team.injures2());//通过调用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){//当法师和战士都阵亡，并且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血量小于等于并且有一个成员存活时时，结束循环并显示boss血量为0
                System.out.println("Boss剩余血量：0，击杀成功");
                break;
            }else if(magicer.getHp()==0 && soldier.getHp()==0 && boss.getHp()==0){//全员为0时，同归于尽
                System.out.println("同归于尽");
                break;
            }
        }

    }
}