Java-Editor

Diese Seite ist nicht editierbar. Sie können den Quelltext sehen, jedoch nicht verändern. Kontaktieren Sie den Administrator, wenn Sie glauben, dass hier ein Fehler vorliegt.
=====Java-Editor=====

Integrierte Java-Entwicklungsumgebungen setzen hohe Anforderungen an die Ausstattung der Computer. Diese Anforderungen sind in der Schule nicht immer umzusetzen. Sollen die Schüler auch zu Hause mit diesen Entwicklungssystemen arbeiten, so kommen eigentlich nur frei verfügbare Systeme in Frage. Da bleiben kaum noch Systeme übrig, die in der Schule tatsächlich einsetzbar sind. Dies war für mich Anlass, den nachfolgend beschriebenen Java-Editor zu entwickeln.

Im Bild sehen Sie das Programmfenster des Java-Editors mit Menü- und Symbolleiste, sowie einigen Registern mit Hilfen zur Programmentwicklung. Die Ausstattung ist an den Notwendigkeiten der Schule ausgerichtet. Daher gibt es zum Beispiel das Register Programm mit den Programm-Grundstrukturen für Konsolen-Anwendungen, Applikationen und Applets und das Register Kontrollstrukturen mit den Java-Kontrollstrukturen. 

{{:de:editorde.png}}
<html><img src="http://vg08.met.vgwort.de/na/c9f095940ac64f408c4817f52cc1e6c7" width="1" height="1" alt=""></html>
                                             
===== Klassen-Modellierer =====

Mit dem Klassen-Modellierer können Sie neue Klassen erzeugen und bestehende Klassen bearbeiten. Er liest Java-Dateien und stellt sie als Klasse mit Attributen und Methoden dar. Änderungen im Klassen-Modellierer werden direkt in die zugehörige Java-Datei übernommen. 

Der Klassen-Modellierer ist ein einfach benutzbares Werkzeug zur Modellierung von Klassen.

{{:de:classdesignerde.png}}

Die Reihenfolge der Attribute und Methoden im Strukturbaum kann mittels Drag&Drop verändert werden.

Den Klassen Modellierer rufen Sie über das Symbol {{:classmodeler.png}} im Editorfenster auf. Sie können auch im UML-Fenster die gewünschte Klasse doppelklicken oder das Kontextmenü benutzen, um den Klassen-Modellierer aufzurufen.

===== UML-Fenster =====
Nach dem Modellieren einer Klasse sollte man das Modell zu testen. Im UML-Fenster können Sie durch Aufrufen des Kontextmenüs einer Klasse mit der rechten Maustaste einen Konstruktor zum interaktiven Erzeugen eines Objekts aufrufen. Es wird dann ein Objekt dieser Klasse erzeugt.

Rufen Sie anschließend das Kontextmenü des Objekts auf, so können Sie die Attribute des Objekts editieren und Methoden des Objekts aufrufen.

Die interaktive Objekterzeugung orientiert sich an der entsprechenden BlueJ-Funktionalität. Es wird keine //main//-Methode benötigt, modellierte Klassen können also interaktiv getestet werden. 

{{:de:umlde.png}}

===== GUI-Designer =====
Nach dem Testen eines Modells im UML-Fenster kann man es in einem Konsolen- oder GUI-Programm benutzen.

Es ist ziemlich kompliziert eine graphische Benutzungsoberfläche mit Layout-Managern zu gestalten.
Schülerinnen und Schüler haben damit erhebliche Schwierigkeiten. Viel einfacher ist es mittels Drag&Drop GUI-Komponenten an die gewünschte Position auf dem Formular zu ziehen. Der im Java-Editor verfügbare GUI-Designer benutzt daher keine Layout-Manager sondern absolute Positionierung, womit man ziemlich schnell sein Layout gestalten kann, und das ist genau das, was in der Schule gebraucht wird. 

{{:de:guidesignerde.png}}

Zum Anlegen eines GUI-Formulars klicken Sie auf der Registerkarte //Programm// auf eines der sechs Symbole: Frame, Dialog, Applet, JFrame, JDialog oder JApplet.

Um eine GUI-Komponente zu platzieren, klicken Sie zuerst auf das entsprechende Symbol in einem AWT-, Swing- oder FX-Register und dann auf das GUI-Formular. Alternativ ziehen Sie eine GUI-Komponente aus einem Register in Ihr GUI-Formular und lassen sie dort fallen. Anschließend können Sie die GUI-Komponente dann positionieren und mit dem Objektinspektor konfigurieren. Der Quellcode wird entsprechend synchronisiert. Dazu werden die Abschnitte

  // Anfang Attribute
  // Ende Attribute

