Java基础数组-编写武器数组

题目：

写一个类Army,代表一支军队，这个类有一个属性Weapon数组w（用来存储该军队所拥有的所有武器），
该类还提供一个构造方法，在构造方法里通过传一个int类型的参数来限定该类所能拥有的最大武器数量,
并用这一大小来初始化数组w。

该类还提供一个方法addWeapon(Weapon wa),表示把参数wa所代表的武器加入到数组w中。
在这个类中还定义两个方法attackAll()让w数组中的所有武器攻击；
以及moveAll()让w数组中的所有可移动的武器移动。

代码01：军队类Army.java

/**
 * 军队
 *
 * 类在强制类型转换过程中，如果是类转换成接口类型。
 * 那么类和接口之间不需要存在继承关系，也可以转换，
 * java语法中允许。
 */
public class Army {

    Weapon[] w;


    /**
     * 创建军队的构造方法
     * @param count  武器数量
     */
    public Army(int count){
        // 动态初始化数组中每一个元素默认值是null。
        // 武器数组是有了，但是武器数组中没有放武器。
        this.w = new Weapon[count];
    }


    /**
     * 将武器加入到数组
     * @param wa
     * @throws AddWeaponException
     */
    public void addWeapon(Weapon wa) throws AddWeaponException {
        for(int i=0;i<w.length;i++){
            // 把武器添加到空的位置上。
            if(null == w[i]){
               w[i] = wa;
               return;
            }
        }
        // 程序如果执行到此处说明，武器没有添加成功
        throw new AddWeaponException("武器数组添加异常！");

    }

    /**
     * 所有可攻击的武器攻击
     */
    public void attackAll(){
        //遍历数组
        for(int i=0;i< w.length;i++) {
            // 调用子类中特有的方法，向下转型。
            if (w[i] instanceof Moveable) {
                Moveable move = (Moveable) w[i];
                move.move();
            }
        }

    }

    /**
     * 所有可移动的武器移动
     */
    public void moveAll(){
        for(int i=0;i< w.length;i++){
            if(w[i] instanceof Shootable){
                Shootable shoot = (Shootable) w[i];
                shoot.shoot();
            }
        }
    }
}
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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

代码02：移动接口Moveable

public interface Moveable {

    //武器移动方法
    void move();
}
1
2
3
4
5

代码03：攻击接口Shootable

public interface Shootable {

    //武器攻击方法
    void shoot();
}
1
2
3
4
5

代码04：武器父类Weapon.java

public class Weapon{}
1

代码04：坦克实现类Tank.java

//坦克武器，可以移动，可以攻击
public class Tank extends Weapon implements Moveable,Shootable{
    @Override
    public void move() {
        System.out.println("坦克在移动！");
    }

    @Override
    public void shoot() {
        System.out.println("坦克开炮！");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

代码05：战斗机实现类Fighter.java

//战斗机，可以移动，可以攻击
public class Fighter extends Weapon implements Moveable,Shootable{
    @Override
    public void move() {
        System.out.println("战斗机起飞！");
    }

    @Override
    public void shoot() {
        System.out.println("战斗机开炮！");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

代码06：高射炮实现类GaoShePao.java

//高射炮类，只能攻击，不能移动
public class GaoShePao extends Weapon implements Shootable{

    @Override
    public void shoot() {
        System.out.println("高射炮开炮！");
    }
}
1
2
3
4
5
6
7
8

代码07：物资实现类WuZiFeiJi.java

//运输战机，不能攻击，可以移动
public class WuZiFeiJi extends Weapon implements Moveable{
    @Override
    public void move() {
        System.out.println("运输机起飞！");
    }
}
1
2
3
4
5
6
7

代码08：自定义异常类AddWeaponException.java

public class AddWeaponException extends Exception{

    public AddWeaponException(){

    }

    public AddWeaponException(String s){
        super(s);
    }
}
1
2
3
4
5
6
7
8
9
10

代码08：测试类Test.java

public class Test {
    public static void main(String[] args) {

        //创建一个军队
        Army army = new Army(4);

        //创建坦克，战斗机对象，高射炮对象
        Fighter fighter = new Fighter();
        Tank tank = new Tank();
        GaoShePao gaoShePao = new GaoShePao();
        WuZiFeiJi wuZiFeiJi = new WuZiFeiJi();
        Fighter fighter2 = new Fighter();

        //往数组添加武器
        try {
            army.addWeapon(fighter);
            army.addWeapon(tank);
            army.addWeapon(gaoShePao);
            army.addWeapon(wuZiFeiJi);
            army.addWeapon(fighter2);
        } catch (AddWeaponException e) {
            System.out.println(e.getMessage());
        }

        // 让所有可移动的移动
        army.attackAll();
        // 让所有可攻击的攻击
        army.moveAll();

    }
}

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

测试