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());
}
}
}
结果：
高射炮添加成功
战斗机添加成功
坦克添加成功
运输机添加成功
武器库已满,无法添加!
高射炮已发射！
战斗机已发射!
坦克已射击!
战斗机已起飞!
坦克已移动!
运输机已起飞!
运输机删除成功
坦克删除成功
战斗机删除成功
高射炮删除成功
删除失败，军队武器库已空!