und

  // Anfang Komponenten
  // Ende Komponenten

benutzt. Diese Abschnittskennzeichnungen und der darin befindliche, automatisch erzeugte Quelltext darf nur auf eigene Gefahr geändert werden.

Über das Symbol {{:de:arrange.png}} eines Quelltext-Fensters können Sie das zugehörige GUI-Formular öffnen und zusammen mit dem Quelltext-Fenster anordnen.

Wenn Schülerinnen oder Schüler ein GUI-Formular erstellt haben, so müssen sie im Wesentlichen die Ereignisprozeduren der Buttons programmieren. Das bedeutet, dass sie Werte aus einigen GUI-Komponenten einlesen, dann die Verarbeitung der Daten vornehmen und zum Schluss die Ergebnisse in GUI-Komponenten ausgeben müssen. Ein größeres Problem dabei ist, dass für die Ein- und Ausgabe auf die GUI-Komponenten über ihre Namen zugegriffen werden muss. Den Namen einer GUI-Komponenten erfährt am einfachsten, wenn man mit der Maus über sie fährt.

Das GUI-Formular verfügt über ein Kontextmenü zur Bearbeitung der Komponenten.

In anderen Entwicklungssystemen wird die Struktur der grafischen Benutzungsoberfläche als Baum dargestellt. Der Java-Editor verzichtet auf ein weiteres Fenster und zeigt die Struktur im Quelltext durch entsprechendes Einrücken der zugehörigen Variablen an.

===== Java Interpreter =====
Ab Version 11.0 können Anweisungen und Ausdrücke interaktiv ausgeführt bzw. berechnet werden. 
Das Java-System verhält sich dabei wie ein Interpreter, das heißt die Eingaben werden zunächst auf
korrekte Syntax geprüft und dann ausgeführt. Der Zustand des Java-Systems wird als Variablentabelle dargestellt,
wobei für jede Variable Name, Typ und Wert angezeigt werden. In danach eingegebenen Anweisungen und Ausdrücken können diese Variablen verwendet werden.

Im folgenden Bild wird der Unterschied zwischen der Deklaration und Initialisierung von Variablen deutlich.
Beispiele zeigen die Verwendung der Variablentabelle und wie man mit Math.random() und String s die Wirkungen von Operatoren und Anweisungen verdeutlichen kann. 

{{:de:variablesde.png}}

Jeder Zeile wird nach dem Drücken der Return-Taste ausgeführt. Sie können auch Anweisungen, die sich über mehrere Zeilen erstrecken, eingeben. Drücken Sie dazu am Ende einer Zeile Umschalt- oder Strg+Return.
<code java>for (int i = 1; i < 5; i++) 
  System.out.println("i = " + i);</code>

Jedes UML-Fenster hat seine eigene Interpreter-Umgebung. Wenn Sie in einem UML-Fenster über das Kontextmenü von Klassen Objekten erzeugen und dann die Methoden von Objekten ausführen, so werden die betreffenden Anweisungen im zugehörigen Interaktiv-Fenster protokolliert. Diese Protokolle werden zusammen mit dem UML-Fenster gespeichert. Wird eine UML-Datei zur nächsten Unterrichtsstunde wieder geöffnet, kann man einen ganzen Block von Zeilen im Interaktiv-Fenster markieren und mit dem Befehl //Ausführen// des Kontextmenüs ausführen lassen. Sollten irgendwelche Schwierigkeiten oder unklare Zustände auftreten, können Sie über das Kontextmenü das Java-System auch zurück setzen. Dabei wird natürlich auch die Variablentabelle gelöscht.

Auch wenn keine UML-Datei geöffnet ist, hat man ein Interaktiv-Fenster zur Verfügung. Man kann also auch ohne die objektorientierten Konzepte den Interpretermodus benutzen. Diesem Interaktiv-Fenster ist ein unsichtbares UML-Fenster zugeordnet, das Sie über das Kontextmenü mit "UML zeigen" öffnen können. Es stellt detailliert die interaktiv angelegten Objekte dar, von denen man in der Variablentabelle nur die interne Bezeichnung sieht.

