ArrayList und Iterator

[Sekundentakt]

Hallo Javanesen,

ich versuche im Moment ein paar Beispiele aus einem Referenzbuch, das ich demnächst hier vorstellen möchte, nachzuvollziehen und selbst zu erweitern.

Hierzu zählt unter anderem der Versuch eine ArrayList in einer ArrayList zu speichern.
Einerseits um zu testen, ob die ArrayList in der ArrayList wie ein multidimensionales Array behandelt werden kann:

 echo $arrayList[0][5] //PHP-Darstellung von "gib das 5. Element der ersten ArrayList aus" 
  

Und andererseits um ein wenig Übung in Java zu erhalten.

Der Java Code sieht so aus:

 package helloworld;
import java.util.*;

public class Collector
{

        
        ArrayList<ArrayList> listing = new ArrayList<ArrayList>();
        ArrayList<String[]> brands = new ArrayList<String[]>();
        


    public void addBrand(String[] string)
    {
        brands.add(string);
    }

    public void addBrandToListing(ArrayList<String[]> brand)
    {
         listing.add(brand);
    }

    public void getIterator(ArrayList<String> list)
    {
        Iterator it = new List.Iterator();
    } 
  

Meine IDE mausert bei der letzten Methoden-Deklaration rum, sie würde "Iterator" nicht kennen. Wo liegt das Problem?
In der API-Dokumentation gibt's auch keinen Hinweis auf so ein Ausnahmeverhalten.

Noch eine Frage:
Gesetz dem Fall ich würde in einer While-Schleife folgendes machen wollen:
Gib a den aktuellen Wert des aktuellen Knotens.
Führe class.add(a) durch.
Speichert die Collection dann den Wert, sodass ich keine Probleme kriege, wenn ich a einmal überschreibe, oder merkt sich die Collection nur die Referenz zur Variablen a? Aufgrund des Code-Problemes kam ich noch nicht zum Ausprobieren - mich würde aber allgemein interessieren, ob Java aufgrund seiner Objektorientiertheit hier das ein oder andere mal - im Vergleich zu PHP - an Gedächtnisverlust leidet.

Danke!

[pago]

Java kopiert sich die Referenz auf das Objekt. ;)
Heißt dein "a" in der Liste ist unabhängig von deiner "a" Variable. Wenn du aber eine Eigenschaft von der Variable "a" veränderst (z.B. a.setColor("#ff0")), dann ist diese Eigenschaft auch in der Liste aktualisiert. Es wird also nicht das ganze Objekt kopiert, sondern nur die Referenz auf dieses Objekt im Speicher.

Bei dem anderen Problem: Ich vermute stark, dass du statt "new List.iterator()" eigentlich "list.iterator()" schreiben wolltest.

[Sekundentakt]

Danke für Deine schnelle Antwort, Pago!

Bei dem anderen Problem: Ich vermute stark, dass du statt "new List.iterator()" eigentlich "list.iterator()"

Ich hab' diese Möglichkeit auch schon durchgespielt, dann mausert er aber am "list" rum. Ich könnte auch "listing" (die eigentliche Variable) nehmen, aber das ändert auch nichts am Problem.
Es heißt dann "package list does not exists".

Heißt dein "a" in der Liste ist unabhängig von deiner "a" Variable. Wenn du aber eine Eigenschaft von der Variable "a" veränderst (z.B. a.setColor("#ff0")), dann ist diese Eigenschaft auch in der Liste aktualisiert. Es wird also nicht das ganze Objekt kopiert, sondern nur die Referenz auf dieses Objekt im Speicher.

Gesetz dem Fall ich habe 1.000 a's mit der Eigenschaft "Name". Es sind jeweils 1.000 verschiedene Namen. Wie mache ich es dann "falsch"? :)

Im Augenblick sieht das in meinem Kopf nämlich so aus:

while (...irgendwas, das wahr ist)
{
a = setName(getValue);
class.add(a);
}

und am Ende haben alle 1.000 in der Liste stehenden a's den selben Namen.
Oder wie meinst Du das?
Das gespeicherte a wäre immer vom Typ eines speziellen Objektes (z.B. Auto, Produkt, User etc.), also kein primitiver Datentyp.

[The_S]

Ich könnte auch "listing" (die eigentliche Variable) nehmen, aber das ändert auch nichts am Problem.
Es heißt dann "package list does not exists".

So ist es aber richtig und funktioniert auch eindeutig. Bau deinen Code dementsprechend um, versuch es noch einmal, und wenn es noch immer nicht geht => Code + Fehlermeldung posten. Generell solltest du dich evtl. ein bisschen besser in die OOP einlesen, wenn du solche Sachen wie dort oben baust ;) . Kann man übrigens auch ganz gut mit PHP machen :) .

