用Java实现一个小项目

Question

实现一个Java项目，该项目管理一个包含项目数组的Warehouse。所有项都由一个名称和一个权重来表征。
有些物品代表消耗品(food and drinks)，还以有效期为特征。消耗品提供了一个方法isExpired，它表示消耗品是否已经超过了过期日期。

类Food实现了方法eat，它只是打印一个格式化如下的字符串“Eating”+ < the name of the food >。一个食物只有在之前没有吃过并且没有过期的情况下才可以吃。

类Drink实现了方法Drink，它只是打印一个格式化如下的字符串“Drinking”+ < the name of the drink >。一个饮料只有在之前没有喝过并且没有过期的情况下才可以喝。

其他物品是武器(例如炸弹(bombs)和枪支(guns))，任何武器都可以使用。对于炸弹，使用方法应该打印“Boom”。对于枪支，方法使用应该打印“Bang”，并将枪支的子弹数量减少1。
炸弹(Bomb)只能在之前没有使用过的情况下使用。枪（Gun）只有子弹数量大于0的情况下才能使用。

仓库实现了一个方法，根据重量对物品进行排序。为了将一个物品与另一个物品进行比较，每个物品都应该实现Comparable< item >接口。这个接口从Java 8开始就提供了。

创建一个包含main方法的类(例如WarehouseDemo)。这样的方法应该表现得像一个心怀不满的员工，它执行以下操作:
• 创建一个仓库，并向仓库中添加2个食物，2个饮料，1个炸弹和2支枪。其中一种食物和一种饮料应该过期。其中一支枪的子弹数为0，另一支枪的子弹数大于0。
• 将仓库里的物品根据重量进行排序。
• 遍历列表中的物品。对于每一项，打印其所有属性。此外，如果该物品是食物，则调用eat方法。如果项目是饮料，则调用方法drink。如果道具是武器，就应该使用。

建议
• 要执行这个任务，需要利用多态性、抽象类和接口。
• 使用类LocalDate来表示过期日期;
• 尽量避免代码重复
• 对于排序算法，可以简单地使用冒泡排序。为了支持排序，Item应该实现Comparable接口。

Answer 1

import java.util.Arrays;
import java.util.Date;

public class WarehouseDemo {

    public static void main(String[] args) {

        // 创建仓库
        Warehouse warehouse = new Warehouse();

        // 添加物品
        Food food1 = new Food("Apple", 0.2, new Date(120, 6, 1));
        Food food2 = new Food("Banana", 0.3, new Date(120, 7, 1));
        Drink drink1 = new Drink("Water", 0.5, new Date(120, 6, 10));
        Drink drink2 = new Drink("Juice", 0.8, new Date(120, 7, 15));
        Bomb bomb = new Bomb("Atomic Bomb", 1000);
        Gun gun1 = new Gun("Pistol", 5);
        Gun gun2 = new Gun("Rifle", 0);

        warehouse.addItem(food1);
        warehouse.addItem(food2);
        warehouse.addItem(drink1);
        warehouse.addItem(drink2);
        warehouse.addItem(bomb);
        warehouse.addItem(gun1);
        warehouse.addItem(gun2);

        // 按重量排序
        Arrays.sort(warehouse.getItems());

        // 遍历仓库中的物品
        for (Item item : warehouse.getItems()) {
            System.out.println("Name: " + item.getName() + ", Weight: " + item.getWeight());
            if (item instanceof Consumable) {
                Consumable consumable = (Consumable) item;
                if (consumable.isExpired()) {
                    System.out.println("This item has expired.");
                } else {
                    if (item instanceof Food) {
                        ((Food) item).eat();
                    } else {
                        ((Drink) item).drink();
                    }
                }
            } else if (item instanceof Weapon) {
                Weapon weapon = (Weapon) item;
                if (weapon instanceof Bomb) {
                    ((Bomb) weapon).use();
                } else {
                    ((Gun) weapon).use();
                }
            }
        }
    }

}


class Warehouse {

    private Item[] items = new Item[0];
    private int index = 0;

    public void addItem(Item item) {
        if (item != null) {
            if (index == items.length) {
                Item[] newItems = new Item[index + 1];
                for (int i = 0; i < index; i++) {
                    newItems[i] = items[i];
                }
                items = newItems;
            }
            items[index] = item;
            index++;
        }
    }

    public Item[] getItems() {
        return items;
    }

}


class Item implements Comparable<Item> {

    private String name;
    private double weight;

    public Item(String name, double weight) {
        this.name = name;
        this.weight = weight;
    }

    public String getName() {
        return name;
    }

    public double getWeight() {
        return weight;
    }

    @Override
    public int compareTo(Item o) {
        if (this.weight > o.weight) {
            return 1;
        } else if (this.weight < o.weight) {
            return -1;
        } else {
            return 0;
        }
    }

}


interface Consumable {

    boolean isExpired();

}


class Food extends Item implements Consumable {

    private Date expiryDate;
    private boolean eaten = false;

    public Food(String name, double weight, Date expiryDate) {
        super(name, weight);
        this.expiryDate = expiryDate;
    }

    @Override
    public boolean isExpired() {
        return expiryDate.before(new Date());
    }

    public void eat() {
        if (!eaten && !isExpired()) {
            System.out.println("Eating " + getName());
            eaten = true;
        } else {
            System.out.println("This food cannot be eaten.");
        }
    }

}


class Drink extends Item implements Consumable {

    private Date expiryDate;
    private boolean drank = false;

    public Drink(String name, double weight, Date expiryDate) {
        super(name, weight);
        this.expiryDate = expiryDate;
    }

    @Override
    public boolean isExpired() {
        return expiryDate.before(new Date());
    }

    public void drink() {
        if (!drank && !isExpired()) {
            System.out.println("Drinking " + getName());
            drank = true;
        } else {
            System.out.println("This drink cannot be drunk.");
        }
    }

}


interface Weapon {

    void use();

}


class Bomb extends Item implements Weapon {

    private boolean used = false;

    public Bomb(String name, double weight) {
        super(name, weight);
    }

    public void use() {
        if (!used) {
            System.out.println("Boom");
            used = true;
        } else {
            System.out.println("This bomb cannot be used.");
        }
    }

}


class Gun extends Item implements Weapon {

    private int bullets;

    public Gun(String name, double weight) {
        super(name, weight);
        bullets = (int) weight;
    }

    public void use() {
        if (bullets > 0) {
            System.out.println("Bang");
            bullets--;
        } else {
            System.out.println("This gun has no bullets left.");
        }
    }
}