JavaExample08-Weapon

JavaExample08-Weapon

1.题目要求

写一个类Arm,代表一支军队，这个类有一个类型为Weapon的数组weapons(用于存储该军队所拥有的所有武器)。

该类提供一个有参构造方法，在该构造方法中通过传入一个int类型的参数来限定该类所能拥有的最大武器数量，并用这一大小来初始化数组weapons。还提供一个无参构造方法用于设置默认最大武器数量。

该类还提供一个方法addWeapon(Weapon newWeapon)，表示把参数newWeapon代表的武器加入到数组weapons中。

在该类中还定义两个方法:

• attackAll()让数组weapons中所有能攻击的武器攻击
• moveAll()让数组weapons中所有能移动的武器移动

写一个测试程序去测试以上功能。

提示：

• Weapon是一个父类，应该有很多子武器
• 子武器有一些可移动的，也有一些可攻击的

2.代码实现

2.1所有武器父类

package attribute;

import java.util.Objects;

/**
 * @Author: TSCCG
 * @Date: 2021/06/25 16:56
 * 武器类
 */
public class Weapon {
    /**
     * 定义武器名，使用final修饰，不可更改
     */
    final String name;

    //定义构造方法
    public Weapon(String name) {
        this.name = name;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        Weapon weapon = (Weapon) o;
        return Objects.equals(name, weapon.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name);
    }

    @Override
    public String toString() {
        return name;
    }
}

2.2可移动接口和可攻击接口

2.2.1可移动接口

package attribute;

/**
 * @Author: TSCCG
 * @Date: 2021/06/25 16:58
 * 可移动的
 */
public interface Moveable {
    /**
     * 移动
     */
    void move();
}

2.2.2可攻击接口

package attribute;

/**
 * @Author: TSCCG
 * @Date: 2021/06/25 16:57
 * 可射击的
 */
public interface Shootable {
    /**
     * 射击
     */
    void shoot();
}

2.3子武器类

2.3.1高射炮类

package weapons;

import attribute.Shootable;
import attribute.Weapon;

/**
 * @Author: TSCCG
 * @Date: 2021/06/25 17:00
 * 高射炮,只能射击，无法移动
 */
public class AntiaircraftGun extends Weapon implements Shootable {
    public AntiaircraftGun() {
        super("高射炮");
    }

    @Override
    public void shoot() {
        System.out.println("高射炮已发射！");
    }
}

2.3.2战斗机类

package weapons;

import attribute.Moveable;
import attribute.Shootable;
import attribute.Weapon;

/**
 * @Author: TSCCG
 * @Date: 2021/06/25 17:08
 * 战斗机，可射击，可移动
 */
public class Fighter extends Weapon implements Shootable,Moveable {
    public Fighter() {
        super("战斗机");
    }

    @Override
    public void move() {
        System.out.println("战斗机已起飞!");
    }

    @Override
    public void shoot() {
        System.out.println("战斗机已发射!");
    }
}

2.3.3坦克类

package weapons;

import attribute.Moveable;
import attribute.Shootable;
import attribute.Weapon;

/**
 * @Author: TSCCG
 * @Date: 2021/06/25 17:12
 * 坦克，可射击，可移动
 */
public class Tank extends Weapon implements Shootable, Moveable {

    public Tank() {
        super("坦克");
    }

    @Override
    public void move() {
        System.out.println("坦克已移动!");
    }

    @Override
    public void shoot() {
        System.out.println("坦克已射击!");
    }
}

2.3.4运输机类

package weapons;

import attribute.Moveable;
import attribute.Weapon;

/**
 * @Author: TSCCG
 * @Date: 2021/06/25 17:14
 * 运输机，可移动，不能射击
 */
public class TransportPlane extends Weapon implements Moveable {
    public TransportPlane() {
        super("运输机");
    }

    @Override
    public void move() {
        System.out.println("运输机已起飞!");
    }
}

2.4自定义异常类

/**
 * @Author: TSCCG
 * @Date: 2021/06/25 17:35
 * 武器添加异常
 */
public class WeaponException extends Exception{
    public WeaponException() {
    }
    public WeaponException(String s) {
        super(s);
    }
}

2.5军队类