Generell finde ich deine Collector-Klasse und die Datenstruktur ArrayList<ArrayList<String[]>> etwas außergewöhnlich ... evtl. liegt hier auch ein Designproblem vor!? So ein Konstrukt macht nur in sehr sehr wenigen Fällen Sinn (mir fällt zwar momentan gar keines ein, aber gibt bestimmt Situationen, wo man so etwas braucht).

Deine zweiten Frage kann ich leider rein vom logischen her so früh am Morgen nicht im geringsten folgen. Deshalb gehe ich stattdessen noch einmal auf deine Eingangsfrage ein:

Gesetz dem Fall ich würde in einer While-Schleife folgendes machen wollen:
Gib a den aktuellen Wert des aktuellen Knotens.
Führe class.add(a) durch.
Speichert die Collection dann den Wert, sodass ich keine Probleme kriege, wenn ich a einmal überschreibe, oder merkt sich die Collection nur die Referenz zur Variablen a? Aufgrund des Code-Problemes kam ich noch nicht zum Ausprobieren - mich würde aber allgemein interessieren, ob Java aufgrund seiner Objektorientiertheit hier das ein oder andere mal - im Vergleich zu PHP - an Gedächtnisverlust leidet.

Bei folgendem:

A a = new A();
List<A> aList = new ArrayList<A>();
for (int i = 0; i < 10; i++) {
  a.setValue(i);
  aList.add(a);
}

würde am Ende in deiner Liste zehnmal das selbe Objekt der Klasse A stehen, jeweils mit der Value "9".

Würdest du aber so etwas machen:

A a = null;
List<A> aList = new ArrayList<A>();
for (int i = 0; i < 10; i++) {
  a = new A();
  a.setValue(i);
  aList.add(a);
}

würden in deiner Liste 9 verschiedene Objekte der Klasse "A" stehen. Diese haben die values 0-9.

[pago]

Danke für Deine schnelle Antwort, Pago!

Bei dem anderen Problem: Ich vermute stark, dass du statt "new List.iterator()" eigentlich "list.iterator()"

Ich hab' diese Möglichkeit auch schon durchgespielt, dann mausert er aber am "list" rum. Ich könnte auch "listing" (die eigentliche Variable) nehmen, aber das ändert auch nichts am Problem.
Es heißt dann "package list does not exists".

Wichtig ist, dass du das "new" entfernst. Die iterator-Methode liefert dir ein Objekt vom Typ Iterator. Das ist aber schon eine konkrete Instanz, deswegen darf da kein "new" hin.

[Sekundentakt]

Wunderbar, nach Pagos Hinweis habe ich das Ganze noch einmal umgeschrieben.

So funktioniert es jetzt:

    public void getIterator(ArrayList<String> list)
    {
        Iterator it = list.iterator();
    }

EDIT: Blödsinn an dieser Stelle ist es aber, dass ich der Methode keinen Rückgabewert geben will ;).

Jetzt aber mal ganz ketzerisch gefragt: Warum muss das Iterator vor dem "it" groß geschrieben werden, aber das Iterator von list.iterator() klein?

Ich könnte auch "listing" (die eigentliche Variable) nehmen, aber das ändert auch nichts am Problem.
Es heißt dann "package list does not exists".

So ist es aber richtig und funktioniert auch eindeutig. Bau deinen Code dementsprechend um, versuch es noch einmal, und wenn es noch immer nicht geht => Code + Fehlermeldung posten. Generell solltest du dich evtl. ein bisschen besser in die OOP einlesen, wenn du solche Sachen wie dort oben baust . Kann man übrigens auch ganz gut mit PHP machen .

Danke für Deine Wortmeldung :). Aber richtig kann das nicht sein, oder ich verstehe Dich gerade falsch.
Wenn ich die Methode getIterator() nämlich so umformulieren würde, dass sie nur noch auf eine einzige Variable anwendbar ist, dann mach ich was falsch.
Methoden sollen ja dynamisch funktionieren - so mein Verständnis bisher :).
Ich definiere den Parameter ja als ArrayList die wiederum nur ArrayLists enthalten darf - welche Variable ich also letzten Endes übergebe, sollte Schnuppe sein, solange sie die Anforderungen erfüllt. So kenne ich es auch nur von PHP her :).
Ich glaube da lag ein Missverständnis vor! :)

