Objekte sind in Java die Regel, Arrays die Ausnahme.
Wenn einem das Angst macht gibt es ja noch C
Jetzt hab ich
import java.util.*;
public class ItemLoader
{
public String itemnormpath;
public int itemSize;
// String path = Helper.buildUp("C:","sys","items",path+".txt");
public ItemLoader(String itemnormpath)
{
this.itemnormpath = itemnormpath;
}
public ItemLoader loadItem(String itemName)
{
//pfad aufbauen mit jedem item ein n euer name
File itemFile = new File(itemnormpath,itemName+".txt");
Scanner sc = new Scanner(itemFile);
if (!itemFile.exists())
{
System.out.println(itemnormpath + itemName + ".txt not found.");
}
List itemList = new ArrayList();
for ( int i = 0; i < itemSize; i++) // laden
{
String k;
k = sc.nextLine(); //Ueberprueft ob ein Wert nicht geladen werden konnte.
itemList.add(sc.nextLine()); // Addet alle elemente der Liste
if (k.equals("")) //Ueberprueft ob ein Wert nicht geladen werden konnte.
{
System.out.println(itemnormpath + itemName + ".txt is missing something.");
}
}
//----------------------------------------------------
Item it = new Item();
return new Item(name,quote,maxlife);
}
}
Weiß aber nicht wie ich aus der Liste elemente nun zu Variablen verarbeiten kann?
Das mit dem Path hat sich immernoch nicht gelöst.
Zeile 43 zu 48: nur ein Item-Objekt erzeugen, im Moment Zeile 43 überflüssig,
die gelesehen Zeilen werden bisher auch gar nicht ins Item eingefügt,
eher doch so:
Scanner sc = new Scanner(weapons);
for (int i = 0; i < itemsize ; i++) // speist die textdatei in arraylists
{
Item i = new Item();
i.name = sc.nextLine(); // oder set-Methode
i.quote = sc.nextLine(); // oder set-Methode
i.almaxlife = sc.nextLine()); // oder set-Methode
usw.
dann werden natürlich mehrere Items erzeugt, z.B. in eine Liste speichern, kein Rückgabewert oder Liste Rückgabewert,
pff, soviele Dinge zu bauen und zu bedenken (das hier letzte Zeile im edit nach unterem), da kann man ja dein ganzes Programm schreiben…
das neue Objekt muss sicherlich längerfristig gemerkt werden, kann in eine Liste,
zur Not auch erstmal statisch wie bisher (nur noch EINE Liste von Items ist schon ein bedeutender Fortschritt gegenüber FÜNFZEHN Listen von Strings & Co.)
im Moment ist das Item der Rückgabewert und nicht erkennbar, was der Aufrufer damit macht,
Attribute herausholen sollte zu den Grundlagen gehören,
wo immer du bisher xyListe.get(4) hat steht als erste Umwandlung z.B.
Item item = itemListe.get(4);
..
String xy = item .xy oder item .getXy(); // mit aktuellen item arbeiten, nicht überall Index 4 zu wissen nötig
wie ist der Stand?
von
public String path;
public void weaponName(String x)
{
path = x;
path = path.toLowerCase();
path = path.trim();
System.out.println(path);
} ```
ist die grundsätzliche Korrektur
```public File weapons;
public String path;
public void weaponName(String x)
{
path = x;
path = path.toLowerCase();
path = path.trim();
System.out.println(path);
weapons = new File("C:"+File.separator+"sys"+File.separator+"weapons"+File.separator+path+".txt");
} ```
-> erst in der Methode mit bekannten Path kann das File-Objekt erstellt werden, nicht vorher,
noch intelligenterer ist aber der Code von EikeB: die brauchst das File nur temporär beim Laden,
muss kein Attribut der Klasse sein, ob statisch oder nicht, erst zum Lesen aktuell zusammenbauen,
dann auch weniger Fragen, ob alle Infomationen gesetzt sindIst mir auch aufgefallen ebend ich Dusel :D.
Sagt er kann das Object nicht zu Item machen
for ( int i = 0; i < itemList.size(); i++) // laden
{
Item s = itemList.get(i);
String a = a.s;
}
Wo ergibt das Sinn wenn sich i immer ändern muss ?
Jedes Item ist eine eigene Textdatei mit ca. 14 Zeilen
Ich möchte nun jedes mal mit
Item rusty_dagger = new Item();
Alle Attribute des Items in eine Liste schicken, sodass ich sagen kann das Item mit Index1 besetzt die ersten 14 Zeilen der Liste.
Das nächste Item die nächsten 14.
Wenn ich also dann sage ich möchte vom Schwert mit dem Index (414-514) wissen wieviel Schaden es macht, das ich das jederzeit aufrufen kann.
Mit der ArrayList hat das perfekt funktioniert, aber alles static. Das eigentlich Problem war nur der Pfad 
Ich will aber gut programmieren deswegen jetzt OO.
i.name = sc.nextLine(); // oder set-Methode
i.quote = sc.nextLine(); // oder set-Methode
i.almaxlife = sc.nextLine()); // oder set-Methode
Das mit dem Pfad ist nun wie von eike.
{
this.itemnormpath = itemnormpath;
}
und
Scanner sc = new Scanner(itemFile);```
Danke(Y)Klassen sind keine neue Mächtigkeit, jedes Programm der Welt kann auch mit den einfachen Listen geschrieben werden, das ist klar,
man müsste statt eines konkreten Objektes immer nur den Index weiterreichen,
in gewisser Weise ist das ja auch schon so, jede Variable auf ein Objekt besteht aus 4 Bytes, einer Speicheradresse zum eigentlichen Objekt,
wenn du deine Listen nie in der Reihenfolge änderst oder was löschst dann ist das eine ähnliche Simulation von Arbeitsspeicher
was du mit 414-514 (zumal negativ) meinst verstehe ich nicht ganz, du verteiltest doch bisher die Daten, in jeder Liste einen Eintrag,
allerdings kann man bei nur 1x Daten pro Datei die for-Schleife beim Einlesen auch als kaputt ansehen so dass leere Zeilen in die Listen kamen
ob aktuell eine Frage besteht ist nicht so gut zu erkennen,
anscheinend willst du Items verwenden und sollte nicht so schwer sein damit zurecht zu kommen,
ich gehe im Moment von Zufriedenheit aus, das (Y) wärmt auch mein Herz 
, sonst noch neu fragen
4*14-5*14
Das Objekt mit dem Index 3 würde ja dann die Plätze 56-70 verbrauchen so meinte ich das.
Die Fragestellung ist immernoch die;
Ich möchte aus der Liste Elemente auslesen können. Integer sowie String.
Und in Variablen einfügen.
Von dir Vorgeschlagen die Umwandlung gibt mir aber die Fehlermeldung aus.
(„kann das Object nicht zu Item machen“)
for ( int i = 0; i < itemList.size(); i++) // laden
{
Item s = itemList.get(i);
String a = a.s;
}
Den Rest pack ich selber 
Danke (Y)
Item s = (Item) itemList.get(i);
Cast(en) ist dann doch ein Grundlagen-Stichwort was anscheinend auch noch fehlt,
gibt auch Generics ab Java 1.5, auch einen Blick wert, obwohl es natürlich viel wird,
in eine List = new ArrayList() kann man nur Item einfügen und get liefert Item ohne Cast
Jetzt kann ich aber kein Item zum String konvertieren.
Wenn du solche Probleme hast solltest du immer den passenden Codeschnipsel dazu posten. So kann dir keiner hier helfen.
Du solltest dich außerdem unbedingt in die Java Grundlagen einlesen. Objektorientierung ist wirklich
for ( int i = 0; i < itemList.size(); i++) // laden
{
Item s = (Item) itemList.get(i);
String a = s .a;
}
Wie schaut die Item Klasse aus? Wie ist a dort deklariert? Was hast du mit dem a in der Schleife vor?
Ich will einfach nur aus einer Liste Werte extrahieren und in ****einer Variable ( String oder int ) ****auffangen.
Z.b. will ich aus:
List itemListe = new ArrayList();
Das was im Index 0/1/2 etc. steht in eine Variable schieben.
Vorschlag von SlaterB:
..
String xy = item .xy oder item .getXy();```
Verstehe ich nicht so richtig, da man doch kein Object in String umformatieren kann oder ?
Es muss doch eine einfache Lösung geben.Der Vorschlag von SlaterB und uns anderen sieht vor das Objektorientiert(!!!) zu machen.
Dazu solltest du dir eine Klasse Item erstellen, die alle Attribute eines Gegenstands speichert. In deinem Code arbeitest du dann mit einer List<Item>, ein Eintrag in der Liste ist dann ein Gegenstand. An die Eigenschaften eines Gegenstands kommst du dann über Getter-Methoden.
Aber wie gesagt, das alles zu erklären macht keinen Sinn wenn du Objektorientierung nicht verstehst.
Dein Weg das über eine einzige Liste zu machen, wovon die ersten 15 Einträge zu einem Gegenstand gehören, die nächsten 15 zum zweiten ist murks. Das würde ich nicht weiterverfolgen…
Also:
List<Item> itemList = new ArrayList();
Dort verfrachte ich also die Namen aller Items = ( Schwert, Dolch, Bogen etc. )
Und erstelle für jedes Item zunächst ein neues Object.
;durch;
return new Item(name,quote,maxlife,attack etc.) // Also die ganzen Attribute
Die Textdatei für RostigerDolch sieht Beispielweise so aus:
Rusty Dagger
Old rusty Dagger
0
0
0
0
11
0
0
0
0
8
11
1
[quote=Quiji]Also:
List itemList = new ArrayList();[/quote]
Die Liste solltest du besser so initialisieren:
List<Item> items = new ArrayList<Item>();
Stichwort: Rawtypes
Nein, die Liste ist dazu gedacht alle geladenen Items zu speichern.
Hier mal ein komplettes Beispiel, an dem die Verwendung der Objekt hoffentlich etwas klarer wird:
public class WeaponLoader
{
final private String basePath;
public WeaponLoader(String basePath)
{
this.basePath = basePath;
}
public Weapon loadWeapon(String weaponName) throws FileNotFoundException
{
// build the full path
File weaponFile = new File(basePath, weaponName + ".txt");
if (!weaponFile.exists()) {
// Fehlerbehandlung, evtl. FileNotFoundException exception werfen
}
// Attribute der Waffe auslesen
Scanner in = new Scanner(weaponFile); // TODO: sollte später wieder geschlossen werden
String name = in.nextLine();
int attack = Integer.parseInt(in.nextLine());
int costs = Integer.parseInt(in.nextLine());
// Objekt erstellen und zurückgeben
return new Weapon(name, attack, costs);
}
public static void main(String[] args) throws Exception
{
WeaponLoader weaponLoader = new WeaponLoader("/home/eike/");
List<Weapon> weapons = new ArrayList<Weapon>();
// Dolch laden
Weapon rustyDagger = weaponLoader.loadWeapon("rusty_dagger");
weapons.add(rustyDagger);
// Schwert laden
Weapon sword = weaponLoader.loadWeapon("sword");
weapons.add(sword);
// Bogen laden
Weapon bow = weaponLoader.loadWeapon("bow");
weapons.add(bow);
// Die geladenen Waffen zu testzwecken ausgeben
for (Weapon weapon : weapons) {
System.out.println("--- " + weapon.getName() + " ---");
System.out.println("Angriff: " + weapon.getAttack());
System.out.println("Kosten: " + weapon.getCosts());
System.out.println();
}
}
}
class Weapon
{
private String name;
private int attack;
private int costs;
public Weapon(String name, int attack, int costs)
{
this.name = name;
this.attack = attack;
this.costs = costs;
}
public String getName()
{
return name;
}
public int getAttack()
{
return attack;
}
public int getCosts()
{
return costs;
}
}
Die weapon files schauen so aus:
in die Liste kommen die Items rein, nicht ‚die Namen der Items‘
hast du schon eine Klasse Item programmiert? wie sieht sie aus, hat sie Attribute?
wie heißen die, kann man auf sie direkt zugreifen oder gibt es getter-Methoden?
das erste Beispiel Person in
Galileo Computing :: Java ist auch eine Insel - 5 Eigene Klassen schreiben
hat zwar auch keine getter-Methoden und keinen Konstruktor mit Parametern,
aber ist der minimale Anfang, eine Klasse mit zwei Attributen, die man belegen kann und später wieder auslesen
edit: nun ist ja ein noch besseres Beispiel gleich hier
Ich programmiere heute seid 8 Stunden bitte nehmt es mir nicht übel. Ich schaue in paar Stunden drüber 
Danke (Y)
[quote=Quiji]Es muss doch eine einfache Lösung geben.[/quote]Ja, nämlich[quote=EikeB;105841]Der Vorschlag von SlaterB und uns anderen sieht vor das Objektorientiert(!!!) zu machen.[/quote]Was immer Du mit denm Item anstellen willst, Du solltest das in der Klasse Item zun indem Du Dort eine entsprechende Methode schreibst, die dann das ausführt.
[quote=Quiji;105840]Verstehe ich nicht so richtig, da man doch kein Object in String umformatieren kann oder ?[/quote]Weil Du die Sache von der falschen Seite aus angehst.
Bevor man eigene Aufgabestellungen löst muss man erstmal die Grundlagen anhand vom Büchern und Tutorials (oder mit einemLehrer) lernen. Wenn Du dass gemacht hättest wärst Du zwangsläufig über die Methode .toString() gestolpert. Ich kenne kein Buch oder Grundlagen-Tutorial in dem die nicht vorgestellt wird.
Offensichtlich hälst Du Dich aber für einen Überflieger, der sowas nicht nötig hat.
[quote=Quiji;105840]Ich programmiere heute seid 8 Stunden[/quote]Hättest Du in dieser Zeit lieber das hier schon verlikte online-Buch gelesen (und zwar von Anfang an, nicht nur dieses eine Kapitel) wärst Du Deiner Lösung schon viel näher.
bye
TT
Offensichtlich hälst Du Dich aber für einen Überflieger, der sowas nicht nötig hat.
Hättest Du in dieser Zeit lieber das hier schon verlikte online-Buch gelesen (und zwar von Anfang an, nicht nur dieses eine Kapitel) wärst Du Deiner Lösung schon viel näher.
Ich bin kein Fan von Büchern und versuche lieber es durch selbstprobieren herrauszufinden.
Ich studiere seid 2 Monaten mit 1 1/2 Stunden Java-Programmieren pro Woche Informatik.
Wir sind im Thema natürlich noch nicht so weit. Aber durch probieren und etc. bin ich halt schon in einigen Punkten weiter.
Da gibts gar nichts zu meckern. Durch dieses Projekt will ich meine Kenntnisse einfach verbessern.
Wie auch immer meine Klasse Item sieht nun so aus.
import java.util.List;
import java.util.ArrayList;
public class Items
{ private String name;
private String quote;
private int maxlife;
private int armor;
private int magc_armor;
private int stamina;
private int phys_attack;
private int magc_attack;
private int mana;
private int spec_abil1;
private int spec_abil2;
private int quantity;
private int quality;
public Items (String name,String quote,int maxlife,int armor,int magc_armor,int stamina,int phys_attack,int magc_attack,int mana,int spec_abil1,int spec_abil2, int quantity, int quality)
{
this.name = name;
this.quote = quote;
this.maxlife = maxlife;
this.armor = armor;
this.magc_armor = magc_armor;
this.stamina = stamina;
this.phys_attack = phys_attack;
this.magc_attack = magc_attack;
this.mana = mana;
this.spec_abil1 = spec_abil1;
this.spec_abil2 = spec_abil2;
this.quantity = quantity;
this.quality = quality;
}
public String getName()
{
return this.name;
}
public String getQuote()
{
return this.quote;
}
public int getMaxLife()
{
return this.maxlife;
}
public int getArmor()
{
return this.armor;
}
public int getMagcArmor()
{
return this.magc_armor;
}
public int getStamina()
{
return this.stamina;
}
public int getPhysAttack()
{
return this.phys_attack;
}
public int getMagcAttack()
{
return this.magc_attack;
}
public int getMana()
{
return this.mana;
}
public int getSpecAbil1()
{
return this.spec_abil1;
}
public int getSpecAbil2()
{
return this.spec_abil2;
}
public int getQuantity()
{
return this.quantity;
}
public int getQuality()
{
return this.quality;
}
public void addItemToInventory() // Fuegt ein [Item] dem Inventar hinzu
{
Inventory.items.add(this.name);
}
public void sellItem()
{
if (Inventory.items.contains(name))
{
System.out.println("");
System.out.println("Do you really want to sell [" + name + "] for "+this.quantity+" ?");
String choice;
choice = Menue.eingabe();
if ( choice.equals("y"))
{
Inventory.items.remove(name);
System.out.println("[" + name + "] sold for ["+ this.quantity + "].");
Char.money = Char.money + this.quantity ;
}
else
{
System.out.println("Canceld.");
}
}
else
{
System.out.println("[" + name + "] not found.");
}
MoneySystem.showMoney();
}
}
Mein Loader
import java.util.*;
public class ItemLoader
{
public String itemnormpath;
public ItemLoader(String itemnormpath)
{
this.itemnormpath = itemnormpath;
}
public Items loadItem(String itemName) throws FileNotFoundException
{
//pfad aufbauen mit jedem item ein n euer name
File itemFile = new File(itemnormpath,itemName+".txt");
if (!itemFile.exists())
{
System.out.println(itemnormpath + itemName + ".txt not found.");
}
// List<Items> itemList = new ArrayList<Items>();
Scanner sc = new Scanner(itemFile);
//------------------------------------- // Alle Attribute
String name = sc.nextLine();
String quote = sc.nextLine();
int maxlife = Integer.parseInt(sc.nextLine());
int armor = Integer.parseInt(sc.nextLine());
int magc_armor = Integer.parseInt(sc.nextLine());
int stamina = Integer.parseInt(sc.nextLine());
int phys_attack = Integer.parseInt(sc.nextLine());
int magc_attack = Integer.parseInt(sc.nextLine());
int mana = Integer.parseInt(sc.nextLine());
int spec_abil1 = Integer.parseInt(sc.nextLine());
int spec_abil2 = Integer.parseInt(sc.nextLine());
int quantity = Integer.parseInt(sc.nextLine());
int quality = Integer.parseInt(sc.nextLine());
//----------------------------------------
return new Items(name,quote,maxlife,armor,magc_armor,stamina,phys_attack,magc_attack,mana,spec_abil1,spec_abil2,quantity,quality);
}
}
Alles funktioniert (Y).
Danke.
Code scheisse, Einstellung scheisse, solltest immer dazu sagen dass du ein Jugendlicher bist, dann drückt man nämlich ein paar Augen zu