Java 面向对象设计-处理项目和库存

我在做我的第一个java项目，这是一个基本的角色扮演游戏。我有一个关于物品和存货的问题。首先，我将概述一些类。Item是描述所有项的抽象类。该项的子类是武器（抽象类）和装甲（很有可能在将来还会有一些）。武器有两个子类-MelleWeapon和RangedWeapon。这总结了物品是如何按类处理的。此外，我还有一个Inventory类，它描述每个角色的库存

代码可以工作，但需要一些升级。我至少有两个主要问题：

首先，Item的每个具体子类都有一个getItem方法，该方法几乎相同。如何避免这种代码重复

其次，库存中的addToInventory方法可能会随着我向Item添加更多的子类（很多if/elseif）而变长，所以我猜这是一个糟糕的设计。如何避免优雅地使用if

abstract public class Item {

private String name;
private long cost;
private double weight;

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

public String getName() { return name; }
public void setName(String name) { this.name = name; }

public double getWeight() { return weight; }
public void setWeight(double weight) { this.weight = weight; }

public long getCost() { return cost; }
public void setCost(long cost) { this.cost = cost; }

}


abstract public class Weapon extends Item{

private boolean oneHanded;
private String reqTraining;
private int n;
private int dice;
private int attackBonus;
private int damageBonus;


Weapon(String name, double weight, long cost, boolean oneHanded, String reqTraining,  int n, int dice, int attackBonus, int damageBonus) {
    super(name, weight, cost);
    this.oneHanded = oneHanded;
    this.reqTraining = reqTraining;
    this.n = n;
    this.dice = dice;
    this.attackBonus = attackBonus;
    this.damageBonus = damageBonus;
}


String getReqTraining(){ return reqTraining; }
int getN() { return n; }
int getDice() { return dice; }
int getAttackBonus() {return attackBonus; }
int getDamageBonus(){ return damageBonus; }

public abstract void attack(Character attacker, Character defender);
}



public class Armor extends Item{

private String reqTraining;
private int acBonus;

Armor(String name, String reqTraining, int acBonus,double weight, long cost) {
    super(name, weight, cost);
    this.reqTraining = reqTraining;
    this.acBonus = acBonus;
}

static List<Armor> armorList = new ArrayList<Armor>();

static
{
    armorList.add(new Armor("Full Plate Armor","Heavy", 8, 25, 200));
    armorList.add(new Armor("Chain Mail Armor","Medium", 5, 18, 120));

}

String getReqTraining(){ return reqTraining; }
int getACBonus() { return acBonus; }


public static Armor getItem(String itemName) {
    try {
        for (Iterator<Armor> iter = armorList.iterator(); iter.hasNext(); ) {
            Armor item = iter.next();
            if (itemName.equals(item.getName())) {
                return item;
            }
        }

    } catch (Exception e) {
        System.out.println(itemName + " haven't been found in spells-list");
        return null;
    }
    return null;
}

}




public class  MeleeWeapon extends Weapon {

boolean throwable;

MeleeWeapon(String name,boolean oneHaned, String reqTraining, int n, int dice, int attackBonus, int damageBonus,double weight, long cost, boolean throwable) {
    super(name, weight, cost, oneHaned, reqTraining, n, dice, attackBonus, damageBonus);
    this.throwable = throwable;
}

static List<MeleeWeapon> meleeWeaponList = new ArrayList<MeleeWeapon>();

static
{
    meleeWeaponList.add(new MeleeWeapon("Long Sword",true, "Martial", 1, 8, 0, 0,8, 10, false));
    meleeWeaponList.add(new MeleeWeapon("Short Sword",true, "Martial", 1, 6, 0, 0,5, 5, false));
    meleeWeaponList.add(new MeleeWeapon("Dagger",true, "Basic", 1, 4, 0, 0,2, 3, true));
    meleeWeaponList.add(new MeleeWeapon("Quarter-staff",false, "Basic", 1, 4, 0, 0,3, 2, false));
    meleeWeaponList.add(new MeleeWeapon("Shield",false, "Martial", 1, 4, 0, 0,8, 8, false));

}


public void attack(Character attacker, Character defender){

    int attackRoll = DiceRoller.roll(20) + attacker.getBaseAttackBonus() + attacker.getModifier(attacker.getStrength()) + getAttackBonus() ;
    System.out.println(attacker.getName() + " attack Roll: " + attackRoll + "AC: " + defender.getArmorClass());

    if (attackRoll >= defender.getArmorClass()){
        System.out.println("Defender: " + defender.getName() + " had " + defender.getCurrentHp());
        int damage = DiceRoller.roll(getN(), getDice()) + attacker.getModifier(attacker.getStrength()) + getDamageBonus() ;
        System.out.println("Damage : " + damage);
        defender.setCurrentHp(attacker.getCurrentHp() - damage);
        System.out.println("Defender: " + defender.getName() + " has " + defender.getCurrentHp());
    } else {
        System.out.println("Missed Attack");
    }

}

public static  MeleeWeapon getItem(String itemName) {
    try {
        for (Iterator<MeleeWeapon> iter = meleeWeaponList.iterator(); iter.hasNext(); ) {
            MeleeWeapon item = iter.next();
            if (itemName.equals(item.getName())) {
                return item;
            }
        }

    } catch (Exception e){
        System.out.println(itemName + " haven't been found");
        return null;
    }
    return null;
}


}