Generell finde ich deine Collector-Klasse und die Datenstruktur ArrayList<ArrayList<String[]>> etwas außergewöhnlich ... evtl. liegt hier auch ein Designproblem vor!? So ein Konstrukt macht nur in sehr sehr wenigen Fällen Sinn (mir fällt zwar momentan gar keines ein, aber gibt bestimmt Situationen, wo man so etwas braucht).

Die Anwendung Collector() hatte für mich überhaupt keinen praktischen Nutzen, es ging einfach nur ums Prinzip :).

Aber vielleicht mal zur Idee:
Ich habe eine unbekannte Anzahl von ArrayLists die nur Strings enthalten können. Diese ArrayLists nenne ich jetzt mal StringList.
Ich möchte diese StringList nun in eine Super-ArrayList stecken, um diese in einem einzelnen Objekt zu sammeln.

Ich habe dann gehofft, dass ich auf die einzelnen StringLists über das Super-Array in etwa so zugreifen kann:

value = getElement(SuperList[i][k])

Wo man das in der Praxis ggf. brauchen könnte, war mir zu dem Zeitpunkt erst mal unwichtig. Was mir aber einfallen würde, wären falsch formatierte .txt/CSV-Dateien. Ich musste einmal im Zuge eines Schulprojektes ein PHP-Script entwickeln, dass aus jeder Dateizeile 14 Spalten ausliest. Das Problem: Einige .txt Dateien hatten weniger, andere mehr als 14 Spalten. Trotz dieses Datenmangels oder Datenüberflusses gehörten alle Spalten einer Zeile immer noch zum selben Ereignis.
Würde ich nun meinen Ansatz da oben darauf übertragen, so kann ich eine dynamische Anzahl an (String)Werten in eine dynamische Anzahl von String-ArrayLists (eine pro Ereignis) packen, die wiederum alle über eine Super-Array-List erreichbar wären. Inwieweit es Sinn machen würde, so schlecht gespeicherte Werte zu verarbeiten, steht ja auf einem anderen Blatt Papier ;)

Falls Du trotzdem glaubst, hier liegt ein Designfehler vor, würd' ich mich freuen, wenn Du dem noch mal Nachdruck verleihst.

[Sekundentakt]

Ich nutze die IDE Eclipse und die IDE NetBeans, einfach mal zum Vergleich.
Bei Eclipse nervt mich gerade tierisch, dass man nicht ArrayList<ArrayList> definieren darf - angeblich wäre es ein "Raw Type".

Bei NetBeans ist alles in Ordnung.
Allerdings kann ich da das Projekt nicht starten, da hier angeblich die Main-Hauptklasse nicht vorhanden ist.

Zur Struktur des NetBeans-Projektes:

helloworld -> Quellpakete -> helloworld -> Collector.java und Main.java

collector.java habe ich oben gepostet.

package helloworld;


public class Main
{
    Collector C1 = new Collector();


     String[] arg = {"Name1", "Name2", "Name3", "Name4", "Name5"};





    public static void main(Collector C1, String[]... arg)
    {
        C1.addBrand(arg[0]);
        C1.addBrand(arg[1]);
        C1.addBrand(arg[2]);
        C1.addBrand(arg[3]);
        C1.addBrand(arg[4]);

        C1.addBrandToListing(C1.brands);

        C1.getArrayList(C1.listing);
    }
}

Das ist Main.java

Warum findet NetBeans jetzt keine Hauptklasse "Main"?
Beim Debuggen heißt es, die Klasse "Main" enthalte keine Main-Methode.
Ob ich Main jetzt groß oder klein schreibe, ändert rein gar nichts an dem Umstand, dass ich eine Fehlermeldung kriege.

[The_S]

Danke für Deine Wortmeldung :). Aber richtig kann das nicht sein, oder ich verstehe Dich gerade falsch.

OK, mein Fehler/Missverständnis/nicht genau gelesen von mir. Müsste dann natürlich "list" und nicht "listing" heißen. Da das Beispiel (wie du selbst sagst) mehr als sinnlos ist, und ich so eine Methode auch für mehr als sinnlos halte (warum sollte man eine Methode mit einem Parameter aufrufen, die nichts anderes macht, als eine Methode des Parameters aufzurufen?), bin ich fälschlicherweise davon ausgegangen, dass du dieser Methode wenigstens etwas Sinn verleihen möchtest, indem sie den Iterator deines Objektattributs "listing" zurückgeben möchtest ;) .

Aber vielleicht mal zur Idee:
Ich habe eine unbekannte Anzahl von ArrayLists die nur Strings enthalten können. Diese ArrayLists nenne ich jetzt mal StringList.
Ich möchte diese StringList nun in eine Super-ArrayList stecken, um diese in einem einzelnen Objekt zu sammeln.

