NetBeans oder Eclipse

[Jor]

Hallo zusammen,

ich möchte wieder mehr mit Java machen, und tue mich schwer, zu entscheiden, welche Entwicklugsumgebung ich einsetzen soll.
Eclipse oder NetBeans?
Was ich neben Java noch programmiere ist Java Script und PHP.

Ich habe schon gegoogelt und die IDE's sehen super aus und haben sicherlich jede für sich Vorteile, aber ich kann mich nicht entscheiden und hoffe auf eure Tipps.

Einen schönen 1. Advent,
viele Grüße,
jor

[bischi]

Also ich benutze zum Programmieren am liebsten nen Texteditor - Scite beispielsweise

MfG Bischi

[Jor]

Hi Bischi,

hhmm, Hardcore-Proggen, naja, etwas mehr Luxus wünsche ich mir dann doch... Eigentlich gefällt es mir schon, dass ich nicht mehr nur mit einem Editor coden muss, man hat zwar nicht mehr alles in der Hand, aber es ist
m. E. schneller und ... angenehmer.

[mehlvogel]

Naja das ist eine Frage des persönlichen Geschmacks. Schau dir beide IDEs an und entscheide selbst. Ich habe mich für Eclipse entschieden, kenne Netbeans aber nur sehr sehr rudimentär, so dass ich einen stärkeres Kriterium als "persönliche Präferenz" nicht angeben kann.

[Jor]

hi mehlvogel,
bei mir sieht es ähnlich aus wie bei dir, nur dass ich von der netbeans-seite auf eclipse schaue. kann es sein, dass eclipse hier in deutschland eine gößere lobby hat, und netbeans eher im ausland?
ich werde mir eclpise dann mal installieren und schaue es mir an.

@all: Vielen Dank für eure Antworten!

[BlueJay]

Was ich neben Java noch programmiere ist Java Script und PHP.

Tja, ich bin schon so alt und klapperig, dass ich alle 3 Sprachen nur mit Texteditoren programmiere. Da weiss man wenigstens, was abläuft. Zudem muss man sich nicht jedes Jahr in eine neue IDE einarbeiten.

Die einzige IDE, die ich wirklich schätze, ist die sun-j2me für Handys.

so long,
BlueJay

[BlueJay]

Editor coden muss, man hat zwar nicht mehr alles in der Hand, aber es ist
m. E. schneller und ... angenehmer.

Hm, schneller und angenehmer? Das bin ich eindeutig mit einem Texteditor meiner Wahl und CommandLine-Tools.
Habe 2-3x Klicki-Bunti-IDEs probiert, bei Qt merkte ich bald, dass die Hauptlast trotzdem auf dem Editor lag. Und mein Entsetzen wurde groß, als ich die Buttons und Menupunkte mal umsortieren wollte, als es zu viele wurden! (diskontinuierliche Indices oder Indices kreuz und quer statt geometrisch-logisch verteilt!)

Bei Javascript und php gab es einfach nix, und bevor ich durch Eclipse oder Netbeans durchgestiegen bin, war ich "zu Fuß" schneller.

Gut finde ich das Sun J2ME, die haben sich auch nur darauf beschränkt, CommandLine Tools (und den Handy-Emulator) in Menuitems zu stecken und den Compiler/Linkeroutput in ein Textfenster zu pappen, der Rest geht wieder mit einem Editor deiner Wahl.

so long,
BlueJay

[Jor]

Hallo BlueJay,
hhmm, hört sich für mich dann doch nach einem Editor-Proggen an ;-)
Aber wie kommst du mit der Syntax bzw. deren Fehlern klar, ist da der
Suchaufwand nicht sehr groß? Ich würde mir gerne mal deine Entwicklungsumgebung anschauen... Was du mit "CommandLine Tools"
meinst weis ich nicht 100%ig, aber es macht mich sehr neugierig.
Wenn man natürlich in der Lage ist Handler und Co. selbst anzulöten, dann hat man die Applikation sicherlich besser im Griff.

