【Java】英雄对战游戏，面向对象实验，综合性实验，编程基础知识：变量的定义、选择语句、循环语句。面对对象：类和接口的定义、继承、接口实现。

忘是亡心i 2024-05-25 17:34 8阅读 0赞

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 各类英雄属性

3、此游戏采用回合制，游戏操作者通过选定我方出战英雄和对战英雄，双方英雄不能相同。每个回合由我方先出击，然后轮到对方出击；受攻击的伤害值通过随机数选定技能1/技能2/技能3的攻击力确定，判断受攻击的伤害是否大于自身的防御值，如果大于，则调用attecked()方法，否则调用show()方法。持续对战直到有一方的生命值小于等于0，游戏结束。游戏必须具有完备的提示信息，例如提示用户输入、每个回合都显示敌我双方每个角色对象的各种参数值等。

![6432747f2a2146fbb8be6b6be5a7f461.png][]

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("我方英雄阵亡,对方获胜");
 }
 }
 }

实验效果：

![a2ae0a38e8f6437ea58263acab7a15c0.png][]

[6432747f2a2146fbb8be6b6be5a7f461.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/25/6499036609054584a9bc217e5039b7f2.png
[a2ae0a38e8f6437ea58263acab7a15c0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/25/ae79e121868648f3b63ff4727bf522b6.png