Ich habe dann gehofft, dass ich auf die einzelnen StringLists über das Super-Array in etwa so zugreifen kann:

value = getElement(SuperList[i][k])

so in etwa ... ja ... aber wie gesagt: Extrem selten, dass so etwas Sinn macht ;) .

Falls Du trotzdem glaubst, hier liegt ein Designfehler vor, würd' ich mich freuen, wenn Du dem noch mal Nachdruck verleihst.

Ja, hier liegt definitiv ein Designfehler vor. Du kehrst die OOP völlig unter den Tisch! Um mich noch einmal selbst zu zitieren:

Generell solltest du dich evtl. ein bisschen besser in die OOP einlesen, wenn du solche Sachen wie dort oben baust ;) . Kann man übrigens auch ganz gut mit PHP machen :) .

In deinem Fall wäre eine Zeile ein Objekt einer eigenen Klasse - bspw. "LineEntry". Jenachdem, aus welchen Datentypen die Spalten bestehen und ob/wie diese miteinander verknüpft sind, hält ein Objekt der Klasse LineEntry den Inhalt der Zeile in Form von 1-14 Attributen vor, die Arrays, ArrayListen, Einfache Objekte, primitive Datentypen oder Objekte eigener Klassen sind. Die Datei würde dann am Ende vollständig in einer Liste mit dem generischen Typen "LineEntry" stehen - List<LineEntry> txtData = new ArrayList<LineEntry>();

[Sekundentakt]

Die Datei würde dann am Ende vollständig in einer Liste mit dem generischen Typen "LineEntry" stehen - List<LineEntry> txtData = new ArrayList<LineEntry>();

Richtig. Jede Zeile wäre in einer LineEntry-List "gefangen" und ich könnte deren Inhalt so zurechtstutzen, wie ich ihn brauche - zeilenweise.
Nachdem das erledigt ist, speichere ich die einzelnen Zeilen in verschiedenen Tabellen oder versehe sie mit der Bemerkung: Unvollständig, Nicht eindeutig etc.

Ich schau' mir noch mal das Kapitel OOP-Grundlagen an, im Augenblick will mir der falsche Gedanken hierbei aber nicht in den Kopf.

[The_S]

OK, dann machen wir mal gleich weiter ;)

Ich nutze die IDE Eclipse und die IDE NetBeans, einfach mal zum Vergleich.

Ja, das ist am Anfang empfehlenswert. Ich persönlich nutze Eclipse und kenne auch mehr Leute, die mit Eclipse arbeiten. Aber wenn man mit den IDEs umgehen kann, sind beide sehr mächtig.

Bei Eclipse nervt mich gerade tierisch, dass man nicht ArrayList<ArrayList> definieren darf - angeblich wäre es ein "Raw Type".

Eclipse warnt dich nur, dass du hier unsicher programmierst, was du auch tust. Les dir am Besten hierzu mal etwas über Generics und Legacy Code durch, bspw. Java Blog Buch : 07.06 Legacy Code und Java Blog Buch : 06.02 Generics (+ evtl. noch Folgekapitel).

Korrekt müsste es heißen (um auf dein Beispiel von vorhin einzugehen) :

ArrayList<ArrayList<String[]>> l = new ArrayList<ArrayList<String[]>>();

Du musst natürlich auch noch spezifizieren, von welchem (generischen) Typ die geschachtelte ArrayList sein muss.

Solche Warnungen kannst du in Eclipse übrigens ausschalten bzw. mit einer entsprechenden Annotation unterdrücken (nicht empfehlenswert). Vermutlich kann man diese Warnung auch in NetBeans einschalten (empfehlenswert), kann dir aber nicht 100%ig sagen ob und wie, da ich wie gesagt kein NetBeans-User bin.

Allerdings kann ich da das Projekt nicht starten, da hier angeblich die Main-Hauptklasse nicht vorhanden ist.

package helloworld;


public class Main
{

// ... von mir gekürzt
    public static void main(Collector C1, String[]... arg)

// ... von mir gekürzt
}

Dieser Code wird auch nicht unter Eclipse und auch nirgends sonst (außer evtl. bei BlueJ ... aber das lassen wir mal lieber ) laufen, da er einfach falsch ist. Zusätzlich zu den OOP-Grundlagen solltest du dir auch noch einmal die Java Basics angucken. Evtl. genügt auch etwas konkretes zum Thema "main-Methode". Kannste hier mal gucken:

Java Blog Buch : 04.03.05 Sonderfall main