Ich werde mal ein bißchen googeln müssen... *lol*

Danke!

[BlueJay]

Zum Editieren benutze ich den Internal Editor vom Krusader.
Das Schätzchen erkennt an den Endungen, was ich gerade proggen will.
Es gibt Zeilennumerierung, es gibt Klammerhilighting und -Ein/Ausblenden, der erkennt Funktionen und etliche Syntaxen sowie alle nötigen Codepages.

Die Dreckfehler, die du fabrizierst, sind da schnell gefunden.

Command line Tools sind javac, java, gcc mit qmake und make und Konsorten

so long,
BlueJay

[Jor]

Heute habe ich gesehen, dass es bei Sun auch ein Paket gibt, JDK mit Command Line Tools, ich werde es mir mal anschauen.
HHhhmm eigentlich dann auch der richtige Druck wieder ein Linux zu installieren, du weist ja wie das ist, man hat viel Wünsche, aber wenig Zeit.
Aber ich habe ja bald Urlaub, da kann ich bestimmt was stemmen
Danke für deine Infos!!!

[jan61]

Zum Editieren benutze ich den Internal Editor vom Krusader.
Das Schätzchen erkennt an den Endungen, was ich gerade proggen will.
Es gibt Zeilennumerierung, es gibt Klammerhilighting und -Ein/Ausblenden, der erkennt Funktionen und etliche Syntaxen sowie alle nötigen Codepages...

Bietet Dir Deine IDE Autocompletion von Klassen und Methoden (inkl. der Anzeige der geforderten Parameter und ihrer Typen sowie des Rückgabetyps), automatischen Import (oder arbeitest Du mit "import java.xyx.*;"?), Umbenennen von Packages, Klassen, Methoden (inkl. aller Referenzen), Einbinden von CVS/SVN, automatisches Generieren von Gettern/Settern, Rebuild-On-Change (verbunden mit der sofortigen Anzeige aller Fehler, Warnungen, nicht initialisierter Variablen, ...), komfortables Erstellen von Packages, Klassen, JAR/WAR/EAR, Verschieben von Methoden / Klassen in andere Klassen / Packages mit automatischer Anpassung aller Dateien, in denen diese rerefenziert werden? Verhindert sie z. B. nicht-statische Methoden in Interfaces? Haut sie Dir auf die Finger, wenn Du in statischen Methoden Objektvariablen benutzen willst? Siehst Du bei ihr auf einem Blick, welche Packages / Klassen / Methoden in Deinem Projekt in welcher Zeile fehlerhaft sind?

Bietet Dir Dein Editor bequeme Unterstützung beim Erstellen und Generieren von Javadoc? Kann er automatisch Code formatieren, Code-Blöcke auskommentieren, Code ergänzen, kannst Du Dir von ihm auf Tastendruck in Frage kommende Variablen- oder Methoden-Namen zur Auswahl anbieten lassen? Verwarnt er Dich, wenn Du z. B. in Java5 Collections nicht typisierst oder in Java4 Typecasts vergisst? Mault er rum, wenn Du in einer Java4-Umgebung Java5-Syntax benutzt? Nimmt er die benötigten Imports mit, wenn Du eine Methode oder auch nur ein paar Codezeilen aus Projekt A, Package B, Klasse C, Methode D per Copy&Paste in Projekt W, Package X, Klasse Y, Methode Z kopierst? Zeigt er Dir an, wenn Du als "veraltet" gekennzeichnete Klassen oder Methoden benutzt? Kannst Du Methoden / Klassen als veraltet markieren und siehst dann auf einen Blick, wo sie noch benutzt werden?

