|
|
|
|
© APSIS GmbH |
Seite 117
Seite 118
Seite 118
package lehrbuch.kapitel6; // (6.1)
public class LeerMenue {
public void menue(); // vier wirkungslose Menüpunkte + Ende ¬
}
public class LeerMitMenue extends java.applet.Applet { // (6.2)
public void start() {
lehrbuch.kapitel6.LeerMenue leerMenue = new lehrbuch.kapitel6.LeerMenue();
leerMenue.menue(); // ¬
lehrbuch.Programm.meldung("Ende"); // erscheint nach Beendigung des Menüs
}
}
Übung 6.1: Rufen Sie die Methode menue der Klasse lehrbuch.kapitel6.SpezialMenue in einem Programm auf. Betrachten Sie das Ergebnis. Den Aufruf können Sie mit der Auswahl des Menüpunkts "Ende" verlassen.
Übung 6.2: Die Klasse lehrbuch.kapitel6.EimerMenue ist geeignet, das Füllen und Entleeren von zwei Eimern zu steuern. Benutzen Sie sie zusammen mit der Klasse lehrbuch.Eimer in einem Programm. Hier müssen Sie beim Aufruf der Methode menue (für ein geeignetes Objekt) ihr zwei (von Ihnen vereinbarte) Datenbehälter der Klasse Eimer als Parameter angeben. Durch die Menüauswahl "Fuellen links Wasser" wird der erste Eimer mit Wasser gefüllt, durch die Auswahl "Fuellen rechts Wein" wird der Zweite mit Wein gefüllt. Mit "Entleeren links" und "Entleeren rechts" kann der Erste bzw. der Zweite entleert werden. Der letzte Menüpunkt "Ende" bewirkt das Verlassen des Aufrufs von menue, d.h. anschließend werden die Anweisungen ausgeführt, die Sie nach dem Aufruf menue in Ihrem Programm geschrieben haben. Entleeren Sie zum Schluss beide Eimer. Im Fenster sehen Sie selbstverständlich nur jene Eimer, die Sie vor dem Aufruf von menue mit anzeigen sichtbar gemacht haben.
Das Profil der Methode menue befindet sich in der Spezifikation der Klasse lehrbuch.kapitel6.EimerMenue:
package lehrbuch.kapitel6; // (6.3)
public class EimerMenue {
public void menue(Eimer links, Eimer rechts); // Menü für zwei Eimer ¬
// Ein Menü für Füllen und Entleeren wird im Fenster dargestellt.
// Der Aufruf kann mit der Auswahl von "Ende" verlassen werden.
}
Seite 119
public class AnonymesObjekt extends java.applet.Applet { // (6.4)
public void start() {
new lehrbuch.kapitel6.LeerMenue().menue(); // anonymes Objekt ¬
}
}
Seite 119
eimer.fuellen(Eimer.WASSER);
Eimer.meldung ("Eimer wurde mit Wasser gefuellt");
import lehrbuch.*; // Eimer, LeerAusn, VollAusn // (6.5)
import lehrbuch.kapitel6.EimerMenue;
public class ZweiEimerMitMenue extends java.applet.Applet {
public void start() {
try {
Eimer eimer1 = new Eimer(), eimer2 = new Eimer();
Eimer.meldung("Guten Tag!"); // Begrüßung
eimer1.anzeigen(); // Eimer werden sichtbar gemacht
eimer2.anzeigen();
Eimer.meldung("Füllen und leeren Sie Ihre Eimer über das Menü");
Eimer.meldung("Verlassen Sie das Menü mit vollen Eimern");
new EimerMenue().menue(eimer1, eimer2); // Eimer interaktiv füllen ¬
eimer2.entleeren(); // eimer2 wird entleert
eimer2.fuellen(eimer1.inhalt()); // dann wieder gefüllt
}
// Ausnahmen durch Bedienungsfehler werden aufgefangen:
catch (LeerAusn ausnahme) { Eimer.meldung("Eimer leer", "Bedienungsfehler"); }
catch (VollAusn ausnahme) { Eimer.meldung("Eimer voll", "Bedienungsfehler"); }
catch (Exception ausnahme) { Eimer.meldung("Ausnahme", "Programmfehler"); } // ¬
finally { Eimer.meldung("Auf Wiederrechnen"); } // Verabschiedung
}
}
Seite 120
Seite 120
new FMenue().menue(rueckrufprozedur); // nicht in Java
new FMenue().menue("rueckrufprozedur");
import lehrbuch.*; // Eimer, LeerAusn, VollAusn // (6.6)
public class UmfuellenMitProzedurparameter extends java.applet.Applet {
public void umfuellen(Eimer ziel, Eimer quelle) {
// Inhalt von quelle wird nach ziel übertragen; anschließend quelle geleert
try {
ziel.fuellen(quelle.inhalt());
quelle.entleeren();
}
catch (LeerAusn ausnahme) { Eimer.meldung("Eimer leer", "Bedienungsfehler"); }
catch (VollAusn ausnahme) { Eimer.meldung("Eimer voll", "Bedienungsfehler"); }
}
public void start() {
Eimer links = new Eimer(), rechts = new Eimer();
... // evtl. Eimer anzeigen
Eimer.meldung("Menüpunkt 'Frei' = Umfüllen");
new lehrbuch.kapitel6.FMenue().menue(links, rechts, "umfuellen"); // ¬
... // evtl. mit den Eimern weiterarbeiten
}
}
Abb. 6.1: Rückrufprozeduren
Seite 122
package lehrbuch.kapitel6;
import lehrbuch.Eimer;
public class FreiMenue {
protected void frei(Eimer e1, Eimer e2); // zum Überschreiben ¬
public void menue(Eimer links, Eimer rechts); // zum Aufrufen ¬
}
import lehrbuch.*; // Eimer, LeerAusn, VollAusn // (6.7)
class UmfuellenMenue extends lehrbuch.kapitel6.FreiMenue { // nicht public
protected void frei(Eimer ziel, Eimer quelle) {
// die formalen Parameter e1 und e2 heißen jetzt ziel und quelle ¬
// (die Namen der formalen Parameter gehören nicht zum Profil, nur ihre Typen)
... // wie im Programm (6.6)
}
public class UmfuellenMitMenue extends java.applet.Applet {
public void start() {
Eimer links = new Eimer(), rechts = new Eimer();
... // evtl. Eimer anzeigen
Eimer.meldung("Menüpunkt 'Frei' = Umfüllen");
new UmfuellenMenue().menue(links, rechts); // ¬
... // evtl. mit den Eimern weiterarbeiten
}
}
Abb. 6.2: Rückruf durch Überschreiben
Seite 123
import lehrbuch.*; // Eimer, LeerAusn, VollAusn // (6.8)
class ErsetzenMenue extends lehrbuch.kapitel6.FreiMenue {
protected void frei(Eimer ziel, Eimer quelle) { // ¬
// ziel wird zuerst geleert, dann mit dem Inhalt von quelle gefüllt
try {
ziel.entleeren();
ziel.fuellen(quelle.inhalt());
}
catch ... // Ausnahmen LeerAusn und VollAusn auffangen
}
}
public class UmfuellenUndErsetzen extends java.applet.Applet {
public void start() {
Eimer links = new Eimer(), rechts = new Eimer();
... // evtl. Eimer anzeigen
Eimer.meldung("Menüpunkt 'Frei' = Umfüllen");
new UmfuellenMenue().menue(links, rechts); // aus dem Programm (6.7) ¬
Eimer.meldung("Menüpunkt 'Frei' = Ersetzen");
new ErsetzenMenue().menue(links, rechts); // ¬
}
}
Übung 6.3: Tippen Sie zuerst das Programm (6.8) aus Seite 123 mit Ihren eigenen Bezeichnern ein. Versuchen Sie dabei, seine Arbeitsweise zu verstehen. Testen Sie es. Entwickeln Sie anschließend Ihr eigenes Programm auf folgende Weise; Sie werden dabei verstehen, wie an ein Menüpunkt verschiedene Prozeduren mit Hilfe von Parameterprozeduren angehängt werden:
Erzeugen Sie zwei Eimer, die Sie zu Anfang durch anzeigen sichtbar machen. Definieren Sie anschließend zwei verschiedene Rückrufprozeduren (mit je zwei Eimer-Parametern): Sie sollen den ersten Parameter-Eimer mit wasser bzw. wein füllen und den Zweiten unverändert lassen. Die Rückrufprozeduren sollen Sie in zwei Aufrufen der Methode menue aus den zwei Unterklassen von FreiMenue durch Menüauswahl nacheinander aktiviert werden können. Informieren Sie den Anwender zuvor über die jeweilige Auswirkung des Menüpunktes "Frei" in einem Meldungsfenster vor dem Menüaufruf.
Führen Sie Ihre Rückrufprozeduren mit der Auswahl des Menüpunkts "Frei" aus. Die einzelnen menue-Aufrufe können Sie mit der Auswahl des Menüpunkts "Ende" verlassen. Vergleichen Sie das sichtbare Ergebnis (die Wirkung der Menüauswahl "Frei") der verschiedenen Rückrufprozeduren.
Bemerkung: Die Ausnahmen VollAusn und LeerAusn werden in der Klasse FreiMenue aufgefangen: Sie weist die Fehlbedienung über ein Meldungsfenster zurück. Anschließend kann eine neue Auswahl erfolgen. Ähnlich müssen Sie sie in Ihren Rückrufprozeduren auffangen, da die Methode menue keine Ausnahmen exportiert.
Seite 124
import lehrbuch.*; // Eimer, LeerAusn, VollAusn // (6.9)
public class GeschachtelteKlasse extends java.applet.Applet {
class ErsetzenMenue extends lehrbuch.kapitel6.FreiMenue { // geschachtelt ¬
... // wie im Programm (6.8)
}
public void start() { ... // wie im Programm (6.8)
new ErsetzenMenue().menue(links, rechts); // ¬
}
}
Seite 125
import lehrbuch.*; // Eimer, LeerAusn, VollAusn // (6.10)
public class AnonymeKlasse extends java.applet.Applet {
public void start() { ... // wie im Programm (6.8)
new lehrbuch.kapitel6.FreiMenue() { // anonyme Klasse erweitert FreiMenue ¬
... // Klassenvereinbarung wie im Programm (6.8)
}.menue(links, rechts); // Aufruf der Methode menue der anonymen Klasse ¬
}
}
Oberklasse referenz = new Oberklasse() { ... };
Seite 125
public class ZweiMeldungenMitMenue extends java.applet.Applet { // (6.11)
class ZweiMeldungenMenue extends lehrbuch.kapitel6.Menue2 { // innere Klasse
protected void ersterPunkt() {
lehrbuch.Programm.meldung("Erster Menüpunkt");
}
protected void zweiterPunkt() {
lehrbuch.Programm.meldung("Zweiter Menüpunkt");
}
}
public void start() {
new ZweiMeldungenMenue().menue(); // ¬
}
}
package lehrbuch.kapitel6; // (6.12)
public class Menue2 {
protected void ersterPunkt(); // zum Überschreiben
protected void zweiterPunkt(); // zum Überschreiben
public void menue(); // zum Aufrufen
}
Seite 126
public class ZweiLeereMenuepunkte extends java.applet.Applet { // (6.13)
public void start() {
new lehrbuch.kapitel6.Menue2().menue(); // geschieht nichts, außer bei "Ende" ¬
}
}
package lehrbuch.kapitel6; // (6.14)
public abstract class MenueAufg extends java.applet.Applet { // ¬
abstract protected void ersterPunkt(); // aufgeschobene Methode ¬
public void menue(); // zum Aufrufen
public void start(); // zum Überschreiben; ruft menue auf
}
import lehrbuch.Programm; // (6.15)
public class EinMenuePunkt extends lehrbuch.kapitel6.MenueAufg {
protected void ersterPunkt() { // ¬
Programm.meldung("Einziger Menüpunkt");
}
public void start() {
Programm.meldung("Guten Tag!");
menue(); // ¬
Programm.meldung("Auf Wiederrechnen!");
}
}
Übung 6.4: Lösen Sie die Übung 6.3 auf Seite 124 mit Hilfe der aufgeschobenen Klasse lehrbuch.kapitel6.FreiMenueAufg. Ihre Spezifikation ist – wie immer – in der Datei FreiMenueAufg.spec; hier kann man erkennen, dass sie java.applet.Applet erweitert. Zeigen Sie den Unterschied zwischen den Klassen lehrbuch.kapitel6.FreiMenue und lehrbuch.kapitel6.FreiMenueAufg; beweisen Sie, dass die zweite eine aufgeschobene Klasse ist und die erste nicht.
Seite 127
import lehrbuch.*; // Eimer, VollAusn, LeerAusn // (6.16)
public class ZweiEimerMitMenue4Aufg extends lehrbuch.kapitel6.Menue4Aufg {
Eimer links = new Eimer(), rechts = new Eimer(); // zwei Objekte
// Überschreiben der vier Rückrufprozeduren:
protected void ersterPunkt() { // ¬
try {
links.fuellen(Eimer.WASSER);
} catch (VollAusn ausnahme) { Eimer.meldung("Eimer voll", "Bedienungsfehler"); }
}
protected void zweiterPunkt() { ... // ähnlich für rechts mit wein
protected void dritterPunkt() { // ¬
try {
links.entleeren();
} catch (LeerAusn ausnahme) { Eimer.meldung("Eimer leer", "Bedienungsfehler"); }
}
protected void vierterPunkt() { ... // ähnlich für rechts
public void start() { ... // evtl. Eimer anzeigen
menue(); // Aufruf der Menüprozedur, mit Rückruf der vier Prozeduren ¬
... // evtl. mit dem vom Anwender hinterlassenen Zustand weiterarbeiten
}
}
Seite 128
Seite 128
abstract public class MenueAufg { // (6.17)
abstract public void menuepunkt1(); /* der Methodenname wird dem Menügenerator
eingegeben; die Anzahl der aufgeschobenen Rückrufprozeduren hängt von der
Anzahl der Menüeinträge ab und wird dem Menügenerator angegeben */
public void menue(); // zum Aufrufen
public void start(); // zum Überschreiben; ruft menue auf
}
Übung 6.5: Entwickeln Sie ein menügesteuertes Programm für das Anzeigen von Gedichtzeilen oder Sprüchen. Generieren Sie dafür von Menuegenerator ein Menü mit vier Menüpunkten (außer "Ende"). Erweitern Sie die generierte Klasse durch Ihre eigene. Verbinden Sie dabei die einzelnen Menüpunkte mit Rückrufprozeduren; jede soll nacheinander zweimal die Methode meldung mit jeweils einer Textzeile (zwei Zeilen Ihres Lieblingsgedichts oder zwei Sprüche) aufrufen. Insgesamt programmieren Sie also acht Meldungsfenster, zwei pro Menüpunkt.
Seite 129
import lehrbuch.kapitel6.DirektMenue; // (6.18)
public class DirektmenueDemo extends java.applet.Applet {
... // globale Objekte für die Rückrufprozeduren
protected void ersterPunkt() { ... // ¬
... // alle Rückrufprozeduren
public void start() { ... // Vorbereitungsmaßnahmen
final String[] s = {"Erster Menüpunkt", "ersterPunkt",
"Zweiter Menüpunkt", "zweiterPunkt", ... // usw.
// paarweise Menütext und Rückrufprozedur als Strings in Klammen { }
};
DirektMenue.menue(s, this); // static-Methode der Klasse DirektMenue ¬
// Aufruf des Direktmenüs, Rückruf der Prozeduren durch Menü
... // evtl. mit dem vom Anwender hinterlassenen Zustand weiterarbeiten
final String[] t = {"Neuer Menüpunkt", "neuerPunkt",
"Weiterer Menüpunkt", "weitererPunkt", ... // usw., beliebige Anzahl
};
DirektMenue.menue(t, this); // erneuter Aufruf des Direktmenüs ¬
// Rückruf anderer Prozeduren durch andere Menüpunkte
}
}
Übung 6.6: Lösen Sie die Übung 6.3 auf Seite 124 mit Hilfe des Direktmenüs. Programmieren Sie die Rückrufprozeduren selber, die im FreiMenue schon enthalten waren (die ersten vier Menüpunkte). Fügen Sie dem zweiten Aufruf einen dritten Menüpunkt hinzu, der beide Eimer entleert.
Seite 130
public void getraenkWahl(); // Eimer wird mit dem ausgewählten Getränk gefüllt (auch wenn er zuvor gefüllt war)
import lehrbuch.*; // Eimer // (6.19)
public class EimerMitAuswahlliste extends java.applet.Applet {
public void start() {
Eimer e = new Eimer();
e.getraenkWahl(); // hier wird die Auswahlliste aufgerufen ¬
e.anzeigen(); // das Ergebnis der Auswahl wird angezeigt
}
}
Übung 6.7: Programmieren Sie mit Hilfe der von der Klasse Kreis exportierten Methode
public void farbWahl(); // Kreis wird mit der ausgewählten Farbe gefärbt
ein menügesteuertes Programm mit einem sichtbaren und einem unsichtbaren Kreis. Dieser letztere soll als Speicher dienen. Die Operationen bemalen, verstecken und wiederherstellen aus dem Paket Kreis sollen für den sichtbaren Kreis durch Menüauswahl aufgerufen werden können. Generieren Sie mit Hilfe von Menuegenerator ein Menü, diesmal mit englischen Bezeichnungen (die angehängten Prozeduren sollten Sie trotzdem mit deutschen Namen versehen): "Draw" (Zeichnen), "Paint" (Bemalen), "Hide" (Verstecken) und "Redraw" (Wiederherstellen). Bei der Auswahl von "Paint" soll die gewünschte Farbe über die (von farbWahl angebotene) Auswahlliste vom Anwender eingegeben werden. Darüber hinaus sollen die Menüpunkte "Save" (Speichern) und "Load" (Laden) die Farbe des ersten Kreises in den Zweiten speichern bzw. zurückladen.
Seite 131
public void getraenkEingabe(); /* Eimer wird mit dem eingetippten Getränk gefüllt (auch wenn er zuvor gefüllt war) wenn nicht "Wasser" oder "Wein" eingetippt wird, wird getraenkWahl aufgerufen */
import lehrbuch.*; // (6.20)
public class EimerMitEingabefenster extends java.applet.Applet {
public void start() {
Eimer e = new Eimer();
e.getraenkEingabe(); // ein Wert für Getränke muss eingetippt werden ¬
e.anzeigen(); // das Ergebnis wird angezeigt
}
}
Seite 132
Seite 132
Seite 132
Abb. 6.3: Referenz als Gedächtnis
import lehrbuch.*; // (6.21)
public class AktionNachVorwahl extends kapitel6.MenueVorwahlAufg { // mit 4 Punkten
private final Eimer linkerEimer = new Eimer(), rechterEimer = new Eimer();
private Eimer vorgewaehlterEimer = linkerEimer; // Referenz, vorbesetzt ¬
protected void linksWaehlen() { // linker Eimer wird vorgewählt
vorgewaehlterEimer = linkerEimer; // ¬
}
protected void rechtsWaehlen() { // rechter Eimer wird vorgewählt
vorgewaehlterEimer = rechterEimer;
}
protected void fuellen() { // Aktion für den vorgewählten Eimer
try {
vorgewaehlterEimer.fuellen(); // ¬
} catch ...
}
protected void entleeren() {
try {
vorgewaehlterEimer.entleeren();
} catch ...
}
public void start() { ... // evtl. die zwei Eimer anzeigen, und dann:
menue(); // Aktion nach Vorwahl
}
Übung 6.8: Schreiben Sie ein Programm für drei Kreise nach der Strategie "Aktion nach Vorwahl": Rufen Sie menügesteuert die von Kreis exportierten Operationen bemalen, verstecken und wiederherstellen für den Kreis auf, der vorgewählt wurde. Die Farbe für bemalen lassen Sie über eine Auswahlliste angeben.
Seite 133
Abb. 6.4: Polymorphe Klassen
try {
eimer.fuellen(Eimer.WEIN);
}
catch (VollAusn ausnahme) {
try { // ¬
eimer.entleeren();
eimer.fuellen(Eimer.WEIN);
}
catch (VollAusn a) {}
catch (LeerAusn a) {}
}
Abb. 6.5: Polymorphe Objektwahl
import lehrbuch.*; // (6.22)
interface KreisOderEimer { // ¬
void rot();
void blau();
void weiss();
}
class EimerObjekt implements KreisOderEimer { // ¬
private Eimer eimer;
EimerObjekt() {
eimer = new Eimer();
eimer.anzeigen();
}
public void rot() { // ¬
try { eimer.fuellen(Eimer.WEIN); }
catch (VollAusn a) {
try {
eimer.entleeren();
eimer.fuellen(Eimer.WEIN);
}
catch (VollAusn ausnahme) { System.err.println(ausnahme); } // unerwartet
catch (LeerAusn ausnahme) { System.err.println(ausnahme); }
}
}
public void blau() { ... // ähnlich mit Eimer.WASSER
public void weiss() { ... // ähnlich mit entleeren()
}
class KreisObjekt implements KreisOderEimer { // ¬
private Kreis kreis;
KreisObjekt() {
kreis = new Kreis(); // zwei Attrappen (Dummys)
kreis.zeichnen();
kreis.verstecken();
... // zweiter Kreis ähnlich
kreis = new Kreis(); // dritter (eigentlicher) Kreis erscheint rechts oben
kreis.zeichnen();
}
public void rot() { // ¬
kreis.bemalen(Kreis.ROT);
}
public void blau() { ... ähnlich mit Kreis.BLAU
public void weiss() { ... ähnlich mit verstecken und zeichnen
}
abstract class MenuePolymorph extends java.applet.Applet { // generiert
public void start() { menue(); }
protected void menue() { ... } // Rückrufprozeduren werden aufgerufen
abstract protected void eimerWaehlen();
abstract protected void kreisWaehlen();
abstract protected void rot();
abstract protected void blau();
abstract protected void weiss();
}
public class PolymorpheVorwahl extends MenuePolymorph {
// enthält Applet; start ruft menue auf
private final KreisObjekt kreis = new KreisObjekt();
private final EimerObjekt eimer = new EimerObjekt();
private KreisOderEimer gewaehltesObjekt = eimer; // Vorbesetzungswert
protected void eimerWaehlen() { gewaehltesObjekt = eimer; }
protected void kreisWaehlen() { gewaehltesObjekt = kreis; }
protected void rot() { gewaehltesObjekt.rot(); } // ¬
... // blau() und weiss() ähnlich
}
Seite 137
Seite 137
public class EinKnopf extends java.applet.Applet { // (6.23)
public void init() {
java.awt.Button knopf = new java.awt.Button("OK"); // Text auf dem Knopf ¬
super.add(knopf); // Applet ist Unterklasse von Window, von wo add geerbt wurde
}
}
Seite 137
class Lauscher implements java.awt.event.ActionListener ...
public void actionPerformed(java.awt.event.ActionEvent ereignis);
public void actionPerformed(java.awt.event.ActionEvent ereignis) {
... // Reaktion auf das Ereignis
}
Lauscher lauscher = new Lauscher(); Button knopf = new Button(); knopf.addActionListener(lauscher); // ¬
knopf.addActionListener(
new ActionListener() { // ¬
public void actionPerformed(ActionEvent ereignis) { ... } // ¬
});
import java.awt.Button; // (6.24)
import java.awt.event.*; // ActionListener, ActionEvent
public class KnopfDruecken extends java.applet.Applet {
public void init() {
Button knopf = new Button("Bitte drücken");
knopf.addActionListener(
new ActionListener() {
public void actionPerformed(ActionEvent ereignis) {
getGraphics().drawString("Knopf gedrückt", 20, 20); // ¬
java.awt.Toolkit.getDefaultToolkit().beep(); // ¬
}
}
);
add(knopf);
}
}
Seite 139
import java.awt.Button; // (6.25)
import java.awt.event.*; // ActionListener, ActionEvent
public class ZweiKnoepfe extends java.applet.Applet {
class HalloLauscher implements ActionListener {
public void actionPerformed(ActionEvent ereignis) {
getGraphics().drawString("Hallo", 20, 20);
play(getCodeBase(), "hallo.au");
}
}
class TschuesLauscher implements ActionListener {
public void actionPerformed(ActionEvent ereignis) {
getGraphics().drawString("Tschüs", 20, 50);
}
}
public void init() {
Button ersterKnopf = new Button("Hallo");
Button zweiterKnopf = new Button("Tschüs");
ersterKnopf.addActionListener(new HalloLauscher()); // Registrierung ¬
zweiterKnopf.addActionListener(new TschuesLauscher()); // ¬
add(ersterKnopf);
add(zweiterKnopf);
}
}
Seite 139
import java.awt.*; // Frame, MenuBar, Menu, MenuItem // (6.26)
public class MenueFenster extends Frame {
public MenueFenster() {
// Menüleiste aufbauen:
MenuBar menueLeiste = new java.awt.MenuBar(); // ¬
super.setMenuBar(menueLeiste); // Menüleiste in das Fenster (Frame) einfügen
// Menüspalten in die Menüleiste einbauen:
Menu menue1, menue2; // zwei Einträge in der Menüleiste ¬
menue1 = new Menu("Erste Menüspalte");
menueLeiste.add(menue1);
menue2 = new Menu("Zweite Menüspalte");
menueLeiste.add(menue2);
// Menüpunkte in die Menüspalten einbauen:
MenuItem menuePunkt11, menuePunkt12, menuePunkt2; // drei Menüpunkte ¬
menuePunkt11 = new MenuItem("Menüpunkt 1.1");
menue1.add(menuePunkt11);
menuePunkt12 = new MenuItem("Menüpunkt 1.2");
menue1.add(menuePunkt12);
menuePunkt2 = new MenuItem("Menüpunkt 2");
menue2.add(menuePunkt2);
}
}
public class MenueFensterAnw {
public static void main(String[] args) {
MenueFenster fenster = new MenueFenster();
fenster.setTitle("Menü im Fenster");
fenster.setSize(450, 200);
fenster.setVisible(true);
}
}
Seite 141
menuePunkt11.addActionListener(lauscher11);
public void actionPerformed(java.awt.event.ActionEvent ereignis) {
getGraphics().drawString(ereignis.getActionCommand(), 20, 20); // ¬
}
class FensterLauscher extends java.awt.event.WindowAdapter {
public void windowClosing(java.awt.event.WindowEvent ereignis) { // ¬
System.exit(0);
}
}
addWindowListener(new java.awt.event.WindowAdapter() {
public void windowClosing(java.awt.event.WindowEvent ereignis) { // ¬
System.exit(0);
}
});
public class Fenster extends java.awt.Frame implements java.awt.event.ActionListener {
...
steuerobjekt.addActionListener(this);
...
public class MenueMitReaktion extends java.awt.Frame // (6.27)
implements java.awt.event.ActionListener {
public MenueMitReaktion () {
... // Menue aufbauen wie im Programm (6.26)
// alle Menüpunkte beim Lauscher registrieren lassen
menuePunkt11.addActionListener(this); // aktuelles Fensterobjekt = Lauscher
menuePunkt12.addActionListener(this);
menuePunkt2.addActionListener(this);
// auf "Schließen" reagieren:
addWindowListener(new java.awt.event.WindowAdapter() { // anonyme Klasse ¬
public void windowClosing(java.awt.event.WindowEvent ereignis) {
System.exit(0);
}
});
}
// Methode von ActionListener implementieren:
public void actionPerformed(java.awt.event.ActionEvent ereignis) {
add(new java.awt.Label(ereignis.getActionCommand())); // ¬
}
public static void main(String[] args) { ... // wie oben im Programm (6.26)
Seite 142
public class VerteilteEreignisse extends java.awt.Frame { // (6.28)
public VerteilteEreignisse() {
... // Menue aufbauen wie im Programm (6.26)
this.setLayout(new FlowLayout()); // Platzierung der Knöpfe, s. Kapitel 13.1.2.
Button Knopfs = new Button("Auswahl 1.1");
knopf11.setSize(100, 100);
add(knopf11);
... // weitere Knöpfe und Fensterobjekte
ActionListener lauscher11 = new ActionListener() { // anonyme Klasse
public void actionPerformed(ActionEvent ereignis) {
... // Antwort auf die Menüauswahl
}
};
menuePunkt11.addActionListener(lauscher11); // Menüpunkt registrieren lassen
knopf11.addActionListener(lauscher11); // Knopf für denselben Lauscher
... // weitere Menüpunkte und Fensterobjekte bei Lauschern registrieren lassen
... // weiter wie im Programm (6.26)
|
|
|
|
© APSIS GmbH |