Konkret besteht dein Fehler darin, dass du die main-Methode fast exakt so, wie sie vorgegeben ist, übernehmen musst (näheres in gerade verlinktem Kapitel). Eine Erweiterung um weitere Übergabeparameter ist nicht erlaubt (ich hab auch ehrlich gesagt keine Ahnung wie und woher die in deinem Fall kommen sollten).

Methoden schreibt main in Java übrigens immer Klein ... siehe Code/NamingConventions http://www.java-blog-buch.de/0705-code-conventions/

Sorry, falls das jetzt alles ein wenig irritierend oder deprimierend für dich ist, aber ohne die Basics und grundlegende OOP Kenntnisse wirste kein Fuß fassen.

[The_S]

Jetzt gehts hier ja Schlag auf Schlag ... ich will ne Beförderung

Ich schau' mir noch mal das Kapitel OOP-Grundlagen an, im Augenblick will mir der falsche Gedanken hierbei aber nicht in den Kopf.

Ich sage nicht, dass eine Lösung falsch ist. Sie funktioniert genauso. Sie ist aber umständlich, fehleranfällig, schlecht erweiter/wartbar, unübersichtlich und nicht im geringsten Objektorientiert. Mein Azubi hat am Anfang seiner Lehre etwas ähnliches fabriziert. Das Ding ging live, er war im Urlaub, es trat ein Fehler auf, und ich musst ihn ausbessern. Nachdem ich weder Zeit noch Lust hatte, mich stunden durch solch schrecklichen Code zu wühlen, musste er vom Urlaub im Geschäft antraben. Seitdem entwickelt er "schöner" ;) .

Ich verstehe deine Sichtweise schon, so ist das nicht. Ich hab ja auch einmal angefangen zu programmieren und da sahs bei mir nicht arg viel besser aus ;) . Aber die Projekte werden komplexer, die Anforderungen höher und irgendwann fliegen dir deine alten Anwendungen um die Ohren und keiner will sie warten ... spätestens dann ist der Punkt gekommen, wo man sich mehr Gedanken um das Design macht (bzw. sich die meisten Gedanken um das Design macht. Steht das Design erst einmal, kann die Entwicklung auch von einem Affen (überspitzt gesagt) übernommen werden ;) ).

[Sekundentakt]

Sorry, falls das jetzt alles ein wenig irritierend oder deprimierend für dich ist, aber ohne die Basics und grundlegende OOP Kenntnisse wirste kein Fuß fassen.

Deprimierend wäre die Perfektion. Spannend wird es doch erst, wenn Fehler auftreten ;).

Zu deiner korrekten Schreibweise: So wollte ich es auch beinahe lösen - ich habe nur vernachlässigt, dass es auf beiden Seiten des Gleichheitszeichens so spezifiziert werden muss. Danke!

Konkret besteht dein Fehler darin, dass du die main-Methode fast exakt so, wie sie vorgegeben ist, übernehmen musst (näheres in gerade verlinktem Kapitel). Eine Erweiterung um weitere Übergabeparameter ist nicht erlaubt (ich hab auch ehrlich gesagt keine Ahnung wie und woher die in deinem Fall kommen sollten).

Soetwas habe ich mir schon fast gedacht. Ich les' mir mal die geposteten Kapitel durch, glaube aber jetzt schon, dass ich die Execute-Klasse/Main-Klasse letzten Endes mit einer Reihe von void-Methoden ausstatten muss, die ihrerseits die benötigten "Übergabeparameter" generieren oder Methoden aufrufen, die Rückgabewerte besitzen. Wenn ich das mal mit PHP vergleiche entsteht dadurch sehr viel Arbeit. Methoden, die dazu da sind Methoden aufzurufen

Jetzt gehts hier ja Schlag auf Schlag ... ich will ne Beförderung

Ich schlage Dich hiermit zum Formel-1-Post-Feedback-Ritter, erhebt euch Sir Kieselot!

Ich werd' die Klasse noch einmal neu posten, sobald ich die von Dir genannten Kritikpunkte umgesetzt habe.

[The_S]

Deprimierend wäre die Perfektion. Spannend wird es doch erst, wenn Fehler auftreten ;).

Super, wenn du dich nicht entmutigen lässt. Gerade wenn man von einer anderen Sprache, die man meint zu beherrschen, das erste Mal auf eine andere Sprache wechselt, und feststellen muss, dass sich diese an vielen Stellen doch anders verhält, als man es evtl. erwartet, ist das oftmals nicht leicht.