Ist in Deiner IDE ein Debugger integriert? Kannst Du auf Tastendruck für jede Methode (sofern der Java-Code vorliegt) zu ihrer Definition springen oder zu einer Methode sämtliche Stellen anzeigen lassen, an denen sie benutzt wird? Kannst Du Abhängigkeiten von anderen Projekten definieren, um bei Änderungen in Basisprojekten sofort die rote Lampe in den abhängigen Projekten angehen zu lassen, wenn Du inkompatible Änderungen einbaust?

Wie viele Sekunden brauchst Du, um ein Package oder eine Klasse zu kopieren (inkl. Umbenennen)? Wie unterstützt Dich Deine IDE, wenn es um die Syntaxprüfung von XML-Konfigs oder Propertydateien geht? Wie viele Tastaturanschläge bzw. Mausklicks brauchst Du, um eine Änderung testen zu können?

Ich habe meine Java-"Karriere" mit SCiTE begonnen, habe irgendwann mit Eclipse (IIRC Version 2.3) angefangen und würde selbst bei Strafe des Erschießens nicht mehr davon ablassen. Die Produktivität (sprich die Quantität und Qualität des erzeugten Codes, die fast automatisch erzeugte Dokumentation, die Möglichkeiten zum Refactoring, Testen, Debuggen, Deployment) ist für mich mit Eclipse um etliche Größenordnungen höher als mit SCiTE & Co. Ich bin oft in der Situation, dass ich unter erheblichem Zeitdruck arbeiten muss - ohne eine komfortable IDE wie Eclipse wäre das nicht drin.

Jan

[Jor]

Hallo jan61,

das sind natürlich Argumente! Da ich mir unter Commans Line Tools nicht viel vortellen konnte, geschweige denn anwenden, sehe ich die Installation von Eclipse schon als notwendig. Besonders da ich zwar mit Java (NetBeans) schon Erfahrungen habe, aber das ist noch nicht so wild.

Danke für die ausführliche Beschreibung, die einen sehr großen Einfluß auf meine Überlegungen hat.

[BlueJay]

Bietet Dir Deine IDE Autocompletion von Klassen und Methoden (inkl. der Anzeige der geforderten Parameter und ihrer Typen sowie des Rückgabetyps),

Nein, ich muss schon selbst wissen, welche Klassen ich wie verwenden möchte, die Beschreibung der Sun-Bibliotheken liegt immer in einem 2.Fenster irgendwo rum. Da kann ich mir dann aussuchen, welche Variante meinen Wünschen am besten entspricht, welche "Overkill" betreibt, oder ob es noch was Besseres gibt.

automatischen Import (oder arbeitest Du mit "import java.xyx.*;"?),

Ich arbeite mit "import dingsbumsda.watt;" und bekomme einen Überblick, was der sich so alles an Land zieht.

Rebuild-On-Change (verbunden mit der sofortigen Anzeige aller Fehler, Warnungen, nicht initialisierter Variablen, ...),

2x Taste up, 1-2x enter , und solche Schönheiten und Fingerzeige erscheinen, gilt auch für den Rest des Abschnittes. Als Anfänger muss ich da leider manchmal etwas scrollen.

Bietet Dir Dein Editor bequeme Unterstützung beim Erstellen und Generieren von Javadoc?

Da liegt so ein (Sun) Comand-Line-Tool rum, was so was kann, habe ich mich aber noch nicht mit beschäftigt.

Kann er automatisch Code formatieren, Code-Blöcke auskommentieren,

1. habe ich einen anderen Geschmack (ANSI),
2. bin ich schneller (/* */)und weiss, was ich getan habe.

Dann fasse ich mal zusammen:
Mein Debugger heisst System.out.println
Veraltete Methoden wirft dir javac entgegen.
Der Pfad eines Fehlers wird genauestens von java aufgelistet, und eigentlich muss man dann nur die Methode in der angegebenen Klasse finden, also im Krusader f4, suchen, eingeben, und mer ist da. F3 hoppst dann von Aufruf zu Aufruf

Wie viele Sekunden brauchst Du, um ein Package oder eine Klasse zu kopieren (inkl. Umbenennen)?