import attribute.Moveable;
import attribute.Shootable;
import attribute.Weapon;

/**
 * @Author: TSCCG
 * @Date: 2021/06/25 17:20
 * 军队，可添加武器，可让所有的武器能射击的射击，能移动的移动
 */
public class Arm {
    /**
     * 定义存放武器的数组
     */
    private Weapon[] weapons;
    /**
     * 定义数组当前长度的下标
     */
    private int currentIndex = -1;

    /**
     * 构造方法
     * @param number
     * 武器的数量
     */
    public Arm(int number) {
        weapons = new Weapon[number];
    }
    /**
     * 无参构造方法
     * 定义默认情况下可存放武器的数量
     */
    public Arm() {
        this(10);
    }

    /**
     * 添加武器
     */
    public void addWeapon(Weapon newWeapon) throws WeaponException {
        if (currentIndex < weapons.length - 1) {
            weapons[++currentIndex] = newWeapon;
            System.out.println(newWeapon + "添加成功");
        } else {
            throw new WeaponException("武器库已满,无法添加!");
        }
    }

    /**
     * 删除武器(尾删)
     * @throws WeaponException 越界异常
     */
    public void removeWeapon() throws WeaponException {
        if (currentIndex < 0) {
            throw new WeaponException("删除失败，军队武器库已空!");
        }
        Weapon tempWeapon = weapons[currentIndex];
        currentIndex--;
        System.out.println(tempWeapon + "删除成功");

    }

    /**
     * 删除武器(指定下标)
     * @param index 指定要删除的武器下标
     * @throws WeaponException 越界异常
     */
    public void removeWeapon(int index) throws WeaponException {
        if (index < 0 || index > currentIndex) {
            throw new WeaponException("删除失败，军队中没有此武器!");
        }
        Weapon tempWeapon = weapons[index];
        for (int i = index; i < currentIndex; i++) {
            weapons[i] = weapons[i + 1];
        }
        System.out.println(tempWeapon + "删除成功");
        currentIndex--;
    }
    /**
     * 所有武器攻击
     */
    public void shootAll(){
        //遍历武器数组
        for (int i = 0; i <= currentIndex; i++) {
            //设定一秒一发射
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //判断当前武器是否能射击
            if (weapons[i] instanceof Shootable) {
                //将当前武器转化为Shootable类型，使得能够调用shoot()方法
                Shootable shootable = (Shootable)weapons[i];
                shootable.shoot();
            }
        }
    }
    /**
     * 所有武器移动
     */
    public void moveAll(){
        //遍历武器数组
        for (int i = 0; i <= currentIndex; i++) {
            //设定一秒一移动
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //判断当前武器是否能移动
            if (weapons[i] instanceof Moveable) {
                //将当前武器转化为Moveable类型，使得能够调用move()方法
                Moveable moveable = (Moveable) weapons[i];
                moveable.move();
            }
        }
    }
}

2.6测试类

import weapons.AntiaircraftGun;
import weapons.Fighter;
import weapons.Tank;
import weapons.TransportPlane;

/**
 * @Author: TSCCG
 * @Date: 2021/06/25 17:50
 * 测试
 */
public class Test {
    public static void main(String[] args){
        Arm arm = new Arm(4);
        try {
            arm.addWeapon(new AntiaircraftGun());
            arm.addWeapon(new Fighter());
            arm.addWeapon(new Tank());
            arm.addWeapon(new TransportPlane());
            arm.addWeapon(new TransportPlane());
        } catch (WeaponException e) {
            System.out.println(e.getMessage());
        }
        arm.shootAll();
        arm.moveAll();
        try {
            arm.removeWeapon();
            arm.removeWeapon();
            arm.removeWeapon();
            arm.removeWeapon();
            arm.removeWeapon();
        } catch (WeaponException e) {
            System.out.println(e.getMessage());
        }
    }
}

结果：

高射炮添加成功
战斗机添加成功
坦克添加成功
运输机添加成功
武器库已满,无法添加!
高射炮已发射！
战斗机已发射!
坦克已射击!
战斗机已起飞!
坦克已移动!
运输机已起飞!
运输机删除成功
坦克删除成功
战斗机删除成功
高射炮删除成功
删除失败，军队武器库已空!