Ich möchte gerne einige kleinere GUI-lastige Anwendungen auf Basis von Java erstellen und haben nun sowohl mit Eclipse als auch NetBeans ein wenig herumgespielt. Die Entscheidung für eine der beiden IDEs wurde dadurch leider nicht einfacher. Während Eclipse einen sehr guten Source-Editor besitzt, kann NetBeans dagegen bei der GUI-Entwicklung überzeugen. Mich würde mal interesserien was die echten Java-Entwickler so einsetzen und warum. Natürlich habe ich schon als vorbildlicher MTNler auch alte Threads zu dem Thema gelesen, aber die Entwicklung geht in diesem Bereich ja rasend voran.

Kommt darauf an, wie versiert du bist. Am allerbesten ist es, die GUI von Hand zu programmieren. Ansonsten würde ich es via Netbeans machen und anschliessend in Eclipse weiterarbeiten.

hmm, die Auswahl hängt nicht zuletzt vom für die Aufgabe zu verwendenden GUI Framework ab:

SWT Eclipse
"Carbon/Aqua" XCode
Swing Netbeans

für die Applikationsentwicklung selbst sind alle drei zu gebrauchen.

Ich hatte vor einigen Jahren mal mit AWT arbeiten müssen und das war eine richtige Qual, bis man alle Elemente zufriedenstellend positioniert hatte. In dieser Beziehung scheint ja Swing/SWT deutlich komfortabler zu sein. Aber wie ich schon eingangs erklärt hatte, ist es halt schwierig, sich zu entscheiden, da beide IDEs ihre Komfort-Funktionen haben, die keine andere (kostenlose) IDE bietet. Die GUI-Frameworks spielen für mich bei der Wahl nur eine untergeordnete Rolle. Letztendlich muss das Framework nur gewährleisten, dass die Anwendungen gleichermaßen unter Windows und Mac OS X benutzbar ist.
Interessanterweise hat sich bisher nur ein Entwickler für NetBeans ausgesprochen (und anscheinend auch nur in Kombination mit Eclipse). Ist es denn praktikabel, zunächst die GUI mit NetBeans zu entwerfen, um dann in Eclipse weiter zu arbeiten? Wie sieht es eigentlich mit dem Visual Editor für Eclipse aus? Benutzt den jemand unter VirtualPC und arbeitet danach unter Mac OS X weiter?

sb

AWT (sick)
Was den Visual Editor angeht... naja, Netbeans ist doch schon wesentlich älter und ausgereifter. Und insbesondere auf diesem Gebiet performanter! Eclipse ist ja so schon nicht der brüller, was die Performance angeht. Aber dann noch via Emulation unter Windows? zzz Lass es lieber bleiben.

Probleme bekommst du keine, wenn du dein Projekt mit zwei IDEs bearbeitest. Hast du dir mal die brandneue Netbeans V5 gezogen? Vielleicht erübrigt sich ja deine Frage damit schon.

stiffler
Ich hatte mir schon NetBeans 5.0 angeschaut, finde es aber unübersichtlicher und langsamer als Eclipse.

Vielen Dank für eure Kommentare! Ich werde jetzt erstmal NetBeans benutzen. Sollte es irgendwo haken, kann ich hoffentlich recht problemlos auf Eclipse umsteigen.

Der GUI-Builder von NetBeans ist wirklich edel. Inbesondere hat mich der saubere Code, den das Ding erzeugt wirklich beeindruckt.
Das wars mit NetBeans dann aber auch schon.

Im harten Alltagseinsatz hab ich Eclipse. Ich hab vor einem halben Jahr ein kleines (10.000+ lines of code) tool mit heftiger Swing GUI von meinem Vorgänger zum "nebenbei betreuen" "geerbt". Absolut undokumentiert und der code selber war auch zum heulen. (eigentlich noch schlimmer)

Ohne (die Refactoring Fähigkeiten von) Eclipse wäre ich eingegangen. Damit kann man recht einfach Variablen/Methoden umbenennen und alles wird konsistent im ganzen Project angepasst. Wenn man Classen in ein anderes Package schiebt, wird auch automatisch alles angepasst. Man kann bequem die Reihenfolge von Parametern umändern. Und er warnt einen, wenn man z.B. die Namens-Konventionen missachtet und Methodennamen mit einem Großbuchstaben anfangen lässt oder es sonst irgend ein Problem beim Refactorn gibt...