Keine Ahnung, auf jeden Fall brauche ich länger, um zu entscheiden, ob ich die Klasse so verwenden kann oder doch besser eine Unterklasse davon schreibe. (Klick-Ratsch F4, 2x neuen Namen eingeben, Ctrl-s, drübergucken dauert dann am längsten).
Mittlerweile habe ich natürlich auch Klassen, die in die "Privatbibliothek" gewandert sind.
Da wird je nach Verwendung einfach schnöde importiert oder ins Paket einverleibt (Klick-Ratsch, F4, 1xPaketnamen eingeben).

Wie viele Tastaturanschläge bzw. Mausklicks brauchst Du, um eine Änderung testen zu können?

ca. 3, bis das geänderte Programm läuft

Ich bin oft in der Situation, dass ich unter erheblichem Zeitdruck arbeiten muss - ohne eine komfortable IDE wie Eclipse wäre das nicht drin.

Das ist eine ganz andere Situation. Ich programmiere Java zum Vergnügen und kann es mir da leisten, statt 10 Tastenschlägen vielleicht 11 oder 12 eingeben zu müssen. Wenn es geschäftlich ist, muss ich ohne aufwändiges Werkzeug auskommen, sozusagen mit Bordmitteln eines Betriebssystems, von denen ein Tastaturpuffer nicht das Schlechteste ist.

Suns JDK bringt da eine ganze Menge Komfort mit, so dass ich mit Eclipse nicht unbedingt produktiver wäre.

Zudem muss man bei den meisten IDEs einen Editor der Wahl angeben, tja, und was soll das denn dann, wenn mir der Compiler, spätestens der Linker, das Runtimemodul oder was sonst noch hintendranhängt, haarklein erzählt, warum er die Zusammenarbeit verweigert.

Der Gau war ja mal der Assistent vom Qt, mit dem ich eine Spielfläche mit 64 Buttons (Reversi) aufbauen wollte. Die Oberfläche war ja schnell mittels klick-klick-copy-paste erstellt, aber die Reihenfolge der Elemente (Indices) programmiertechnisch unbrauchbar, der Code selbst total umständlich, auch ohne dass ich irgendwie "Hand angelegt" hatte

Übertroffen wurde das Ganze noch vom frühen Netscape-Editor zum Erstellen von HTML-Seiten. Und Dreamweaver-Seiten erkannte man schon beim Laden.

Nee, das Höchste, was ich mir da gefallen lasse, ist so was im Stil von J2ME, man nehme den Lieblingseditor und wähle Compiler, Packager, Verifier und Handy-Emulator per Menu an.

so long,
BlueJay

[jan61]

Moin,

Autocompletion:

Nein, ich muss schon selbst wissen, welche Klassen ich wie verwenden möchte, die Beschreibung der Sun-Bibliotheken liegt immer in einem 2.Fenster irgendwo rum. Da kann ich mir dann aussuchen, welche Variante meinen Wünschen am besten entspricht, welche "Overkill" betreibt, oder ob es noch was Besseres gibt.

Das Javadoc von Sun habe ich auch immer parat, aber darum ging es mir nicht. In Eclipse tippst Du einen Klassennamen (per <Ctrl>-Blank kannst Du Dich auch dabei unterstützen lassen), dann ".", und dann werden Dir alle Methoden (die mit den passenden Rückgabewerten zuerst) angezeigt. Mit jedem weiteren Buchstaben wird die Liste kleiner, so dass meist schon nach 1 - 2 Buchstaben der Methode ein beherztes <ENTER> ausreicht, um die Methode inkl. der Klammern und einem Tooltip zu haben, in dem Dir der Typ des einzusetzenden Parameters angezeigt wird. Damit bin ich wesentlich schneller (vor allem bei Konstrukten wie klasse1.methode2.methode3...) als wenn ich das manuell eintippe, und es verhindert Fipptehler ;-)

Autoimport:

Ich arbeite mit "import dingsbumsda.watt;" und bekomme einen Überblick, was der sich so alles an Land zieht.

Das Praktische an Eclipse ist, dass er Dir z. B. bei nicht eindeutigen Methoden- / Klassenbezeichnungen eine Liste aller in Frage kommenden Imports anbietet und nebenbei gleich noch nicht mehr benötigte Imports rausschmeisst (so nach dem Motto: Hashtable benutzt - ach nein, da reicht ja eine ArrayList - schwupps ist der Hashtable-Import draussen und ArrayList drin).

2x Taste up, 1-2x enter , und solche Schönheiten und Fingerzeige erscheinen, gilt auch für den Rest des Abschnittes. Als Anfänger muss ich da leider manchmal etwas scrollen.

Das kriegst Du in Eclipse ganz ohne Zutun sofort serviert. Einfach die Maus auf die Markierung an der Stelle, wo ein Fehler ist, draufhalten - schon ist der Fehler erklärt.

Da liegt so ein (Sun) Comand-Line-Tool rum, was so was kann, habe ich mich aber noch nicht mit beschäftigt.

Das Ding heisst javadoc, das benutzt Eclipse auch. Aber Du kannst Dir (konfigurierbar) das Skelett dafür erstellen lassen: /** eingeben, <Enter> drücken, und schon hast Du die Parameter, Rückgabewerte und Exceptions Deiner Methode vorgegeben (gilt im Übrigen auch für Klassen- und Package-Beschreibungen). Wenn Du mit Deinem Projekt fertig bist, dann einmal "Generate Javadoc" und Du hast die Doku genauso wie die von Sun für die Verwendung im Browser fertig. Sowas ist lebenswichtig, wenn Du auch mal entspannt Urlaub machen willst ;-)

Formatieren, Auskommentieren:

1. habe ich einen anderen Geschmack (ANSI),
2. bin ich schneller (/* */)und weiss, was ich getan habe.

Wie schmeckt ANSI? Ich meinte damit die z. B. Fähigkeit, nach einem umfänglicheren Umbau eines Codeblocks per <CTRL>-i das Einrücken wieder gerade zu ziehen. Oder z. B. Tabs automatisch in Leerzeichen zu verwandeln (ich hasse Tabs - der Code sieht auf jedem Rechner und mit jedem Editor anders und meist wie Unkraut aus). Wie Code-Completion (für häufig benutzte Konstrukte) aussehen soll, kannst Du konfigurieren, .... Zu 2.: da könnten wir ja mal wetten ;-) - markieren und <CTRL>-7 - fertig. Auch eine IDE nimmt Dir das Nachdenken nicht ab, aber wenn Du z. B. eine Zeile zuviel auskommentiert hast, siehst Du in Eclipse sofort ein rotes Lämpchen.

Mein Debugger heisst System.out.println

Das ist mir viel zu aufwändig. Ich will gezielt zu den Breakpoints hüpfen können, an denen mich der Code nervt und mir dann in aller Ruhe alle aktuell gültigen Objekte und deren Properties anschauen können (oft ist ja gar nicht ersichtlich, welche davon Quatsch macht) - Du kannst übrigens in Eclipse so auch ganz bequem Collections und komplette Objekte parsen; sie auch mal zur Laufzeit ändern ... Da will ich nicht jedesmal den Code anfassen und neu kompilieren müssen. Und ich will auch mal in andere Packages / Projekte springen können (Step Into), weil doch schon mal in einer Basisklasse der Wurm stecken kann. Selbst wenn Du im aktuellen Projekt diese Klasse aus einem JAR nutzt, kannst Du sie debuggen, wenn der Quellcode mit drin steckt oder in Deinem Workspace offen ist.

Veraltete Methoden wirft dir javac entgegen.
Der Pfad eines Fehlers wird genauestens von java aufgelistet, und eigentlich muss man dann nur die Methode in der angegebenen Klasse finden, also im Krusader f4, suchen, eingeben, und mer ist da. F3 hoppst dann von Aufruf zu Aufruf