Man kann auch in einem Javaprogramm ein oder mehrere Zeilen markieren und dann auf {{:de:symbolrun.png}} klicken. Dann werden die markierten Zeilen im Interpretermodus ausgeführt. Auf diese Weise kann man bei der Besprechung von Programmen die Wirkung einzelner Programmzeilen verdeutlichen. Die Variablentabelle wird aktualisiert und Ein- und Ausgaben im Interpreterfenster dargestellt.

In der Konfiguration können Sie im Bereich Optionen festlegen, ob im Interpretermodus strikte Java-Syntax verlangt wird oder nicht. Die Standardeinstellung ist strikt. In der Einstellung nicht strict müssen keine abschließenden Semikola eingegeben werden. Auch sind Wertzuweiungen möglich, ohne zuvor die Variablen deklariert zu haben. Bei der Wertzuweisung

<code java>d = Math.random()*"abcde".length()</code>

wird zunächst der Ergebnistyp der rechten Seite bestimmt, dann die Variable d vom Typ double deklariert und zum Schluss die Wertzuweisung ausgeführt.

==== Einsatzmöglichkeiten des Java-Interpreters im Unterricht ====
Unterscheidung zwischen Deklaration und Erzeugung von Variablen
<code java>
  int a, b, c;
  int x = 7;
  double y = 8.9;
</code>
Dreieckstausch
<code java>
  String a = "Anton";
  String b = "Berta";
  String h;
  h = a;
  a = b;
  b = h;
</code>
Vergleich von Strings mit equals bzw. ==
<code java>
  String a = new String("Hallo");
  String b = new String("Hallo");
  a =====b;
  false
  a.equals(b);
  true
</code>
===== Struktogrammeditor =====
Ab Version 12.0 verfügt der Java-Editor über einen Struktogrammeditor, mit dem Struktogramme erstellt und bearbeitet werden können.

Die Modellierung von Abläufen mit Struktogrammen auf einer programmiersprachlich unabhängigen Ebene spielt im Informatikunterricht eine wichtige Rolle. Händisches Zeichnen von Struktogrammen auf Papier bringt keine ansehlichen Ergebnisse. Mit dem Struktogrammeditor können Struktogramme einfach, schnell und korrekt erstellt werden. Aus Struktogrammen kann Java-Quellcode generiert werden. Im Editor kann man Quelltext auswählen und daraus ein Struktogramm erzeugen lassen.

{{:de:structogramde.png}}

Per Drag&Drop können Struktogrammelemente in ein Struktogramm eingefügt und aus einem Struktogramm herausgezogen werden. Aus der linken Symbolleiste lassen sich Struktogramelemente herausziehen, zum Löschen kann man sie zurück auf die Symbolleiste ziehen. Leere Struktogrammelemente klickt man an und tippt den Text einfach ein. Zum nachträglichen Editieren doppelklickt man den betreffenden Text. 

Das grüne J erzeugt aus dem Struktogramm soweit möglich ein Java-Programm oder eine Java-Methode. In der Konfiguration können die im Struktogramm verwendeten Texte angepasst werden.

==== Puzzlemodus ====
Mit dem Puzzlemodus kann man interaktive Struktogrammpuzzles erstellen, bei denen die Schülerinnen und Schüler aus Puzzleteilen ein vollständiges Struktogramm erstellen. Zum Herstellen eines Struktogrammpuzzles beginnt man mit der Lösung, die aus einem einzigen Algorithmus-Struktogramm bestehen muss. Dazu ruft man im Kontextmenü des Struktogramms den Puzzlemodus auf.

Ziehen Sie die Struktogrammelemente aus dem vollständigen Struktogramm heraus, wobei der ursprüngliche Platz als leerer Platzhalter erhalten bleibt. 
{{:de:puzzleeinfach.png}}
Die Puzzleelemente behalten die ursprüngliche Form in Breite und Höhe bei. Beim Zusammenpuzzlen passen Puzzleteile nur, wenn sie die passende Größe haben. 
Speichern Sie in dieser Fassung das Struktogrammpuzzle. Es erscheinen dann drei weitere Puzzles und zwar unterschieden nach //leicht//, //mittel//, //schwer// und //ganz schwer//, die Sie noch Nachbearbeiten können.

Im Modus //mittel// wird die Höhe der Puzzleteile auf die Standardhöhe reduziert. 

{{:de:puzzlemittel.png}}