public class RangedWeapon extends Weapon {

private String shoots;

RangedWeapon(String name, boolean oneHaned, String reqTraining, String shoots, int n, int dice, int attackBonus, int damageBonus, double weight, long cost) {
    super(name, weight, cost, oneHaned, reqTraining, n, dice, attackBonus, damageBonus);
    this.shoots = shoots;
}


static List<RangedWeapon> rangedWeaponList = new ArrayList<RangedWeapon>();

static {
    rangedWeaponList.add(new RangedWeapon("Long Bow", false, "Archery", "Arrow", 1, 8, 0, 0, 5, 10));
    rangedWeaponList.add(new RangedWeapon("Short Bow", false, "Archery", "Arrow", 1, 6, 0, 0, 3, 5));
}


public void attack(Character attacker, Character defender) {

    int attackRoll = DiceRoller.roll(20) + attacker.getBaseAttackBonus() + attacker.getModifier(attacker.getDexterity()) + getAttackBonus();
    System.out.println(attacker.getName() + " attack Roll: " + attackRoll + "AC: " + defender.getArmorClass());

    if (attackRoll >= defender.getArmorClass()) {
        System.out.println("Defender: " + defender.getName() + " had " + defender.getCurrentHp());
        int damage = DiceRoller.roll(getN(), getDice()) + attacker.getModifier(attacker.getStrength());
        System.out.println("Damage : " + damage);
        defender.setCurrentHp(attacker.getCurrentHp() - damage);
        System.out.println("Defender: " + defender.getName() + " has " + defender.getCurrentHp());
    } else {
        System.out.println("Missed Attack");
    }

}

public static RangedWeapon getItem(String itemName) {
    try {
        for (Iterator<RangedWeapon> iter = rangedWeaponList.iterator(); iter.hasNext(); ) {
            RangedWeapon item = iter.next();
            if (itemName.equals(item.getName())) {
                return item;
            }
        }

    } catch (Exception e) {
        System.out.println(itemName + " haven't been found");
        return null;
    }
    return null;
}

}



public class Inventory {

private Map<String,Item> inventory;

Inventory() {

    inventory = new HashMap<String, Item>();
}


public void showInventory() {

    System.out.println("Show Inventory: ");

    for (Map.Entry<String,Item> entry: inventory.entrySet()) {
        System.out.println(entry.getKey());
        }

    System.out.println(" ");
}


public void addToInventory(String itemName) {

    Item newItem = null;

    try {

        if (MeleeWeapon.getItem(itemName) != null) {
            newItem = MeleeWeapon.getItem(itemName);
        } else if (RangedWeapon.getItem(itemName) != null) {
            newItem = RangedWeapon.getItem(itemName);
        } else if (Armor.getItem(itemName) != null) {
            newItem = Armor.getItem(itemName);
        }else
            System.out.println("Add futural other options (like potions) ");

            System.out.println(newItem.getName() + " has been added to inventory");
            inventory.put(newItem.getName(), newItem);

    } catch (Exception e){
        System.out.println("Adding " + itemName +"to inventory has failed");
    }

}

}

