一、实验目的
理解面向对象的概念；
理解继承、封装、多态的实现；
练习使用DEBUG工具调试程序；
二、实验内容
- 某一款游戏，其主要角色如下:
（1） HeavyTank 重型坦克 初始生命值200，攻击力 20
（2） Medium Tank 轻型坦克 初始生命值100，攻击力 10
（3）War Factroy 兵工厂 初始生命值100，无攻击力
（4） Barrack 兵营，可以训练出步枪兵、 RPG兵、军犬,初始生命值100，无攻击力
（5） Rifle soldier 步枪兵 初始生命值50(对战 军犬除外)，攻击力 5（对战军犬可以一次击毙军犬)
（6） Rocket soldier 火箭兵 初始生命值50(对战 军犬除外)，攻击力 10
（7） Dog 军犬 ,初始生命值50，攻击力5(对战人类时候一口毙命)
此外还要能通过Solider.getLivingSoilderCount/getDeadedSoilderCount 统计现在有多少个活着的和死去的士兵数量
任何对象有getHealth() 方法，返回当前生命值，如果已经死亡则返回 <=0的一个数字 任何对象有isDestroyed() 方法，如果生命值<=0则true,否则false
攻击，两个对象之间相互攻击，削减每个对象的健康值。
请遵循以上游戏规则，设计并实现游戏代码，使其能够通过测试用例
三、程序实现
观察测试程序中有EnumObjectType，我们首先定义EnumObjectType类
1
2
3
| public enum EnumObjectType{
rifleSoldier,RPGSoldier,dog,mediumTank,heavyTank;
}
|
观察主要角色的叙述，可以发现每一个对象都有初始生命值和攻击力两个属性
攻击方面如果攻击士兵导致死亡，通过setDeadedSoilderCount来增加死去的士兵数量；如果攻击的是tank或者Dog，那么只削减生命值
通过以上信息，我们可以定义出Game基类和Soilder类
Game基类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
| public class Game {
protected int PH;
protected int attackValue;
public Game(int PH, int av) {
this.PH = PH;
this.attackValue = av;
}
public void attack(Soldier soldier) {
if(soldier.PH >0) {
soldier.PH -= this.attackValue;
if(soldier.PH <=0) {
soldier.setDeadedSoldierCount();
}
}
}
public void attack(Tank tank) {
if(tank.PH >0) {
tank.PH -= this.attackValue;
}
}
public void attack(Dog dog) {
if(dog.PH > 0) {
dog.PH -= this.attackValue;
}
}
public int getHealth() {
return this.PH;
}
public boolean isDestroyed() {
return this.PH <= 0;
}
}
|
有了以上的Game基类，每次构造对象时都可以继承这个基类。
例如：WarFactory是专门造Tank的，通过building方法，在方法内部判断具体是造mediumTank还是HeavyTank
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| public class WarFactory extends Game{
public WarFactory() {
super(100,0);
}
public Tank building(EnumObjectType obj) {
if(obj == EnumObjectType.mediumTank) {
return new MediumTank();
}else if (obj == EnumObjectType.heavyTank) {
return new HeavyTank();
}else {
return null;
}
}
}
|
为了方便building方法返回值的书写，我们构造一个Tank作为父类，让mediumTank和heavyTank作为其子类
1
2
3
4
5
| public class Tank extends Game{
public Tank(int PH, int av) {
super(PH, av);
}
}
|
1
2
3
4
5
| public class MediumTank extends Tank{
public MediumTank() {
super(100,10);
}
}
|
1
2
3
4
5
| public class HeavyTank extends Tank{
public HeavyTank() {
super(200,20);
}
}
|
除了兵工厂WarFactory，还有兵营Barrack，和兵工厂->tank的思路是一样的，Barrack继承Game基类，有traing方法可以产生Soldier，这个soilder正好是RifleSoldier和RPGSoldier的父类，除了士兵还可以产生Dog，具体的代码如下
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| public class Barrack extends Game{
public Barrack() {
super(100,0);
}
public Game traing(EnumObjectType trained) {
if(trained == EnumObjectType.rifleSoldier) {
return new RifleSoldier();
}else if(trained == EnumObjectType.RPGSoldier) {
return new RPGSoldier();
}else if(trained == EnumObjectType.dog) {
return new Dog();
}else {
return null;
}
}
}
|
在Soldier类中，要定义活着的士兵和死去的士兵字段，并且要有对应的getter和setter方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
| public class Soldier extends Game{
private static int livingSoldierCount;
private static int deadSoldierCount;
public Soldier(int PH, int av) {
super(PH,av);
}
public static int getLivingSoldierCount() {
return livingSoldierCount;
}
public static void setLivingSoldierCount() {
livingSoldierCount++;
}
public static int getDeadedSoldierCount() {
return deadSoldierCount;
}
public static void setDeadedSoldierCount() {
deadSoldierCount++;
livingSoldierCount--;
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
| public class RifleSoldier extends Soldier{
public RifleSoldier() {
super(50,5);
super.setLivingSoldierCount();
}
public void attack(Dog dog) {
if(dog.PH > 0) {
dog.PH = 0;
}
}
}
|
1
2
3
4
5
6
| public class RPGSoldier extends Soldier{
public RPGSoldier() {
super(50,10);
super.setLivingSoldierCount();
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
| public class Dog extends Game{
public Dog() {
super(50,5);
}
public void attack(Soldier soldier) {
if(soldier.PH > 0) {
soldier.PH = 0;
soldier.setDeadedSoldierCount();
}
}
}
|
四、测试结果
测试结果
五、实验总结
本次实验较为基础，主要是对面向对象代码设计的基本考察，但还是要注意一些细节，如定义枚举类、梳理好每个对象之间的关系等等