Man kann Puzzleteile in leere Struktogrammelemente schieben oder zwischen vorhandene Struktogrammelemente platzieren. Es wird nicht mehr die Höhe, sondern nur noch die Breite kontrolliert. Nur wenn diese zur Einfügestelle passt, kann ein Puzzleteil dort eingefügt werden. Man kann die Schwierigkeit dadurch erhöhen, dass man in Sequenzen leerer Struktogrammelemente einige Struktogrammelemente entfernt. 

Im Modus //schwer// wird außer der Höhe auch die Breite der Struktogrammelemente auf die Standardgröße gebracht. 

{{:de:puzzleschwer.png}}

Puzzleteile können nun an beliebiger Stelle eingefügt werden, weder Breite noch Höhe müssen passen. 

Im Modus //ganz schwer// werden zusätzlich, soweit möglich, leere Struktogrammelemente entfernt.

Die Schülerinnen und Schüler können sich im Unterricht eine für sie passende Puzzlevariante auswählen. Wenn sie eine Lösung erstellt haben, können Sie diese durch Anklicken des Puzzle-Buttons {{:de:puzzlebutton.png}} selbstständig prüfen. Der Java-Editor teilt mit, ob die Lösung gefunden ist oder noch etwas geändert werden muss.

Beim Wechsel in den Puzzlemodus muss die vollständige Lösung in einem einzigen Struktogramm vorliegen. Von dieser Lösung merkt sich der Java-Editor eine Textdarstellung und vergleicht sie mit der Textdarstellung der Schülerlösung.

Wenn es bei zwei aufeinander folgenden Anweisungen nicht auf die Reihenfolge ankommt, ist auch eine Lösung mit vertauschter Reihenfolge inhaltlich richtig. Das kann aber vom Java-Editor nicht kontrolliert werden. Daher sollte man in solchen Fällen die zwei Puzzleteile nicht auseinander nehmen.










===== Sequenzdiagramm =====

Mit dem Sequenzdiagramm-Werkzeug können Sie ein Sequenzdiagramm interaktiv erstellen. Lebenslinien gibt in zwei Formen, als Akteur und mit benanntem Kopf. Sie werden mit Hilfe der Symbolleiste eingefügt. Zum Herstellen einer Verbindung zwischen Lebenslinien benutzt man das Kontextmenü einer Lebenslinie und ruft dort //verbinden mit// auf. Zum Verändern von Texten rufen sie den Texteditor durch Doppelklicken auf.

{{:de:sequenzdiagramm.png}}

Sie können eine Debuggersession über das Menü //Test/Erzeuge Sequenzdiagramm// als Sequenzdiagramm darstellen lassen. Analoges gilt für die Arbeit ohne bzw. mit Debugger im UML-Fenster.  
===== Menü-System =====

==== Datei-Menü ====

Das Datei-Menü stellt die üblichen Operationen wie //Neu//, //Öffnen//, //Speichern// und //Drucken// zur Verfügung. Alle geöffneten Fenster können als Java-Editor-Projekt (.jep-Datei) gespeichert werden. //Alle speichern in// speichert alle Fenster in einem anderen Ordner. Eine Java-Datei können Sie im HTML und RTF-Format exportieren, um die farbige Syntaxauszeichnung außerhalb des Editors verwenden zu können.

