Java: создание нескольких отдельных объектов из одного базового типа. TextAdventure

Question

В моей маленькой текстовой игре у меня есть класс Item, который загружает свои объекты из файла .txt, а затем добавляет объект в ArrayList типа Item.Я пытаюсь обновить с помощью метода upgrade () в классе Item.Это работает, но если у меня есть два одинаковых предмета в моем инвентаре, так как они ссылаются на один и тот же предмет, если я обновляю один, я обновляю все предметы этого типа.

Есть ли способ создать новый Предмет (Бронзовый Шлем), который при создании будет таким же, как Бронзовый Шлем, загруженный из текстового файла, но при обновлении он не изменит исходный объект в статическом состоянии?шлем ArrayList в Item.java.

метод openInventory () из класса Игрока:

public void openInventory(){
        //newWindow();
        int selection;
        boolean upgraded = false;

            backPack.printInventory(this);
            println("[1] UseItem  [2] Upgrade Item  [3] Item Details");
            selection = getInt();
            if(selection == 1){
                println("Type the number of the corresponding Item Slot you would like to use.");
                    int itemNum = (getInt() - 1);
                    Item itemSelection = backPack.itemSlot[itemNum].oi;
                    if(backPack.itemSlot[itemNum].stack.size() > 0){
                        itemSelection = backPack.itemSlot[itemNum].stack.get(0);
                    }
                    itemSelection.printStats();
                    this.useItem(itemSelection);
            }
            if(selection == 2){

                int sInt;
                Item scroll = new Item();
                Item item = new Item();

                while(upgraded == false){
                    println("Pick a scroll");
                    sInt = getInt();
                    if(backPack.itemSlot[sInt - 1].oi.type.equals("scroll")){
                        scroll = backPack.itemSlot[sInt - 1].oi;
                    }
                    else
                        println("Not a Scroll");

                    println("Pick which " + scroll.category + " to upgrade.");
                    sInt = getInt();
                    if(backPack.itemSlot[sInt - 1].oi.type.equals(scroll.category)){
                        item = backPack.itemSlot[sInt - 1].oi;
                    }
                    else
                        println("Wrong type of Item");

                    if(scroll.name != "None" && item.name != "None"){
                        backPack.itemSlot[sInt - 1].oi.upgrade(scroll);
                        upgraded = true;
                    }
            }
        }
            if(selection == 3){
                println("Pick item to display details.");
                int i = getInt();

                backPack.itemSlot[i - 1].oi.printStats();
            }
    }

Инвентаризация после обновления одного из бронзовых шлемов

—————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————
[1]  Bronze Helmet [+1]  [2]  Bronze Helmet [+1]  [3]  Helmet Def Scroll   [4]  None                [5]  None                

[6]  None                [7]  None                [8]  None                [9]  None                [10] None                
—————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————
                                                        [Gold]:  $50
—————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————

Предмет.java:

import static com.projects.aoa.Print.*;
import static com.projects.aoa.Input.*;

import java.util.*;
import java.io.*;

class Item {

    //Item
    String name, type, category, statUpgrade;
    int remSlots, maxSlots, upgraded, probability, statIncrease;
    int hp, mp, str, def, atk, dex, duration;
    Area shopPurchased;


    //Inventory
    public boolean filled;
    public int count, stackLimit;


    public static List<Item> helmets = new ArrayList<Item>();
    public static List<Item> potions = new ArrayList<Item>();
    public static List<Item> swords = new ArrayList<Item>();
    public static List<Item> scrolls = new ArrayList<Item>();

    Item(){
        name = "None";
        maxSlots = 5;
        remSlots = 5;
    }
    public String toString(){
        return (name);
    }