Davon abgesehen:
- Man kann sehr bequem die Call-Hierarchie einer Methode abfragen: Man findet leichter heraus was eigentlich passiert und kann auch tote public Methoden zu entsorgen. (unbenutzte private Methoden findet er alleine und merkiert sie mit einer Warnung)
- Schnell zur Deklaration einer Methode springen
- Der Code wird automatisch mit compiliert so dass man Tippfehler extrem schnell findet. Meistens bietet Eclipse auch gleich die Lösung an (z.B. import von irgendwas, ein try/catch block, wenn eine Methode Exceptions wirft, eine Methodensignatur ändern oder eine komplett neue Methode in die Klasse einbauen...)
- Strg+Space komplettiert Variablen, Klassen und Methoden Namen bei mehreren Möglichkeiten werden alle angezeigt und durchs eingeben weiterer Buchstaben wird die Auswahl eingegrenzt... (ich drück mittlerweile sogar beim Mails-Schreiben andauernd Strg-Space)
- Wenn man mit der Maus über einen Methoden-Aufruf oder eine Variable fährt werden einem die Parameter (Typen) und wo die Variable her kommt angezeigt, wenn vorhanden auch gleich die Java-Doc information dazu.
- Für Member-Variablen werden auf Wunsch automatisch Getter/Setter generiert.
- Selbges für Java-Doc Rümpfe (alt+shift+j)
- Der Debugger ist unglaublich genial. Breakpoint setzen, laufen lassen, und dann nach Herzenslust Variablen anschauen (Kontext-MenuWatch). Wenn dann der Fehler gefunden wurde: Korrigieren, Speichern. Das ganze wird automatisch compiliert und _in das Laufende Programm_ eingebunden. (Der Methodenaufruf in dem etwas geändert wurde wird noch mal von vorne angefangen.
- Das SVN Plugin ist genial, CVS hab ich noch nicht ausprobiert und werde es wohl auch nicht mehr.
- Das Metrics Plugin misst verschiedene Aspekte von "Code" Qualität, so dass man leichter Stellen findet wo es krankt (z.B. eine Methode mit 12 Parametern oder eine Methode mit 1300 Zeilen und bis zu 15 fach verschachtelte if-Konstrukte sind irgendwie albern). I.e. wenn Metrics nicht mehr motzt ist der Code schon ganz brauchbar...
- PMD-Plugin. (vgl. gcc -Wall -pedantic -grammarNazi) Sucht nach Standard-Design/Coding Fehlern. Z.B. werden oft Streams in einer Methode geöffnet, aber nicht auf allen Pfaden die die Methode verlassen wieder ordentlich geschlossen so dass man ein "Filehandle-Leak" hat... . Außerdem gib es einige Performance Tipps...
-Das Omondo UML-Plugin generiert automatisch UML Diagramme aus vorhandenem Code (Java 5.0 compatibel und wenn man in den Diagrammen was ändert wird auch der Code sauber angepasst)

Ansonsten gibt es noch unzählige sinnvolle Funktionen und Plugins die den Rahmen hier bei weitem sprengen. Eclipse and happy camper.

Donar: Super Ausführung!

An dieser Stelle mal ein nützlicher Link:

frank
Danke - guter Tipp!

Donar-
Einige der aufgezählten Punkte (wie z.B. Refactoring) beherrsch NetBeans 5. Es scheint hier also schon glücklicherweise Fortschritte zu geben.

stiffler
Die Plug-Ins sind natürlich ein Pluspunkt für Eclipse, aber ich werde es jetzt dennoch erstmal mit NetBeans versuchen. (schon allein, um nicht noch einmal wie bei AWT an der GUI herumbasteln zu müssen) Eclipse kann ich dank Plug-Ins nebenbei für PHP verwenden, so dass ich mit beiden IDEs Erfahrung sammeln kann.

Ich will um Himmels Willen Eclipse hier nicht bis aufs Messer verteidigen. Habe mit Netbean 5 & 5.5 noch nicht gearbeitet (nur mit Versionen vor Eclipse).
Jede IDE, die auch nur annähernd komfortabel und funktional ist wie Eclipse und dabei nur einen Hauch schneller, könnte mich überzeugen.

sb PHP mit Eclipse? Ich hoffe, du hast einen extremst vernünftigen Rechner dafür.

Vim

Um der Diskussion hier einen ordentlichen Abschluss zu geben, kommt hier nun mein Fazit nach zwei Monaten "Spielerei". Für die Java-Anwendungen-Entwicklung kann ich fast uneingeschränkt NetBeans empfehlen, zumal es neben Vorlagen auch schöne zugängliche Beispiele mitliefert. Nur wer SWT einsetzen will, sollte doch besser Eclipse den Vorzug geben. Doch auch NetBeans hat so seine Ecken und Kanten, die ich hiermit einmal kurz aufzählen will:

1. Der GUI-Builder Matisse benötigt eine zusätzliche Swing-Erweiterung zur Positionierung, die teilweise auf veraltete Klassen zurückgreift aber dennoch mindestens Java 1.4 erfordert. Um diese Bibliothek außerdem in die JAR-Datei zu bekommen, muss man entweder die Build-Einstellungen per Hand ändern oder die Bibliothek als Source in jedes Projekt integrieren.

2. Swing ist immer noch sehr lahm und je nach Betriebssystem hier und da inkonsistent. Ein Ausweichen auf AWTs bei Möglichkeit ist empfehlenswert, hat aber auch seine Tücken, wir der nächste Punkt zeigt.

3. Es kommt recht häufig vor, dass NetBeans 5.0 im Zusammenhang mit der Verwendung von AWTs abstürzt. Eine Lösung für diese Problem habe ich nicht gefunden. Man kann lediglich vor jeder Änderung eines AWT-Elements sicherheitshalber das Projekt speichern.

Deswegen bin ich mittlerweile auf NetBeans 4.1 umgestiegen. Hier machen sich beim Zusammenspiel von AWT und Swing lediglich im GUI-Builder einige Grafikfehler bemerkbar, die in der fertigen Anwendung dann aber verschwunden sind. Natürlich muss man hier auf den erweiterten Komfort mit Matisse verzichten, hat aber dank der üblichen Layout-Modi dennoch ausreichend Freude mit dem GUI-Builder. Übrigens beherrscht auch NetBeans 4.1 Refactoring.

Das wäre soweit alles, was ich noch loswerden wollte.

Danke für dein Fazit, vor dem gleichen Problem wie du stehe ich auch gerade.
Es hilft sehr sowas zu lesen.

Worauf ich noch im Zusammenhang mit NetBeans 4.1 bei der GUI-Gestaltung hinweisen will:
1. Bei der Gestaltung von Fenstern will man diese oft mit einer festen Größe. Hierfür muss man in den PropertiesCode des jeweiligen Frame/Dialog die "Form Size Policy" ändern.
2. Um Abstände zwischen den GUI-Komponenten und dem Fenster-Rand zu erreichen, empfiehlt sich nach meinem Kenntnisstand ein Border-Layout, welches an den Rändern mit leeren Panes im Border- oder Grid-Layout gefüllt ist.

Zu Punkt 2: Das mit dem Border-Layout ist doch nicht das Optimale. Also am Besten und Leistungsfähigsten scheint GridBag-Layout zu sein, da man dort individuell die Abstände (auch zum Rand) bei der jeweiligen GUI-Komponente festlegen kann.

Ich kann die Abneigung gegen Netbeans nicht ganz verstehen. Gerade in den letzten Versionen hat es sich sehr gemacht. Inzwischen finde ich es eleganter als Eclipse.

Und der GUI-Editor ist super. Wenn du wirklich Swing machen willst kommst du an Netbeans kaum vorbei.

Schau dir mal die Preview von Netbeans 5.5 an. Läuft sehr stabil und ist nochmal etwas runder.

Und zur Ehrenrettung. Netbeans kann das auch alles... seit 5.0.

In den Versionen davor war Netbeans wirklich gruselig.

Werd mir jetzt auch mal Netbeans 5 angucken.