军队加武器

军队武器配置小实例

1. 一个军队类
2. 多个武器类
3. 有的武器可攻击，有的武器可移动
4. 让可移动的武器移动，让可攻击的武器攻击
5. 向军队添加武器，超出武器数目抛出自定义的异常

代码如下：

枪类:

/*
    手枪，可攻击
 */
public class Gun extends Weapon implements Attackable{

    @Override
    public void shoot() {
        System.out.println("Gun shooting...");
    }
}

导弹类：

/*
    导弹，可飞行，可攻击
 */
public class Missile extends Weapon implements Moveable, Attackable{
    @Override
    public void shoot() {
        System.out.println("Missile shooting...");
    }

    @Override
    public void move() {
        System.out.println("Missile flying...");

    }
}

坦克类：

/*
    坦克，可移动，可攻击
 */
public class Tank extends Weapon implements Moveable, Attackable{
    @Override
    public void shoot() {
        System.out.println("Tank moving...");
    }

    @Override
    public void move() {
        System.out.println("Tank attacking...");

    }
}

武器类：

/*
    所有武器的父类
 */
public class Weapon {
    @Override
    public String toString() {
        return "当前武器";
    }
}

添加武器异常类：

/**
 * 添加武器越界异常
 */
public class WeaponAddException extends Exception {
    public WeaponAddException() {
    }

    public WeaponAddException(String message) {
        super(message);
    }
}

可移动接口：

/*
    可移动的
 */
public interface Moveable {
    void move();
}

可攻击接口：

/*
    可攻击的
 */
public interface Attackable {
    void shoot();
}

军队类：

/**
 * 军队类
 */
public class Army {

    // 武器数组
    private Weapon[] w1;

    /**
     * 创建军队的构造方法
     * @param count 军队含有的武器的数目
     */
    public Army(int count){
        w1 = new Weapon[count];
    }

    /**
     * 将武器加入数组
     * @param weapon
     */
    public void addWeapon(Weapon weapon) throws WeaponAddException{

        for (int i = 0; i < w1.length ; i++) {
            if (null == w1[i]){ // 注意这里的写法
                w1[i] = weapon;
                System.out.println(weapon + "添加成功");
                return;
            }
        }
        // 程序执行至此说明武器添加失败
        throw new WeaponAddException("武器数量已满！");

    }

    /**
     * 所有可攻击的武器攻击
     */
    public void attackAll(){
        for (int i = 0; i < w1.length; i++) {

            // 说明：类在强制类型转换过程中，如果是类强转为接口类型，
            // 那么类与接口之间不存在继承关系也可以转换，Java语法允许

            if (w1[i] instanceof Attackable){// 判断武器是否可攻击
                Attackable a = (Attackable)w1[i];
                a.shoot();
            }
        }

    }

    /**
     * 所有可移动的武器移动
     */
    public void moveAll(){
        for (int i = 0; i < w1.length; i++) {

            if (w1[i] instanceof Moveable){// 判断武器是否可攻击
                Moveable m = (Moveable)w1[i];
                m.move();
            }
        }
    }
}

测试程序：

/*
    测试类
 */
public class Test {
    public static void main(String[] args) {

        Army a1 = new Army(3); // 武器数目设置成为3

        Weapon w1 = new Gun();
        Weapon w2 = new Missile();
        Weapon w3 = new Tank();
        Weapon w4 = new Gun();

        try {
            a1.addWeapon(w1);
            a1.addWeapon(w2);
            a1.addWeapon(w3);

            a1.addWeapon(w4); // 超出数目限定

            System.out.println("这里的代码不会执行");

        } catch (WeaponAddException e) {
            System.out.println(e.getMessage());
        }

        a1.moveAll();
        a1.attackAll();
    }
}