Genau das meine ich: Wenn Du in Eclipse entwickelst, siehst Du solche Sachen sofort beim Editieren (Runtime-Exceptions wie die berühmte NullPointerException ausgenommen, aber auch da kriegst Du Hilfe - wenn Du z. B. nicht initialisierte Objekte benutzt). Damit vermeidest Du auch Folgefehler, weil Du eben sofort auf (potenzielle) Fehlerursachen hingewiesen wirst. Dazu gehört auch, dass Du beim Editieren z. B. darauf hingewiesen wirst, wenn Du Exceptions nicht abfängst oder weiterreichst oder dass Eclipse rummault, wenn Du nicht an allen Ausstiegs-Haltestellen Deiner Methode den deklarierten Rückgabewert lieferst.

Packages, Klassen oder Methoden kopieren:

Keine Ahnung, auf jeden Fall brauche ich länger, um zu entscheiden, ob ich die Klasse so verwenden kann oder doch besser eine Unterklasse davon schreibe. (Klick-Ratsch F4, 2x neuen Namen eingeben, Ctrl-s, drübergucken dauert dann am längsten).

Das meine ich nicht. Ich habe manchmal die Situation, dass ich für individuelle Kundenanpassungen Klassen ähnlich wie bei anderen - aber eben nicht identisch - bauen muss. Dann suche ich mir meist die am besten passende Klasse (egal in welchem Projekt meines Workspace), mache einmal <Strg>-c, <Strg>-v und schon habe ich eine Kopie. Wenn es Namenskollisionen gibt oder ich bewusst umbenennen will, dann sorgt Eclipse dafür, dass auch alle Referenzen, Text-Matches usw. angepasst werden (ggf. im Dialog, wenn Eclipse nicht entscheiden kann, ob in Package X, Klasse Y die Methode Z auch umbenannt werden muss). Du musst nicht erst suchen oder per Find/Replace womöglich zu viel umbenennen, weil Du gleich die Übersicht (inkl. Code-Ausschnitt) darüber hast.

Mittlerweile habe ich natürlich auch Klassen, die in die "Privatbibliothek" gewandert sind.
Da wird je nach Verwendung einfach schnöde importiert oder ins Paket einverleibt (Klick-Ratsch, F4, 1xPaketnamen eingeben).

Selbstverständlich, Wiederverwendbarkeit soll ja angeblich eine der großen Errungenschaften von OOP sein ;-) - da gibt es bei uns z. T. sehr umfangreiche Frameworks. Aber auch da gibt es Situationen, in denen Du in irgendeiner selten verwendeten Methode oder mit ausgefallenen Parametern eine Klasse auf dem falschen Fuß erwischst. Und da ist es eben schön, wenn Du die auch mal schnell debuggen kannst und nicht Stunden oder Tage mit der Fehlersuche in Deinem Code zubringst.

Änderungen testen:

ca. 3, bis das geänderte Programm läuft

Ätsch: 1 ;-) (SCNR) Und ich sehe die Programmausgabe ohne Fensterwechsel innerhalb der IDE.

Suns JDK bringt da eine ganze Menge Komfort mit, so dass ich mit Eclipse nicht unbedingt produktiver wäre.

Ich empfehle Dir, mal die Zeit zu investieren und die Möglichkeiten von Eclipse mal intensiv und unvoreingenommen auszuprobieren.

Zudem muss man bei den meisten IDEs einen Editor der Wahl angeben...

