利用Java实现玩家打怪小游戏的完整过程
作者：星迹日
这篇文章主要介绍了如何使用Java创建一个简单的“打怪小游戏”,游戏中的角色分为法师、战士、BOSS和一个Team类,代码展示了如何通过面向对象编程来实现一个基本的战斗系统,需要的朋友可以参考下
前言
今天，我们尝试用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时 ，才会开始改变血量，
最后进行各个成员的血量判断：
<strong>当法师和战士都阵亡，并且boss血量不为0时击杀失败</strong>
<strong>当boss血量小于等于并且有一个成员存活时时，结束循环并显示boss血量为0</strong>
<strong>全员为0时，同归于尽</strong>
让我们来看一下运行的结果吧
最后让我奉上完整的代码吧：
完整代码：
.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;
}
}
}
}总结
到此这篇关于利用Java实现玩家打怪小游戏的文章就介绍到这了,更多相关Java玩家打怪小游戏内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！