    static void loadItems(){

        try {
            //System.out.println(System.getProperty("user.dir"));

            FileInputStream fstream = new FileInputStream(System.getProperty("user.dir") 
                    + "/LoadFiles/" + "itemLoad.txt");

            DataInputStream in = new DataInputStream(fstream);

            BufferedReader br = new BufferedReader(new InputStreamReader(in));

            String line, itemType = "none";
            int counter = 0;
            Item newItem = new Item();

             while((line = br.readLine()) != null) {
                 if(line.length() == 0){
                        newItem.printStats();
                        if(itemType.equals("helmet")){
                            helmets.add(newItem);
                        }
                        if(itemType.equals("potion")){
                            potions.add(newItem);
                        }
                        if(itemType.equals("sword")){
                            swords.add(newItem);
                        }
                        if(itemType.equals("scroll")){
                            scrolls.add(newItem);
                        }
                        counter = -1;
                        }
                 if(line.equals("#"))
                     break;

                switch(counter) {
                    case -1:
                        counter++;
                        break;

                    case 0:

                        itemType = line;
                        counter++;
                        break;


                    case 1:
                        if(itemType.equals("helmet")){
                            //tempName = line;
                            newItem = new Helmet(line);
                            newItem.type = itemType;
                        }
                        if(itemType.equals("potion")){
                            newItem = new Potion(line);
                            newItem.type = itemType;
                        }
                        if(itemType.equals("sword")){
                            newItem = new Sword(line);
                            newItem.type = itemType;
                        }
                        if(itemType.equals("scroll")){
                            newItem = new Scroll(line);
                            newItem.type = itemType;
                            counter = 9;
                        }
                        counter++;
                        break;

                    case 2:
                        newItem.hp = Integer.parseInt(line);
                        counter++;
                        break;

                    case 3:
                        newItem.mp = Integer.parseInt(line);
                        counter++;
                        break;

                    case 4:
                        newItem.def = Integer.parseInt(line);
                        counter++;
                        break;

                    case 5:
                        newItem.str = Integer.parseInt(line);
                        counter++;
                        break;

                    case 6:
                        newItem.atk = Integer.parseInt(line);
                        counter++;
                        break;

                    case 7:
                        newItem.dex = Integer.parseInt(line);
                        counter++;
                        break;

                    case 8:
                        newItem.stackLimit = Integer.parseInt(line);
                        counter++;
                        break;

                    case 9:
                        newItem.duration = Integer.parseInt(line);
                        counter++;
                        break;
                    case 10:
                        newItem.category = line;
                        counter++;
                        break;
                    case 11:
                        newItem.statUpgrade = line;
                        counter++;
                        break;
                    case 12:
                        newItem.statIncrease = Integer.parseInt(line);
                        counter++;
                        break;
                    case 13:
                        newItem.probability = Integer.parseInt(line);
                        counter++;
                        break;
                }

             }

                in.close();

        } catch (Exception e) {
            e.printStackTrace();
        }
    } 


    void printStats(){
        line();
        println("[" + name + "]");
        println("Type: " + type);
        println("Stack Limit: " + stackLimit);
        println("Duration: " + duration);
        println("HP:  " + hp);
        println("MP:  " + mp);
        println("Def: " + def);
        println("Str: " + str);
        println("Atk: " + atk);
        println("Dex: " + dex);
    }

    void upgrade(Item scroll){
        Random rand = new Random();

        int geti;

            if(remSlots > 0){
                if(this.type.equals(scroll.category)){
                    int prob = rand.nextInt(99);
                     println("Prob: " + prob);

                     if(prob < scroll.probability){
                         if(scroll.statUpgrade.equals("def")){
                             this.def += scroll.statIncrease;
                             this.upgraded++;
                             println("Upgraded: " + this.upgraded);
                         }
                     }

                     remSlots--;
                        println("Slots: " + this.remSlots + " / " + this.maxSlots);
                }
        }
            else
                println("No slots remaining.");
    }

static Item getItem(String searchedName){

        Item item = new Item();

        for(int i = 0; i < potions.size(); i++){
            if(potions.get(i).name.equals(searchedName)){
                item = potions.get(i);
                return item;
            }
        }
        for(int i = 0; i < helmets.size(); i++){
            if(helmets.get(i).name.equals(searchedName)){
                item = helmets.get(i);
                return item;
            }
        }
        for(int i = 0; i < swords.size(); i++){
            if(swords.get(i).name.equals(searchedName)){
                item = swords.get(i);
                return item;
            }
        }

        for(int i = 0; i < scrolls.size(); i++){
            if(scrolls.get(i).name.equals(searchedName)){
                item = scrolls.get(i);
                return item;
            }
        }
        return item;
    }
}

Инвентарь:

public class Inventory {

    int useableSlots, slots = 50;
    Itemslot[] itemSlot = new Itemslot[slots];


    Inventory(int slots){
        this.useableSlots = slots;
    }