抽象公共类项{
私有字符串名称；
私人长期成本；
私人双倍重量；
公共项目（字符串名称、双倍重量、长期成本）{
this.name=名称；
重量=重量；
成本=成本；
}
公共字符串getName（）{return name；}
public void setName（字符串名）{this.name=name；}
public double getWeight（）{return weight；}
public void setWeight（双重权重）{this.weight=weight；}
public long getCost（）{return cost；}
public void setCost（长期成本）{this.cost=cost；}
}
抽象公共类扩展项{
私人布尔单手；
私人培训；
私人int n；
私人智力骰子；
私人int攻击奖金；
私人伤害奖金；
武器（字符串名称，双倍重量，长成本，布尔单手，字符串训练，整数n，整数骰子，整数攻击加成，整数伤害加成）{
超级（名称、重量、成本）；
这个。单手的=单手的；
this.reqTraining=reqTraining；
这个，n=n；
this.dice=骰子；
this.attackBonus=attackBonus；
this.damageBonus=damageBonus；
}
字符串getReqTraining（）{return reqTraining；}
int getN（）{return n；}
int getDice（）{return dice；}
int getAttackBonus（）{return attackBonus；}
int getDamageBonus（）{return damageBonus；}
公开摘要无效攻击（角色攻击者、角色防御者）；
}
公共类护甲扩展项{
私人培训；
私人红利；
护甲（弦名称、弦训练、智力加成、双倍重量、长成本）{
超级（名称、重量、成本）；
this.reqTraining=reqTraining；
this.acBonus=acBonus；
}
静态列表armorList=newArrayList（）；
静止的
{
增加（新装甲（“全板装甲”，“重型”，8，25，200））；
增加（新护甲（“链甲护甲”，“中等”，5，18，120））；
}
字符串getReqTraining（）{return reqTraining；}
int getACBonus（）{return acBonus；}
公共静态项（字符串itemName）{
试一试{
for（迭代器iter=armorList.Iterator（）；iter.hasNext（）；）{
装甲项目=iter.next（）；
if（itemName.equals（item.getName（）））{
退货项目；
}
}
}捕获（例外e）{
System.out.println（在拼写列表中未找到itemName+）；
返回null；
}
返回null；
}
}
公共级近战武器扩展武器{
布尔可丢弃；
近战武器（字串名称、布尔单选、字串训练、整数n、整数骰子、整数攻击加成、整数伤害加成、双倍重量、长成本、布尔掷骰）{
超级（姓名、重量、成本、单兵、要求训练、n、骰子、攻击加成、伤害加成）；
this.throwable=throwable；
}
静态列表meleeWeaponList=new ArrayList（）；
静止的
{
近战武器列表。添加（新近战武器（“长剑”，真，“军事”，1,8,0,0,8,10,false））；
近战武器列表。添加（新近战武器（“短剑”，真，“军事”，1，6，0，0，5，5，假））；
添加（新的近战武器（“匕首”，正确，“基本”，1，4，0，0，2，3，正确））；
添加（新的近战武器（“四分之一棍”，假，“基本”，1,4,0,0,3,2，假））；
添加（新的近战武器（“盾牌”，假，“军事”，1,4,0,0,8,8，假））；
}
公共无效攻击（角色攻击者、角色防御者）{
int attackRoll=dicerroll.roll（20）+attacker.getBaseAttackBonus（）+attacker.getModifier（attacker.getStrength（））+getAttackBonus（）；
System.out.println（攻击者.getName（）+“攻击骰：”+attackRoll+“AC:”+defender.getArmorClass（））；
if（attackRoll>=defender.getArmorClass（））{
System.out.println（“Defender:+Defender.getName（）+”had“+Defender.getCurrentHp（））；
智力伤害=骰子掷骰（getN（），getDice（））+攻击者.getModifier（攻击者.getStrength（））+getDamageBonus（）；
系统输出打印项次（“损坏：+损坏）；
defender.setCurrentHp（攻击者.getCurrentHp（）-damage）；
System.out.println（“Defender:+Defender.getName（）+”具有“+Defender.getCurrentHp（））；
}否则{
System.out.println（“未遂攻击”）；
}
}
公共静态项目（字符串项目名称）{
试一试{
for（迭代器iter=meleeWeaponList.Iterator（）；iter.hasNext（）；）{
MeleeWearm item=iter.next（）；
if（itemName.equals（item.getName（）））{
退货项目；
}
}
}捕获（例外e）{
System.out.println（未找到itemName+）；
返回null；
}
返回null；
}
}
公共类远程武器扩展武器{
私人串芽；
RangedWeapon（字符串名称、布尔值增强、字符串训练、字符串射击、整数n、整数骰子、整数攻击加成、整数伤害加成、双倍重量、长成本）{
超级（姓名、重量、成本、单兵、要求训练、n、骰子、攻击加成、伤害加成）；
这个.芽=芽；
}
静态列表rangedWeaponList=new ArrayList（）；
静止的{
添加（新的远程武器（“长弓”，假，“射箭”，“箭”，1,8,0,0,5,10））；
rangedWeaponList.add（新RangedWeapon（“短弓”），false，
public static final Armor FULL_PLATE_ARMOR = new Armor("Full Plate Armor","Heavy", 8, 25, 200)