In Eclipse nicht. Überhaupt ist der eingebaute Eclipse-Editor (zumindest für Java) meiner Meinung nach einer der besten, die ich je erlebt habe. Der aus M$-VisualStudio z. B. erzeugt bei mir jedesmal Brechreiz. Eclipse bietet an fast allen Stellen sinnvolle Defaults (ohne Dich dabei zu hindern, bis zum Koma Konfigurationseinstellungen anzupassen), so dass Du eigentlich sofort nach Installation loslegen kannst. Was für mich auch sehr wichtig ist: Du kannst für jedes Projekt entscheiden, mit welcher JRE-Version Du arbeitest und welche Code-Kompatibilität (1.4, 5.0, ...) Eclipse benutzen soll, um Dir auf die Finger zu schauen. Ich muss nämlich sowohl Kunden mit 1.4 als auch mit 5.0 bedienen können. Und bei einem Upgrade meiner Projekte habe ich das volle Verständnis von Eclipse ;-)

Ich will nicht behaupten, dass Eclipse immer und in jeder Situation die eierlegende Wollmilchsau ist (in Sachen GUI-Entwicklung z. B. hinkt Eclipse AFAIK hinter NetBeans hinterher - ich bin aber noch nicht dazu gekommen, mir das näher anzugucken, ich bin meist auf Serverseite unterwegs), aber das Ding hat bei mir bisher am schnellsten und nachhaltigsten Punkte gegenüber anderen IDEs (VB, Delphi, KDevelop, VisualStudio, QtDesigner, ...) und Editoren (vim, SCiTE, UltraEdit, Kate, ...), die ich gezwungenermaßen oder aus eigenem Entschluss probiert habe, gesammelt. Das liegt sicher auch am Charme von Java (und dessen Riesenangebot an Bibliotheken) und den unzähligen verfügbaren Eclipse-Plugins, aber eben auch daran, dass ich bald gemerkt habe, wie schnell und sauber ich damit Code erzeugen kann.

Jan

P.S.: Für Shell, Perl, Tcl, PHP & Co, nehme ich nach wie vor vim (oder Kate, wenn es schlimm kommt und es mehr als 5 Module werden)

[zerix]

Hallo,

ich möchte auch mal meine Meinung kund tun.

Wenn es um Java-Programmierung geht, arbeite ich am liebsten mit eclipse.
Wenn ich mal schnell ein shell-Script schreibe, dann nehme ich den vi.

@BlueJay
Also ich glaube, dass du bei einem paar Zeilen-Programm mit deinem Editor schneller bist, als ich mit eclipse. Ich glaube aber nicht, dass es bei größeren Applicationen so ist.
Ich arbeite mit an einem Project, welches mehrere tausend Klassen hat. Zudem nutzen wir ein Versions-Controll-System. Also wenn ich mir überlege da mit einem normalen Editor zu arbeiten. Das ist fast unmöglich. Da würde ich am Tag ja gar nichts garbeitet bekommen.

In eclipse muss man sich GUIs ja auch nicht zusammen klicken, man kann sie auch selbst schreiben. Eclipse nimmt mir auch ne Menge arbeit ab. Trotzdem weiß ich immer noch was ich mache und was passiert. Wenn ich Beispielsweise ein Interface mit 20 Methoden implementiere, reicht bei eclipse 3 Tastendrücke und ich hab alle Methoden fertig da stehen und muss nicht noch alles selbst schreiben.

Zum Thema Debugger. Also ich hab schon Situationen gehabt, da ist man nur mit sysouts nicht weit gekommen. Beim Debugger, kann man leicht sich mal schnell den Inhalt von Objection während der Laufzeit anschauen. Ich möchte mal sehen, wie du das mal schnell mit nem sysout gemacht hast.

Bei einem Anfänger verstehe ich es, wenn er noch mit einem "normalen" Editor programmiert. So lernt er am besten. Wenn man das aber schon kann, ist es blödsinn auch noch die kleinsten Arbeiten selbst zu erledigen.

Warum soll ich meine Zeit vergeuden um Methodenköpfe zu tippen, wenn ich ein Interface implementiere, wenn jemand das für mich machen kann?

Warum sollte ich meine Zeit mit imports verschwenden, wenn jemand die für mich schreiben kann und ich sehe was er schreibt?

MFG

zEriX