    public void printInventory(Player playerOne){
        newWindow(5);

        int excess, lineTotal = 0, invSlotSize = 25, maxLineLength = 125;
        String invItem, difference = "";
        String inventoryTitle = "[" + playerOne.name + "'s BackPack]";
        String invTitleIndent = "";

        for(int i = 0; i < (maxLineLength - inventoryTitle.length()) / 2; i++){
            invTitleIndent += " ";
        }

        println(invTitleIndent + inventoryTitle);

        printMult("—", maxLineLength);

        line();


        for(int i = 0; i < useableSlots; i++){

            if(lineTotal >= maxLineLength){
                line();
                lineTotal = 0;
                line();
            }

            if(i < 9){
                difference = " ";
            }
            else{
                difference = "";
            }

            invItem = ("[" + (i + 1) + "] " + difference);
            if(itemSlot[i].stack.size() > 0){
                invItem += (itemSlot[i].stack.get(0).name + "(" + itemSlot[i].stack.size() + ")");
            }
            else {
                invItem += itemSlot[i].oi.name;

                if(itemSlot[i].oi.upgraded > 0){
                    invItem += " [+" + itemSlot[i].oi.upgraded + "]";
                }
            }


            excess = (invSlotSize - invItem.length());

            for(int v = 0; v < excess; v++){
                invItem += " ";
            }

            //print(invItem.length());
            print(invItem);

            lineTotal += invItem.length();

        }

        line();
        printMult("—", maxLineLength);
        line();

        String printGold = "[Gold]:  $" + playerOne.gold;
        String goldIndent = "";     

        for(int i = 0; i < (maxLineLength - printGold.length()) / 2; i++){
            goldIndent += " ";
        }

        println(goldIndent + printGold);

        printMult("—", maxLineLength);
        line();

        line(2);

    }


    void addItem(Item item){
    for (int i = 0; i < useableSlots; i++){
        if (itemSlot[i].occupied == false) {
            itemSlot[i].oi = item;
            itemSlot[i].occupied = true;
            break;
        }
    }
}

ItemSlot:

public class Itemslot extends Item{

    List<Item> stack = new ArrayList<Item>();
    Item oi = new Item();
    boolean occupied;

}

Скорее всего, я просто глуп, но помогу в решении этой проблемы,или какое направление было бы желательно.

РЕДАКТИРОВАТЬ: Решено

добавлен конструктор копирования в Item

Item(Item item){
        this.name = item.name;
        this.type = item.type;
        this.category = item.category;
        this.statUpgrade = item.statUpgrade;
        this.remSlots = item.remSlots;
        this.maxSlots = item.maxSlots;
        this.upgraded = item.upgraded;
        this.probability = item.probability;
        this.statIncrease = item.statIncrease;
        this.hp = item.hp;
        this.mp = item.mp;
        this.str = item.str;
        this.def = item.def;
        this.atk = item.atk;
        this.dex = item.dex;
        this.duration = item.duration;
    }

изменен addItem

void addItem(Item item){
        Item newItem = new Item(item);
        for (int i = 0; i < useableSlots; i++){
            if (itemSlot[i].occupied == false) {
                itemSlot[i].oi = newItem;
                itemSlot[i].occupied = true;
                break;
            }
        }
    }

Answer 1

вместо того, чтобы иметь два объекта для одного и того же предмета в инвентаре, оставьте один объект и счетчик.(conter скажет вам, сколько предметов представляет объект)

Answer 2

Скорее, чем

Item newItem = new Item();

for ... 
  helmets.add(newItem);

не должно быть

for ...
  helmets.add(new Item());

или

for ...
  Item newItem = new Item();
  helmets.add(newItem);

Answer 3

Рекомендуемый способ копирования объектов в соответствии с Эффективной Java 2 - предоставить конструктор копирования

public Foo(Foo foo){
//.. copy all members
this.name=foo.name;
this.age=foo.age;

}

Обратите внимание, что метод clone нарушен в Java, по той же книге.

Я думаю, что ваш подход неправильный, вместо этого вы можете записать свой объект в файл данных, используя ObjectInputStream и ObjectOutputStream

public class Item implements java.io.Serializable{
  ....
}

{
  Item item=new Item();
  ObjectInputStream stream=new ObjectInputStream(fileStream);
  stream.write(item);
}

Answer 4

Я не прочитал весь код, однако addItem выглядит подозрительно для меня и может вызвать вашу проблему:

    void addItem(Item item){
    Item newItem = new Item();
    newItem = item;
    for (int i = 0; i < useableSlots; i++){
        if (itemSlot[i].occupied == false) {
            itemSlot[i].oi = newItem;
            itemSlot[i].occupied = true;
            break;
        }
    }
    }

Что вы, вероятно, хотите сделать здесь, это

   newItem = item.clone()

Это всего лишь предположение, поскольку я не знаю, как вы на самом деле звоните addItem.

http://en.wikipedia.org/wiki/Clone_(Java_method)

РЕДАКТИРОВАТЬ: Я только что видел, как вы звонитеaddItem в loadItems.Либо вы делаете то, что предлагает Том Ингрэм, либо изменяете реализацию addItem.Эффект должен быть таким же.

EDIT 2: Если вы не планируете создавать подклассы Item, это будет быстрое решение:

 void addItem(){
 Item newItem = new Item();
 for (int i = 0; i < useableSlots; i++){
     if (itemSlot[i].occupied == false) {
         itemSlot[i].oi = newItem;
         itemSlot[i].occupied = true;
         break;
     }
 }
 }