Soetwas habe ich mir schon fast gedacht. Ich les' mir mal die geposteten Kapitel durch, glaube aber jetzt schon, dass ich die Execute-Klasse/Main-Klasse letzten Endes mit einer Reihe von void-Methoden ausstatten muss, die ihrerseits die benötigten "Übergabeparameter" generieren oder Methoden aufrufen, die Rückgabewerte besitzen.

Öhm ... kann ich jetzt nicht so ganz nachvollziehen ... die Main-Methode ist nur dein Startpunkt in die Klasse. Diese wird idR direkt von der JRE aufgerufen. Hier kannst du nur Kommandozeilenargumente in Form von Strings übergeben. Die eigentliche Logik solltest du natürlich dann auf deine Klassen/Methodenstruktur verteilen.

Das ist ähnlich wie wenn in PHP ein GET oder POST aufgerufen wird. Diese Methoden stellen gewissermaßen den Startpunkt eines Vorgangs (Anwendung) dar, der von außen (in PHP durch den User, der auf den entsprechenden Link geklickt hat, in Java bspw. über die Kommandozeile) ausgeführt wurde. Intern wird die Logik dann an andere Methoden und Klassen/Objekte delegiert. Soweit alles normal ;) .

Wenn ich das mal mit PHP vergleiche entsteht dadurch sehr viel Arbeit. Methoden, die dazu da sind Methoden aufzurufen

Öhm ... eine Methode sollte in einem sauber strukturierten Projekt genau für eine Aufgabe zuständig sein. Manche Entwickler/Architekten gehen sogar soweit, dass eine Methode nicht mehr als 10 Zeilen enthalten darf. So extrem sehe ich das zwar nicht, aber wenn eine Methode aus 25 Zeilen oder mehr besteht, sollte man sich schon seine Gedanken machen, ob man da nicht etwas auslagern könnte. Selbes gilt für Klassen. Eine Klasse mit mehr als 400-500 Zeilen ist in den meisten Fällen falsch designd.

Ich schlage Dich hiermit zum Formel-1-Post-Feedback-Ritter, erhebt euch Sir Kieselot!

Wie zuvorkommend ... mit wem muss ich jetzt ein Turnier reiten? ;)

[Sekundentakt]

Gerade wenn man von einer anderen Sprache, die man meint zu beherrschen, das erste Mal auf eine andere Sprache wechselt, und feststellen muss, dass sich diese an vielen Stellen doch anders verhält, als man es evtl. erwartet, ist das oftmals nicht leicht.

Dem kann ich nur zustimmen. An einigen Stellen vermisse ich oftmals PHPs lockeren Umgang gerade im Bezug auf Variablendeklaration.

Das ist ähnlich wie wenn in PHP ein GET oder POST aufgerufen wird

Das einzige was mich an der Main-Methode behindert und zu meinem "Methoden rufen Methoden auf"-Gedanken führte, war, dass ich in der Main-Methode keine Variablen wie gewohnt einsetzen kann.

Wenn ich z.B. i als int; außerhalb der Main-Methode deklariere, kann ich ihm in der Main-Methode nicht den Wert 5 zuweisen, ohne über eine Methode zu gehen. Im Vergleich zu PHP eine echte Umstellung ;).

Öhm ... eine Methode sollte in einem sauber strukturierten Projekt genau für eine Aufgabe zuständig sein. Manche Entwickler/Architekten gehen sogar soweit, dass eine Methode nicht mehr als 10 Zeilen enthalten darf. So extrem sehe ich das zwar nicht, aber wenn eine Methode aus 25 Zeilen oder mehr besteht, sollte man sich schon seine Gedanken machen, ob man da nicht etwas auslagern könnte. Selbes gilt für Klassen. Eine Klasse mit mehr als 400-500 Zeilen ist in den meisten Fällen falsch designd.

Demnach wären ja fast alle Klassen von z.B. Online Shops wie Magento oder oXid e-Sales einem fehlerhaften Design unterworfen. Andererseits ist die Wartbarkeit (finde den Fehler) bei 500 Zeilen-Monstern äußerst schwer.
Ich kann aber nicht von mir selbst behaupten, dass ich es toll fände, wenn die Methoden alle einzeln in verschiedenen Dateien zu finden wären. Zumindest stelle ich mir das als ein sehr großes Gefummel vor, sobald irgendwer von irgendwem erbt.

Wie zuvorkommend ... mit wem muss ich jetzt ein Turnier reiten?

Ich schlage vor, dass Du gegen Jann den Weisen oder Pago den Fenstertöter antrittst. Zu gewinnen gibt es die WinLux 7 Edition mit der für diese Version limitierten Apache License 2.0.

... und jetzt lese ich mir mal die Referenzen durch.