==== Editor-Menü ====
Der Editor unterstützt die Arbeit mit der Windows-Zwischenablage, mehrstufiges Rückgängig machen von 
Editoroperationen und das Suchen und Ersetzen von Texten. Markierter Text kann in unterschiedlichen 
Formaten kopiert werden. Suchen und Ersetzen ist in Dateien und mit regulären Ausdrücken möglich. 
Sie können markierten Texte einrücken (Strg+Umsch+I), ausrücken (Strg+Umsch+U) sowie ein- und 
auskommentieren (Strg+K). Zur einfachen Verwendung der Konsolenausgabe fügt Strg+U //System.out.println()// in den 
Quellcode ein, Strg+Y löscht eine Zeile. Sie können bis zu zehn Lesezeichen mit der Maus oder der 
Tastatur (Strg+Umsch+#) setzen und zu einem Lesezeichen springen (Strg+#). Jeder Befehl des 
Editor-Menüs hat ein Taststenkürzel und ein Symbol auf der Symbolleiste. Der Editor basiert 
auf der [[https://github.com/SynEdit/SynEdit| SynEdit Komponente]]. 
In der [[Konfiguration#Tastatur|Konfiguration]] kann man sich eine Liste aller Tastenkürzel anzeigen lassen.

==== Start-Menü ====
Über das Start-Menü bzw. die zugehörigen Symbole kann das im aktiven Editor-Fenster stehende Programm compiliert werden. Wenn Sie den //jikes//-Compiler installieren haben Sie einen zweiten Compiler zur Verfügung. Fehlermeldungen werden im Compiler-Fenster angezeigt. Per Doppelklick auf eine Fehlermeldung wird der Cursor an die Fehlerstelle im Quelltext positioniert. Falls die Fehlermeldung unverständlich ist, ist es eine gute Idee mit den anderen Compiler zu verwenden. Manchmal sind dessen Fehlermeldungen besser verständlich.

Wenn Sie ein Programm //starten//, das zuvor geändert wurde, wird es automatisch gespeichert, compiliert und falls fehlerfrei gestartet.

Applets werden im Appletviewer angezeigt. Die zum Aufruf nötigen HTML-Dokumente werden automatisch oder manuell per Befehl generiert. Startet Sie das zum Applet gehörige HTML-Dokument, so wird das Applet im Browser angezeigt. 

Zusätzlich lassen sich über das Start-Menü der Debugger, Disassembler und JavaDoc-Dokumentierer aufrufen. Mit dem Jar-Untermenü können Sie jar-Dateien ausführbare jar-Dateien erzeugen. Der Pack-Befehl unterstützt den einfachen Austausch von Dateien zwischen Schülern und Lehrern. In der Konfiguration wird festgelegt, welche Dateien gepackt werden. Eine gepackte jar-Datei kann leicht auf eine Lernplattform wie z. B. Moodle hochgeladen oder per E-Mail an den Lehrer geschickt werden.

==== Test-Menü ====
Mit den Befehlen des Test-Menüs führen Sie ein Programm unter der Kontrolle des Debuggers aus.
Wenn ein Haltepunkt in einer Java-Datei gesetzt ist und Sie ihr Programm starten, wird der Debugger benutzt. Nach dem Erreichen eines Haltepunktes wird die Ausführung unterbrochen. Sie können dann ihr Programm schrittweise ausführen. Während des Debuggens zeigt das Meldungsfenster detaillierte Informationen über Attribute, Parameter, lokale Variable, überwachte Ausdrücke und den Aufrufstack. 

Um ein GUI-Programm zu debuggen setzen Sie einen Haltepunkt an die gewünschte Stelle. Starten Sie ihr GUI-Programm und warten Sie, bis das GUI-Formular gezeigt wird. Klicken Sie dann den Schalter an, der zum Aufruf der Stelle mit dem Haltepunkt führt.

==== UML-Menü ====
Mit dem UML-Menü können Sie neue UML-Fenster öffnen, neue Klassen anlegen und Klassen öffnen und bearbeiten. Zum Speichern und Laden von Klassendiagrammen benutzen Sie die normalen Öffnen und Speichern-Symbole und wählen dabei den Dateityp '.uml' aus. Sie können ein Klassendiagramm als Bild speichern oder in die Zwischenablage zur direkten Weiterverarbeitung kopieren. Mit dem Befehl 'Ordner öffnen' können Sie aus allen Java-Dateien eines Ordners sowie seiner Unterordner ein Klassendiagramm erstellen. Wenn Sie schon ihre Java-Dateien geöffnet haben benutzen Sie einfach //Diagramm aus Dateien// um ein Klassendiagramm zu erzeugen.

Das UML-Fenster bietet eine reichhaltige Symbolleiste zur Bearbeitung des Klassendiagramms an. Klassenbeziehungen werden automatisch erkannt, sofern entsprechende Attribute vorhanden sind. Anderenfalls können Sie Klassen manuell miteinander verbinden. Markieren Sie dazu die Startklasse und ziehen Sie dann mit der Maus eine Verbindung zur Zielklasse. 

==== Komponenten-Menü ====
Standardmäßig wird das Komponenten-Menü nicht angezeigt. Es steht für sehbehinderte oder blinde Benutzer zur Verfügung, die keine Maus benutzen können. Das Komponenten-Menü ermöglicht die Erstellung von GUI-Oberflächen ohne den GUI-Designer.

==== Tools-Menü ====
Das Tools-Menü bietet das //Checkstyle//-tool an, das die Einhaltung eines Codierstandards für einen 
Java-Quelltext prüft. Das //Jalopy//-tool formatiert einen Java-Quelltext gemäß einem vorgegebenen 
Codierstandard. Das Tool zum Vergleichen von Dateien zeigt neue, geänderte und gelöschte Zeilen. 
Änderungen können in die jeweils andere Datei übernommen werden. 
Wenn Sie die Versionsverwaltung [[Konfiguration#git|Git]] oder [[Konfiguration#subversion|Subversion]] installieren, erscheint ein eigenes Git- bzw. Subversion-Untermenü.

{{:de:comparede.png}}

==== Fenster-Menü ====
Neben den Grundfunktionen zum Anordnen, Öffnen und Schließen von Fenstern können Sie Symbolleisten anzeigen oder verstecken, Konsolen-, Explorer- und Browser-Fenster öffnen. Zusätzlich können Sie für das aktive Fenster die Schriftart wählen und den Konfigurationsdialog aufrufen.

==== Hilfe-Menü ====
Das Hilfe-Menü gibt Zugriff auf die Java-Dokumentation, Demos und das Tutorial.
Sie können das Javabuch in HTML-Form integrieren, haben einen Verweis auf die Java-Editor Homepage und können den Java-Editor updaten.

=====Betriebssysteme =====

==== Windows ====

Der Java-Editor wird unter Windows entwickelt.

==== Linux ====

Der Java-Editor funktioniert unter Linux mit der //Wine//-Erweiterung. Hinweise zur Installation finden Sie auf der [[http://appdb.winehq.org/objectManager.php?sClass=version&iId=29838 |WineHQ Seite]]. Unter Wine wird die Schriftart Monospace empfohlen. Manche Schriftarten funktionieren nicht im Editor. Und so siehst es unter {{:de:ubuntu.png?linkonly|Ubuntu}} aus.


==== Mac ====

Der Java-Editor läuft auf dem Mac sowohl mit CrossOver Office (Wine) als auch in einer virtualisierten Windows XP-Instanz problemlos.

Bei einem 64-Bit Mac funktioniert er unter der Virtualisierungssoftware VMWare Fusion einwandfrei. Die Alternativen Boot Camp, VirtualBox, CrossOver und Parallels scheinen dies nicht zu ermöglichen.


==== Mac M1/M2 ====
Auf einem Mac mit M1 oder M2 Prozessor kann man den JavaEditor wie folgt einrichten.
Zunächst lädt man die kostenlose Software UTM herunter https://mac.getutm.app/ und installiert diese.
Zur Installation zieht man im UTM-Fenster das UTM-Icon auf das Applications-Icon.

{{:utm.png}}

Die bei UTM befindlichen Anleitungen zum Download einer Windows-ISO-Datei sind kompliziert und führen oft nicht zum Ziel. Daher installiert man sich im nächsten Schritt die Testversion von Paralles für Mac https://www.parallels.com/de/products/desktop/. Mit Parallels lädt man dann eine funkionierende Windows-11-ISO-Datei herunter. Die Testversion von Parallels deinstalliert man wieder.

Zum Schluss ruft man UTM auf und erzeugt sich eine virtuelle Maschine mit Windows 11. In diese virtuellen Maschine installiert man Java und den JavaEditor. 
===== Barrierefreiheit =====
Der Java-Editor hat spezielle Unterstützung für Sehbehinderte und Blinde. Im Optionen-Menü kann die Schriftgröße für das Komponenten-Menü eingestellt werden. Die Schriftgröße für den Editor und weitere Fenster stellt man über das Symbol Schriftgröße oder das Schriftarten-Menü ein.

Wenn nicht mit der Maus gearbeitet werden kann, so schaltet man die Darstellung der Symboleiste im Fenster-Menü ab und aktiviert in der Konfguration bei den Optionen die Option //Komponentenmenü anzeigen//. Mit dem Komponenten-Menü kann man GUI-Formulare ohne Mausbenutzung erstellen.

===== Einführung in den Java-Editor mit Applets =====
Stefan Bartels hat freundlicherweise eine {{:de:Einfuehrung_Java-Editor.pdf|Einführung in den Java-Editor mit Applets}} bereitgestellt.

===== Meinungen und Bewertungen =====
Auf der Seite http://www.heise.de/software/download/java_editor/61374 finden Sie Meinungen und Bewertungen zum Java-Editor. Wenn Sie den Java-Editor nutzen und Gefallen daran gefunden haben, würde ich mich über Ihre Bewertung oder auch Meinung freuen.

===== Fehler und Wünsche =====
Hinweise auf Fehler und  Erweiterungswünsche können Sie per E-Mail an Gerhard Röhner schicken: <groehner@t-online.de>

[[Android]]