1、定义一个描述战斗单位的英雄（Hero）类，此类必须包含以下成员变量：名称(name)，生命值(life)，技能1攻击力(damage1)，防御力(defence)。此类包含成员方法：受到对手攻击时的处理方法（attacked()）。
2、此游戏中存在多种战斗角色:刺客（Assassin）、法师（Mage）、坦克（Tank），每种角色都是由要求1所定义的类派生出来的子类。各角色类都继承英雄（Hero）类，并添加成员属性：技能2攻击力（damage2）和技能3攻击力（damage3），在各角色类中，根据表1在其无参构造方法中初始化各角色的生命值、攻击力、防御力。定义一个免伤（Safe）接口，Safe接口中定义抽象方法show()；各角色类都实现Safe接口，在重写的show()方法中输出免伤信息。类图如图1所示。
表1 各类英雄属性
| 英雄名称 | 生命值 | 技能1攻击力 | 技能2攻击力 | 技能3攻击力 | 防御力 |
| 刺客 | 100 | 6 | 15 | 30 | 8 |
| 法师 | 80 | 8 | 20 | 40 | 6 |
| 坦克 | 120 | 6 | 12 | 20 | 10 |
3、此游戏采用回合制，游戏操作者通过选定我方出战英雄和对战英雄，双方英雄不能相同。每个回合由我方先出击，然后轮到对方出击；受攻击的伤害值通过随机数选定技能1/技能2/技能3的攻击力确定，判断受攻击的伤害是否大于自身的防御值，如果大于，则调用attecked()方法，否则调用show()方法。持续对战直到有一方的生命值小于等于0，游戏结束。游戏必须具有完备的提示信息，例如提示用户输入、每个回合都显示敌我双方每个角色对象的各种参数值等。
Hero英雄类
public class Hero {
protected String name;//英雌名称
protected int life;// 英雄生命
protected int damage1; //英雄攻击力
protected int defence;//防御
protected int attacked() { //受到对手攻击时的处理方法
return 0;
}
// protected 保护型,自身类和派生类可以访问相当于自身的private型成员，它同private的区别就是在对待派生类的区别上。
}
刺客类
class Assassin extends Hero implements Safe {
private String name;//英雌名称
private int life;// 英雄生命
private int damage1; //英雄攻击力1
private int damage2; //英雄攻击力2
private int damage3; //英雄攻击力3
private int defence;//防御
//private 私有型；自己的类可以访问，但派生类不能访问。
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getLife() {
return life;
}
public void setLife(int life) {
this.life = life;
}
public int getDamage1() {
return damage1;
}
public void setDamage1(int damage1) {
this.damage1 = damage1;
}
public int getDefence() {
return defence;
}
public void setDefence(int defence) {
this.defence = defence;
}
public int getDamage2() {
return damage2;
}
public void setDamage2(int damage2) {
this.damage2 = damage2;
}
public int getDamage3() {
return damage3;
}
public void setDamage3(int damage3) {
this.damage3 = damage3;
}
public String name() {
name = "Assassin";
return name;
}
public int life() {
life = 100;
return life;
}
public int damage1() {
damage1 = 6;
return damage1;
}
public int damage2() {
damage2 = 15;
return damage2;
}
public int damage3() {
damage3 = 30;
return damage3;
}
public int defence() {
defence = 8;
return defence;
}
public int show(int attack, int defence) {
int c = 0;
if ((attack == defence) || attack < defence)
c = 0;
return c;
}
public int attacked(int attack,int defence){//返回扣除的血量
return attack-defence;
}
}法师类
class Mage extends Hero implements Safe{
private String name;//英雌名称
private int life;// 英雄生命
private int damage1; //英雄攻击力1
private int damage2; //英雄攻击力2
private int damage3; //英雄攻击力3
private int defence;//防御
//private 私有型；自己的类可以访问，但派生类不能访问。
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getLife() {
return life;
}
public void setLife(int life) {
this.life = life;
}
public int getDamage1() {
return damage1;
}
public void setDamage1(int damage1) {
this.damage1 = damage1;
}
public int getDefence() {
return defence;
}
public void setDefence(int defence) {
this.defence = defence;
}
public int getDamage2() {
return damage2;
}
public void setDamage2(int damage2) {
this.damage2 = damage2;
}
public int getDamage3() {
return damage3;
}
public void setDamage3(int damage3) {
this.damage3 = damage3;
}
public String name() {
name = "Mage";
return name;
}
public int life() {
life = 80;
return life;
}
public int damage1() {
damage1 = 8;
return damage1;
}
public int damage2() {
damage2 = 20;
return damage2;
}
public int damage3() {
damage3 = 40;
return damage3;
}
public int defence() {
defence = 6;
return defence;
}
public int show(int attack, int defence) {
int c = 0;
if ((attack == defence) || attack < defence)
c = 0;
return c;
}
public int attacked(int attack,int defence){//返回扣除的血量
return attack-defence;
}
}
坦克类
class Tank extends Hero implements Safe{
private String name;//英雌名称
private int life;// 英雄生命
private int damage1; //英雄攻击力1
private int damage2; //英雄攻击力2
private int damage3; //英雄攻击力3
private int defence;//防御
//private 私有型；自己的类可以访问，但派生类不能访问。
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getLife() {
return life;
}
public void setLife(int life) {
this.life = life;
}
public int getDamage1() {
return damage1;
}
public void setDamage1(int damage1) {
this.damage1 = damage1;
}
public int getDefence() {
return defence;
}
public void setDefence(int defence) {
this.defence = defence;
}
public int getDamage2() {
return damage2;
}
public void setDamage2(int damage2) {
this.damage2 = damage2;
}
public int getDamage3() {
return damage3;
}
public void setDamage3(int damage3) {
this.damage3 = damage3;
}
public String name() {
name = "Tank";
return name;
}
public int life() {
life = 120;
return life;
}
public int damage1() {
damage1 = 6;
return damage1;
}
public int damage2() {
damage2 = 12;
return damage2;
}
public int damage3() {
damage3 = 20;
return damage3;
}
public int defence() {
defence = 10;
return defence;
}
public int show(int attack, int defence) {
int c = 0;
if ((attack == defence) || attack < defence)
c = 0;
return c;
}
public int attacked(int attack,int defence){//返回扣除的血量
return attack-defence;
}
}
免伤接口
public interface Safe {
abstract int show(int attack,int defence);
}
每一个英雄类都要实现免伤接口，接口是抽象的，必须要对其方法重写。
测试类（main）
import java.util.Scanner;
import java.util.Random;
import java.util.*;
public class text01 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("目前可选择职业是：");
System.out.println("刺客,法师,坦克");
String name1;
String name2;
System.out.println("请选择我方的英雄(刺客,法师,坦克)");
name1 = sc.nextLine();
System.out.println("请选择对方的英雄(刺客,法师,坦克)");
name2 = sc.nextLine();
String[] name = {"刺客", "法师", "坦克"};
int i;
int damage01 = 0, damage02 = 0, damage03 = 0, defence01 = 0, life01 = 0;
int damage11 = 0, damage12 = 0, damage13 = 0, defence11 = 0, life11 = 0;
Assassin role01 = new Assassin();
Mage role02 = new Mage();
Tank role03 = new Tank();
Assassin role11 = new Assassin();
Mage role12 = new Mage();
Tank role13 = new Tank();
int l1 = 0;//我方技能计数
int l2 = 0;//对方技能计数
for (i = 0; i < 3; i++) {
if (name1.equals(name[i])) {
System.out.println("我方选择" + name[i]);
if (name[i].equals("刺客")) {
damage01 = role01.damage1();
damage02 = role01.damage2();
damage03 = role01.damage3();
defence01 = role01.defence();
life01 = role01.life();
l1 = 1;
break;
}
if (name[i].equals("法师")) {
damage01 = role02.damage1();
damage02 = role02.damage2();
damage03 = role02.damage3();
defence01 = role02.defence();
life01 = role02.life();
l1 = 2;
break;
}
if (name[i].equals("坦克")) {
damage01 = role03.damage1();
damage02 = role03.damage2();
damage03 = role03.damage3();
defence01 = role03.defence();
life01 = role03.life();
l1 = 3;
break;
}
}
}
for (i = 0; i < 3; i++) {
if (name2.equals(name[i])) {
System.out.println("对方选择" + name[i]);
if (name[i].equals("刺客")) {
damage11 = role11.damage1();
damage12 = role11.damage2();
damage13 = role11.damage3();
defence11 = role11.defence();
life11 = role11.life();
l2 = 1;
break;
}
if (name[i].equals("法师")) {
damage11 = role12.damage1();
damage12 = role12.damage2();
damage13 = role12.damage3();
defence11 = role12.defence();
life11 = role12.life();
l2 = 2;
break;
}
if (name[i].equals("坦克")) {
damage11 = role13.damage1();
damage12 = role13.damage2();
damage13 = role13.damage3();
defence11 = role13.defence();
life11 = role13.life();
l2 = 3;
break;
}
}
}
i = 0;
int attack1 = 0;//我方技能伤害
int attack2 = 0;//对方技能伤害
int j = 0;//
int life1 = life01;//我方生命
int life2 = life11;//对方生命
int[] attack01 = {damage01, damage02, damage03};//我方技能
int[] attack11 = {damage11, damage12, damage13};//对方技能
Random random = new Random();//产出随机数
System.out.println("------------------------");
System.out.println("我方："+name[l1-1]+" VS "+"对方："+name[l2-1]);
System.out.println("==========对战开始==========");
while (true) {
i++;
System.out.println("第" + i + "回合");
System.out.println("我方出击");
j = random.nextInt(3);
attack1 = attack01[j];
System.out.println("我方技能攻击力为" + attack1);
System.out.println("对方防御为" + defence11);
System.out.println("对方的生命值为" + life2);
if (attack1 > defence11) {//我方技能伤害大于对方防御，攻击有效
System.out.println("我方攻击有效！");
if (l1 == 1) {
life2 = life2 - (role01.attacked(attack1, defence11));
System.out.println("对方"+name[l2-1]+"受到"+role01.attacked(attack1, defence11)+"伤害");
}
if (l1 == 2) {
life2 = life2 - (role02.attacked(attack1, defence11));
System.out.println("对方"+name[l2-1]+"受到"+role02.attacked(attack1, defence11)+"伤害");
}
if (l1 == 3) {
life2 = life2 - (role03.attacked(attack1, defence11));
System.out.println("对方"+name[l2-1]+"受到"+role03.attacked(attack1, defence11)+"伤害");
}
}
if (attack1 <= defence11) {//我方技能伤害小于或者等于对方防御值；
System.out.println("我方攻击无效！");
if (l1 == 1) {
life2 = life2 - (role01.show(attack1, defence11));
}
if (l1 == 2) {
life2 = life2 - (role02.show(attack1, defence11));
}
if (l1 == 3) {
life2 = life2 - (role03.show(attack1, defence11));
}
}
j = random.nextInt(3);
attack2 = attack11[j];
System.out.println("对方出击");
System.out.println("对方技能攻击力为" + attack2);
System.out.println("我方防御为" + defence01);
System.out.println("我方的生命值为" + life1);
if (attack2 > defence01) {//对方技能伤害大于我方防御，对方攻击有效
System.out.println("对方攻击有效！");
if (l2 == 1) {
life1 = life1 - (role11.attacked(attack2, defence01));
System.out.println("我方"+name[l1-1]+"受到"+role11.attacked(attack2, defence01)+"伤害");
}
if (l2 == 2) {
life1 = life1 - (role12.attacked(attack2, defence01));
System.out.println("我方"+name[l1-1]+"受到"+role12.attacked(attack2, defence01)+"伤害");
}
if (l2 == 3) {
life1 = life1 - (role13.attacked(attack2, defence01));
System.out.println("我方"+name[l1-1]+"受到"+role13.attacked(attack2, defence01)+"伤害");
}
}
if (attack2 <= defence01) {//对方技能伤害小于或者等于我方防御值；
System.out.println("我方攻击无效！");
if (l2 == 1) {
life1 = life1 - (role11.show(attack2, defence01));
}
if (l2 == 2) {
life1 = life1 - (role12.show(attack2, defence01));
}
if (l2 == 3) {
life1 = life1 - (role13.show(attack2, defence01));
}
}
System.out.println("=============================");
if (life1 <= 0 || life2 <= 0) {
break;
}
}
if(life1>life2){
System.out.println("对方英雄阵亡,我方获胜");
}else{
System.out.println("我方英雄阵亡,对方获胜");
}
}
}实验效果：
2848
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