[The_S]

An einigen Stellen vermisse ich oftmals PHPs lockeren Umgang gerade im Bezug auf Variablendeklaration.

Wie so vieles im Leben: Ansichtssache ;) . Ich hasse Sprachen, in denen ich keine strenge Typisierung hab. Ich finds einfach unlogisch und nur schwer wartbar, wenn ne Variable einmal ein String (mit speziellen Methoden), dann ne Zahl (mit anderen Methoden) und am Ende ein Objekt einer beliebigen Klasse (das sich noch einmal komplett anders verhält) ist.

Das einzige was mich an der Main-Methode behindert und zu meinem "Methoden rufen Methoden auf"-Gedanken führte, war, dass ich in der Main-Methode keine Variablen wie gewohnt einsetzen kann.

Doch, das geht ohne Probleme.

Wenn ich z.B. i als int; außerhalb der Main-Methode deklariere, kann ich ihm in der Main-Methode nicht den Wert 5 zuweisen, ohne über eine Methode zu gehen. Im Vergleich zu PHP eine echte Umstellung ;).

Geht auch ohne Probleme. Hier kommt dir wohl nur mal wieder die Objektorientierung im Allgemeinen und das kleine aber feine Wörtchen "static" im spezifischen in die Quere. Und natürlich habe ich auch hier wieder einen Link im JBB für dich ;) : Java Blog Buch : 04.03.07 Verwendung von static

Demnach wären ja fast alle Klassen von z.B. Online Shops wie Magento oder oXid e-Sales einem fehlerhaften Design unterworfen.

Kenne den Code der Shops nicht, aber das kann durchaus sein. Nur weil etwas groß ist, heißt das noch lange nicht, das es unter der Haube auch schön aussieht. Ich kann dir sogar in den original Klassenbibliotheken von Sun den einen oder anderen Fehler aufzeigen ;) .

Generell denke ich aber, dass hier eher das Problem daran liegt, dass PHP und Java meistens unterschiedlich programmiert werden. In Java gabs die OO schon von Beginn an. Bei PHP wurde sie erst irgendwann eingeführt (kenn mich da nicht sonderlich aus, aber ich glaube mich zu erinnern, dass das in Version 4 oder 5 gewesen sein müsste). Dementsprechend haben viele PHPler die Programmierung ohne OO gelernt bzw. tuen dies noch immer. Deshalb ist hier die Sichtweise auch ein bisschen anders. Die meisten Beispiele im Web zu PHP sind auch noch ohne OOP ... also bis der OOP-Gedanken an jeder Ecke der PHP-Community angekommen ist, wird das wohl noch ne ganze Ecke dauern.

Außerdem wird nach meiner Erfahrung PHP-Programmierung von den meisten nur als Hobby betrieben. Das heißt jetzt nicht zwangsläufig, dass deshalb der Code schlechter ist, aber in vielen Fällen findet man schon einige Qualitätsunterschiede zwischen professionell entwickelten Anwendungen und Anwendungen, die von Hobbyprogrammierern stammen.

Ich kann aber nicht von mir selbst behaupten, dass ich es toll fände, wenn die Methoden alle einzeln in verschiedenen Dateien zu finden wären. Zumindest stelle ich mir das als ein sehr großes Gefummel vor, sobald irgendwer von irgendwem erbt.

Eine willkürliche Verteilung von Methoden ist ja auch nicht sinnvoll. Die sollten natürlich logisch gegliedert, verteilt und gekapselt werden. Dafür ist halt wieder eine Objektorientierte Denkweise nötig ... aber die entwickelt sich schon mit der Zeit, hat bis jetzt noch bei jedem geklappt ;) .

[Sekundentakt]

So - nach Studium des Java Blog Buches habe ich versucht den Code anzupassen. Von vorne Anfangen werd' ich erst, wenn ich verstanden hab, warum er eigentlich permanent am Rumnörgeln ist.

Collector.java

public class Collector
{
        ArrayList<ArrayList<String>> listing = new ArrayList<ArrayList<String>>();
        ArrayList<String[]> brands = new ArrayList<String[]>();



    public void addBrand(String[] args)
    {
        brands.add(args);
    }

    public void addBrandToListing(ArrayList<String> brands)
    {
         listing.add(brands);
    }


    public void getArrayList(ArrayList<ArrayList<String>> superList)
    {
        Iterator<ArrayList<String>> it = superList.iterator();
        while (it.hasNext())
        {
            System.out.println(it.next());
        }
    }
}

Genau an der unterstrichenen Stelle nörgelt er rum "The method add(String) in the Type ArrayList<String> is not applicable for the arguments String[]".

Ich kann das umdefinieren wie ich lustig bin, der Fehler bleibt gleich.

EDIT:
Fehler gefunden. Ich muss mich wohl erst an Eclipse gewöhnen. PHPDesigner2008 hört sofort auf zu meckern, wenn man den Fehler behoben hat, Eclipse wartet bis man in eine andere Zeile geklickt hat.

Die Lösung:

    public void addBrand(String[] args)
    {
        brands.add(0,args);
        brands.add(1,args);
    }

Sofern man also weiß, wie viele Elemente args enthält, kann man das Ganze von einer Schleife erledigen lassen.

Hier Main.java

public class Main
{
     String[] args = {"Name1", "Name2", "Name3", "Name4", "Name5"};
 
     
    public static void main(String[] args)
    {
       Collector C1 = new Collector();
        
    	C1.addBrand(args);


        C1.addBrandToListing(C1.brands);

        C1.getArrayList(C1.listing);
    }
}

EDIT:
Beim RUN unter Eclipse zeigte er irgendeine Fehlermeldung, dass er einen Call auf das JDK 1.2 nicht ausführen kann. Nach einem Klick auf Coninue konnte ich die Fehlermeldung leider nicht mehr reproduzieren. Vielleicht nutze ich ja die falschen Google Keywords, aber geholfen hat da kein Eintrag. Jemand eine Idee?

[The_S]

ok, hast schon selbst gefunden :) . Aber Eclipse meckert bei mir nicht mehr, sobald der Fehler behoben ist. Im schlimmsten Fall muss ich mal kurz STRG + S zum Speichern drücken.

[edit] Aber ob das Programm jetzt so läuft, wie du möchtest, mag ich zu bezweifeln ;) .

[Sekundentakt]

Schau einmal kurz bitte in mein EDIT :).

Nein, es läuft nicht.
Ich muss das Ding über die Konsole ansteuern, da man dort die Argumente übergibt. Glücklicherweise liefern die IDEs sowas ja mit;).

Will heißen: In der Main - Klasse jetzt die Variable "args" löschen und über die Konsole übergeben.
Richtig?

[The_S]

EDIT:
Beim RUN unter Eclipse zeigte er irgendeine Fehlermeldung, dass er einen Call auf das JDK 1.2 nicht ausführen kann. Nach einem Klick auf Coninue konnte ich die Fehlermeldung leider nicht mehr reproduzieren. Vielleicht nutze ich ja die falschen Google Keywords, aber geholfen hat da kein Eintrag. Jemand eine Idee?

Hm, da scheint Eclipse irgendwo falsch konfiguriert sein. Auf was steht denn deine Projekt-JRE bzw. wenn die auf "workspace-Einstellungen" gesetzt ist, auf was steht die Workspace-JRE? Aber wenns jetzt nicht mehr auftritt: Einfach ignorieren ;) .

Nein, es läuft nicht.
Ich muss das Ding über die Konsole ansteuern, da man dort die Argumente übergibt. Glücklicherweise liefern die IDEs sowas ja mit;).

Will heißen: In der Main - Klasse jetzt die Variable "args" löschen und über die Konsole übergeben.
Richtig?

Jop. Wobei du in der IDE nicht direkt in der Konsole eingeben wirst, sondern die Übergabeparameter in der Run-Configuration konfigurieren musst. Oder du gibst (wenn es sowieso nur ein Test ist) die Parameter fest im Programm mit an (was ich fast bevorzugen würde).

[Sekundentakt]

Hm, da scheint Eclipse irgendwo falsch konfiguriert sein. Auf was steht denn deine Projekt-JRE bzw. wenn die auf "workspace-Einstellungen" gesetzt ist, auf was steht die Workspace-JRE? Aber wenns jetzt nicht mehr auftritt: Einfach ignorieren .

Die Frage ist gemein, gegenüber einem Anfänger. Ich glaube aber, dass es 1.6 gewesen ist bzw. 6.0 - ich bin mir nicht sicher.
Java Compliance steht jedenfalls auf 1.6.

Jop. Wobei du in der IDE nicht direkt in der Konsole eingeben wirst, sondern die Übergabeparameter in der Run-Configuration konfigurieren musst. Oder du gibst (wenn es sowieso nur ein Test ist) die Parameter fest im Programm mit an (was ich fast bevorzugen würde).

Das mache ich doch auch - trotzdem gibt er nichts aus.
Als Ausgabe soll am Ende

Name1Name2Name3

erscheinen.
Erscheinen tut aber gar nichts. Außer einer Erfolgsmeldung.