GP-113
8. Model/View-Paradigma für Komponenten

Darstellung

class Mitglied      der Werte
{ String name;
Leisure hobby;
boolean profi;
String notiz;   Änderung

ellipsis
}          der Werte

Model          View

Wechselwirkung:

* Komponenten der Benutzungsoberfläche (view) stellen Inhalte von Datenstrukturen (model)
des Programms dar

* Ziel: Übereinstimmung zwischen Daten und ihrer Darstellung am Bildschirm automatisch
sicherstellen

--------------------------------------------------------------------------------


Vorlesung Grundlagen der Programmierung 2 SS 2005 / Folie 113

Ziele:
Beziehung zwischen Benutzungsoberfläche und Datenstrukturen des Programms kennenlernen

in der Vorlesung:
* Korrespondenz zwischen GUI-Komponenten und Objektvariablen
* Wertänderungen durch den Benutzer und durch das Programm

Verständnisfragen:
* Ist der Typ einer GUI-Komponente aus dem Typ der zugehörigen Objektvariable in der Datenstruktur direkt
ersichtlich? Nennen Sie Beispiele für sinnvolle Alternativen für das gezeigte Beispiel.

--------------------------------------------------------------------------------


GP-114
Zusammenarbeit von Model, View und Programm

ChangeListener

dataChanged
ellipsis
void dataChanged(ellipsis ) {ellipsis }      installiert    View

ellipsis

Reaktion
meldet Änderungen          Swing-Komponente
Model

meldet
Datenstruktur          fragt Inhalte ab          Benutzeraktionen

ellipsis
ändert Inhalte
installiert          void actionPerformed(ellipsis ) {ellipsis }
ellipsis

Programm        Reaktion          ActionListener
actionPerformed
Controller

* Anwendung des "Observerquotedblright -Prinzips (wie bei der Ereignisbehandlung):
eine (oder mehrere) Komponenten beobachten die Datenstruktur

* Datenstruktur ruft bei jeder Änderung zugehörige Methode in jedem Beobachter-Objekt auf

--------------------------------------------------------------------------------

Vorlesung Grundlagen der Programmierung 2 SS 2005 / Folie 114

Ziele:
Überblick über den Verbund der drei kooperierenden Bestandteile bekommen

in der Vorlesung:
* Rolle und Aufgaben der drei Bestandteile erklären
* Zusammenhang mit dem MVC-Paradigma (Model-View-Controller)
* erneute Anwendung des Observer-Prinzips untersuchen

Verständnisfragen:
* Welche Rolle spielt die Swing-Komponente in den beiden Anwendungen des Observer-Prinzips?

--------------------------------------------------------------------------------


GP-115
Schematischer Aufbau von Model und View

class Model          class View extends JComponent
{ // Datenstruktur mit Zugriffsmethoden    {  private Model model;
private String data;          View (Model m)

String getData ()          { model = m;
{ return data; }          model.addChangeListener(

void String setData (String s)          new RedrawListener());
{ data = s;          }

fireChangeEvent();          ellipsis
}          class RedrawListener

// Verwaltung der Listener          implements ChangeListener
ChangeListener[] listener;         { public void dataChanged()
int count = 0;          { String s =

void addChangeListener          model.getData();

(ChangeListener cl)          ellipsis
{ listener[count++] = cl; }          repaint();
}
void fireChangeEvent ()          }
{ for (int i=0; i<count; i++)   }

listener[i].dataChanged();
}          interface ChangeListener
}          { public void dataChanged(); }

--------------------------------------------------------------------------------


Vorlesung Grundlagen der Programmierung 2 SS 2005 / Folie 115

Ziele:
Einblick in die Realisierung von Model- bzw. View-Klassen gewinnen

in der Vorlesung:
* Verwaltung von Listener-Objekten in der Model-Klasse
* Registrierung eines Listener-Objekts in der View-Klasse
* resultierende Objektstruktur
* Interface ChangeListener als Bindeglied

Verständnisfragen:
* Für welche Swing-Komponenten wäre die gezeigte Model-Klasse geeignet?
* Was wären die zentralen Objektvariablen in Model-Klassen für die anderen Swing-Komponenten auf  Folie 87?

--------------------------------------------------------------------------------

GP-116
Beispiel: Haushaltsbuch

Aufgabe: Programm zur Überwachung von Ausgaben im Haushalt entwerfen

Eigenschaften:

* speichert Geldbetrag
(Summe der Ausgaben)
für jede Kategorie

* Eingabe von Einzelbuchungen (+/endash )
und Löschen ganzer Kategorien

* Liste aller Kategorien mit Beträgen
wird angezeigt

Entwicklungsschritte:
* Datenstruktur entwerfen
* Datenstruktur zum Datenmodell (Model) für eine Liste (JList) erweitern
* Komponenten strukturieren
* Komponenten generieren und anordnen

* Ereignisbehandlung entwerfen und implementieren

--------------------------------------------------------------------------------


Vorlesung Grundlagen der Programmierung 2 SS 2005 / Folie 116

Ziele:
Gewünschte Funktionalität des Haushaltsbuch-Programms kennenlernen

in der Vorlesung:
* Benutzung und zentrale Konzepte des Programms (aus Anwendersicht) erläutern.
* Entwicklung in mehreren, überschaubaren Schritten planen.

--------------------------------------------------------------------------------


GP-117
Datenstruktur für Haushaltsbuch

Speicherung der Kategorien und Beträge in zwei parallel belegten Arrays;
zentrale Operation "Buchung vornehmenquotedblright und Abfragemethoden:

class ChequeBook
{ private String[] purposes = new String[20];  // Namen der Kategorien
private int[] amounts = new int[20];          // Geldbeträge dazu
private int entries = 0;          // Anzahl Einträge

void addTransaction (String p, int a)
{ if (p.length() == 0 || a == 0) return;    // keine sinnvolle Buchung
for (int i = 0; i < entries; i++)
{ if (purposes[i].equals(p))          // Kategorie bereits vorhanden

{ amounts[i] += a; return; }          // Geldbetrag anpassen
}
int index = entries; entries += 1;        // neue Kategorie anfügen
purposes[index] = p; amounts[index] = a;
}

int getEntries ()          // Abfragemethoden: Anzahl Einträge
{ return entries; }

int getAmount (int index)          // Geldbetrag eines Eintrags
{ return amounts[index]; }

String getPurpose (int index)          // Kategoriename eines Eintrags
{ return purposes[index]; }
}

--------------------------------------------------------------------------------


Vorlesung Grundlagen der Programmierung 2 SS 2005 / Folie 117

Ziele:
Entwicklung einer geeigneten Datenstruktur

in der Vorlesung:
* Bedeutung der Objektvariablen erklären
* Realisierung der Änderungsoperation erläutern

Übungsaufgaben:
Erweitern Sie die Klasse um eine Operation zum Löschen einer Kategorie.

Verständnisfragen:
* Welche Invarianten gelten für diese Datenstruktur?
* Beschreiben Sie alternative Implementierungen der Datenstruktur.

--------------------------------------------------------------------------------


GP-117a
Model für JList-Komponenten

Das Interface ListModel im Package javax.swing beschreibt die Anforderungen an das
Datenmodell für eine graphisch dargestellte Liste (JList-Objekt):

public interface ListModel
{ // Verwaltung von Swing-Komponenten, die das Model beobachten:
void addListDataListener (ListDataListener ldl);
void removeListDataListener (ListDataListener ldl);
int getSize ();          // Abfrage der Daten durch das JList-Objekt
Object getElementAt (int index);          // Abfrage eines Eintrags
}

Die abstrakte Klasse AbstractListModel implementiert das An- und Abmelden von
ListDataListener-Objekten und ergänzt Methoden, um diese zu benachrichtigen:

public abstract class AbstractListModel implements ListModel
{ public void addListDataListener (ListDataListener ldl) { ellipsis }
public void removeListDataListener (ListDataListener ldl) { ellipsis }
protected void fireContentsChanged (Object src, int from, int to)
{ ellipsis }          // ruft Methode contentsChanged() in allen Listenern auf
protected void fireIntervalAdded (ellipsis ) { ellipsis }
protected void fireIntervalRemoved (ellipsis ) { ellipsis }
}

Die fireXXX-Methoden korrespondieren mit den Methoden im Interface ListDataListener:
contentsChanged(ListDataEvent e), intervalAdded(ellipsis ), intervalRemoved(ellipsis ).

--------------------------------------------------------------------------------

Vorlesung Grundlagen der Programmierung 2 SS 2005 / Folie 117a

Ziele:
Zusammenhang zwischen Interface und abstrakter Oberklasse für ein JList-Model verstehen.

in der Vorlesung:
* Verwaltungs- und Abfrageoperationen im Interface
* Implementierung der Verwaltungsoperationen in der abstrakten Klasse
* Zusammenhang zwischen den fireXXX-Methoden und den Methoden in den ListDataListener-Objekten

Verständnisfragen:
* Warum gibt es mehrere (drei) verschiedene Arten von Benachrichtigungen in einem JList-Model?

--------------------------------------------------------------------------------


GP-117b
Model für Haushaltsbuch

Erweitern die Datenstruktur zum Datenmodell für eine Liste:
* Abfragemethoden für JList-Objekt hinzufügen.

* Benachrichtigung der Listener in den Operationen ergänzen, die die Datenstruktur verändern.

class ChequeBook extends AbstractListModel          // neue Oberklasse
{ private ellipsis ;          // Objektvariablen bleiben unverändert

public int getSize ()
{ return entries; }

public Object getElementAt (int index)
{ return purposes[index] + ": " + String.valueOf(amounts[index]); }

void addTransaction (String p, int a)
{ if (p.length() == 0 || a == 0) return;    // keine sinnvolle Buchung
for (int i = 0; i < entries; i++)
{ if (purposes[i].equals(p))          // Kategorie bereits vorhanden
{ amounts[i] += a;          // Geldbetrag anpassen
fireContentsChanged(this, i, i);     // Beobachter informieren
return;
}
}
int index = entries; entries += 1;        // neue Kategorie anfügen
purposes[index] = p; amounts[index] = a;
fireIntervalAdded(this, index, index);    // Beobachter informieren
} ellipsis }          // restliche Abfragemethoden bleiben unverändert

--------------------------------------------------------------------------------

Vorlesung Grundlagen der Programmierung 2 SS 2005 / Folie 117b

Ziele:
Unterschiede zwischen der reinen Datenstruktur und einer Model-Klasse erkennen.

in der Vorlesung:
* Beiträge der abstrakten Oberklasse zusammenfassen.
* Zusammenhang zwischen neuen Abfragemethoden und resultierender Darstellung erläutern.
* Regeln zum Einfügen von Benachrichtigungsoperationen.

nachlesen:
erste Version der Datenstruktur auf  Folie 117

Übungsaufgaben:
Fügen Sie die notwendigen Benachrichtigungsoperationen in die zusätzliche Operation zum Löschen einer Kategorie ein.

Verständnisfragen:
* Warum ist der Zeitpunkt zu dem die Benachrichtigung der Listener-Objekte erfolgt kritisch?

--------------------------------------------------------------------------------


GP-118
Objektbaum zum Haushaltsbuch
JFrame
MoneyTracker
ContentPane   JScrollPane

Border          JList
list
JPanel
entryArea
Grid

purpurposeEntrposeEntryy JPanel

Flow          JLabel

JTextField
purposeField

amountEntry JPanel        JLabel

Flow          JTextField

amountField

JButton
bookButton          ActionListener

deleteButton          ActionListener

--------------------------------------------------------------------------------

Vorlesung Grundlagen der Programmierung 2 SS 2005 / Folie 118

Ziele:
Struktur der Oberfläche entwerfen

in der Vorlesung:
* Elemente der Oberfläche erläutern.
* Strukturentscheidungen begründen.

--------------------------------------------------------------------------------


GP-119
Programm zum Haushaltsbuch

class MoneyTracker extends JFrame
{ private ChequeBook listData; private JList list;
private JTextField purposeField, amountField;

MoneyTracker (String title, ChequeBook data)
{ super(title); listData = data;
list = new JList(listData);       // Liste erzeugen und mit Model verbinden
list.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);

JPanel purposeEntry = new JPanel(new FlowLayout(ellipsis ));
purposeEntry.add(new JLabel("Zweck"));
purposeField = new JTextField(30);
purposeEntry.add(purposeField);
JPanel amountEntry = new JPanel(ellipsis ); ellipsis         // Komponenten einfügen
JPanel entryArea = new JPanel(new GridLayout(2, 1));
entryArea.add(purposeEntry); entryArea.add(amountEntry);
Container content = getContentPane();
content.setLayout(new BorderLayout());
content.add(new JScrollPane(list), BorderLayout.CENTER);
content.add(entryArea, BorderLayout.SOUTH);
ellipsis setVisible(true);          // Eigenschaften des Fensters einstellen
}

public static void main (String[] args)
{ ChequeBook myMoney = new ChequeBook();
JFrame f = new MoneyTrackerB("Wherequotesingle s my money?", myMoney);

} }

--------------------------------------------------------------------------------


Vorlesung Grundlagen der Programmierung 2 SS 2005 / Folie 119

Ziele:
Objektbaum konstruieren

in der Vorlesung:
* Regeln für die Wahl von lokaler Variable oder Objektvariable für GUI-Komponenten anwenden.
* Beziehung zwischen Fenster-Objekt und Model untersuchen.

nachlesen:
Plan für den Objektbaum auf  Folie 118

Verständnisfragen:
* Wiekönnte dasProgramm so erweitert werden, dass mehrere Haushaltsbuch-Fenster angezeigt werden? Welche zwei
Varianten sind denkbar?

--------------------------------------------------------------------------------


GP-120

Implementierung der Ereignisbehandlung

Methoden aufrufen, die Änderungen am Datenmodell vornehmen:

class MoneyTracker extends JFrame
{ private ChequeBook listData; private JList list;
private JTextField purposeField, amountField;

MoneyTracker (String title, ChequeBook data)
{ super(title); listData = data;
list = new JList(listData);       // Liste erzeugen und mit Model verbinden
ellipsis
JPanel amountEntry = new JPanel(ellipsis ); ellipsis         // Komponenten einfügen
JButton bookButton = new JButton("Verbuchen");
amountEntry.add(bookButton); ellipsis
bookButton.addActionListener(new ActionListener()
{ public void actionPerformed (ActionEvent e)    // Reaktion auf Klick
{ String purpose = purposeField.getText();      // Werte auslesen
String amount = amountField.getText();
int money;
try
{ money = Integer.parseInt(amount); } // Geldbetrag in Zahl wandeln
catch (NumberFormatException nfe)
{ money = 0; }          // keine Zahl: 0 annehmen
listData.addTransaction(purpose, money);     // Modell verändern
}
});
ellipsis setVisible(true);          // Rest des Fensters aufbauen
} ellipsis }

--------------------------------------------------------------------------------


Vorlesung Grundlagen der Programmierung 2 SS 2005 / Folie 120

Ziele:
Schema für den Aufruf von Model-Operationen in Listener-Objekten

in der Vorlesung:
* Anonyme innere Klasse zur Ereignisbehandlung
* Konvertierung der Benutzereingaben
* Beziehung zwischen Listener-Objekt, Fenster-Objekt und Model untersuchen.

nachlesen:
Aufbau des Objektbaums auf  Folie 119

Übungsaufgaben:
* Vervollständigen und erproben Sie das Programm.
* Ergänzen Sie die fehlende Ereignisbehandlung für den "Löschen"-Knopf.

Verständnisfragen:
* Welche anderen Reaktionen auf Fehleingaben des Benutzers wären denkbar bzw. sinnvoll?

--------------------------------------------------------------------------------


GP-121

Anpassung der Darstellung durch Renderer-Objekte

class MoneyTracker extends JFrame
{ ellipsis
MoneyTracker (String title, ChequeBook data, ListCellRenderer render)
{ super(title); listData = data;
list = new JList(listData);       // Liste erzeugen und mit Model verbinden
list.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
list.setCellRenderer(render); ellipsis  // eigenes Renderer-Objekt anschliessen
}

public static void main (String[] args)
{ ChequeBook myMoney = new ChequeBook();
JFrame f = new MoneyTracker("Wherequotesingle s my money?", myMoney,
new BalanceRenderer(myMoney)); }
}

class BalanceRenderer implements ListCellRenderer
{ private ChequeBook entries;
BalanceRenderer (ChequeBook data) { entries = data; }
public Component getListCellRendererComponent (JList list, Object value,

int index, boolean isSelected, boolean cellHasFocus)
{ JLabel lab = new JLabel("** " + value.toString());
if (isSelected) { ellipsis } else { ellipsis }
int amount = entries.getAmount(index);
if (amount < 0) lab.setForeground(Color.green);
else if (amount > 500) lab.setForeground(Color.red);
ellipsis lab.setOpaque(true); return lab;
} }

--------------------------------------------------------------------------------


Vorlesung Grundlagen der Programmierung 2 SS 2005 / Folie 121

Ziele:
Flexibilität durch Auslagerung von Methoden in separate Hilfsobjekte

in der Vorlesung:
* anpassbare Darstellung von Listeneinträgen durch Austauschbare Renderer-Objekte
* resultierende Objektstruktur
* Bedeutung des Interface ListCellRenderer und der Operation getListCellRendererComponent()

nachlesen:
bisherige Version des Haushaltsbuch-Programms auf  Folie 119

Übungsaufgaben:
Erweitern Sie das Programm so, dass zwei Fenster auf dasselbe Model-Objekt, jedoch mit unterschiedlicher Darstellung
der Liste geöffnet werden.

Verständnisfragen:
* Wie viele JLabel-Objekte erzeugt das Renderer-Objekt in der gezeigten Form?
* Wie und wie weit kann man die Anzahl erzeugter Objekte verringern? Ist das bedenkenlos möglich?

--------------------------------------------------------------------------------


GP-124
9. Applets

Applet (small application):
* kleines Anwendungsprogramm in Java für eine spezielle Aufgabe,

* an eine WWW-Seite (world wide web) gekoppelt;

* das Applet wird mit der WWW-Seite über das Internet übertragen;

* der Internet Browser (Werkzeug zum Navigieren und Anzeigen von Informationen) arbeitet
mit einer Java Virtual Machine (JVM) zusammen; sie führt eintreffende Applets aus.

Internet          M

Duke.class  Duke.html          Browser
JVM

Programm (Java-Applet) wird übertragen, läuft beim Empfänger, bewirkt dort Effekte.
Applets benutzen JVM und Java-Bibliotheken des Empfängers.

(c) 2005 bei Prof. Dr. Uwe Kastens

--------------------------------------------------------------------------------


Vorlesung Grundlagen der Programmierung 2 SS 2005 / Folie 124

Ziele:
Prinzip der Applets im Internet

in der Vorlesung:
* Begriffe erläutern
* Applet vorführen Catch the Duke
* Applet vorführen Traffic Lights

nachlesen:
Judy Bishop: Java lernen, 2.Aufl., Abschnitt 12.1

Übungsaufgaben:

Verständnisfragen:
* Welche Vorteile hat es, ein Programm beim Empfänger statt beim Sender auszuführen?
* Welche Nachteile?

--------------------------------------------------------------------------------


GP-125
Programmierung von Applets

Applets werden wie Programme mit Swing-Benutzungsoberfläche geschrieben, aber:
* Die Hauptklasse ist Unterklasse von JApplet statt von JFrame.
* Es gibt die Methode main nicht.
* System.exit darf nicht aufgerufen werden.

* Die Methode public void init () tritt an die Stelle des Konstruktors.

* Ein- und Ausgabe mit Swing-Komponenten statt mit Dateien.

Programmschema: Fenster mit Zeichenfläche (GP-88):

class WarningApplet extends JApplet
{ ...
public void paint (Graphics g)
{ ... auf g schreiben und zeichnen ...}
}

Programmschema: Bedienung mit Swing-Komponenten (GP-103):

class TrafficLight extends JApplet
{ public void init ()
{ ... Objektbaum mit Swing-Komponenten aufbauen ... }
...
}

(c) 2005 bei Prof. Dr. Uwe Kastens

--------------------------------------------------------------------------------


Vorlesung Grundlagen der Programmierung 2 SS 2005 / Folie 125

Ziele:
Programmstruktur von Applets kennenlernen

in der Vorlesung:
Begründung der Strukturen

nachlesen:
Judy Bishop: Java lernen, 2.Aufl., Abschnitt 12.1

Übungsaufgaben:

Verständnisfragen:
Warum ist Datei-E/A für Applets nicht sinnvoll?

--------------------------------------------------------------------------------


GP-126
Applet-Methoden

Die Klasse JApplet liegt in der Hierarchie der graphischen Komponenten:

java.awt.Component
java.awt.Container
java.awt.Panel
java.awt.Applet
javax.swing.JApplet

JApplet definiert Methoden ohne Effekt zum Überschreiben in Unterklassen:

wird aufgerufen, wenn das Applet ...
void init ()       geladen wird
void start ()      seine Ausführung (wieder-)beginnen soll
void stop ()       seine Ausführung unterbrechen soll
void destroy ()    das Applet beendet wird

Methoden zum Aufruf in Unterklassen von JApplet, z. B.

void showStatus (String)    Text in der Statuszeile des Browsers anzeigen
String getParameter (String) Wert aus HTML-Seite lesen
Weitere Methoden aus Oberklassen, z. B

void paint (Graphics g)        auf g schreiben und zeichnen (aus Container)

(c) 2005 bei Prof. Dr. Uwe Kastens

--------------------------------------------------------------------------------


Vorlesung Grundlagen der Programmierung 2 SS 2005 / Folie 126

Ziele:
Wichtige Methoden für die Applet-Programmierung kennenlernen

in der Vorlesung:
* JApplet in die Hierarchie einordnen
* Methoden erläutern

nachlesen:
Judy Bishop: Java lernen, 2.Aufl., Abschnitt 12.1

Übungsaufgaben:

Verständnisfragen:
In welcher Verwandtschaftsbeziehung steht JApplet zu Window, Frame, JFrame und zu Applet?

--------------------------------------------------------------------------------


GP-127
Applets zu HTML-Seiten

HTML (Hypertext Markup Language):
* Sprache zur Beschreibung formatierter, strukturierter Texte und deren Gestaltung

* Standardsprache zur Beschreibung von Internet-Seiten

* Einfache Sprachstruktur: Marken <hr> und Klammern <ul> ellipsis </ul>, <li> ellipsis </li> mit
bestimmter Bedeutung, z. B.

Wir unterscheiden          Wir unterscheiden
<ul>          * diesen Fall,
<li>diesen Fall,</li>
<li>jenen Fall</li>         * jenen Fall
</ul>
und viele andere Fälle.         und viele andere Fälle.
<hr>

Ein Applet wird auf einer HTML-Seite aufgerufen, z. B.

<title>Catch the Duke!</title>
<hr>
<applet code="CatchM.class" width="300" height="300">
</applet>

Beim Anzeigen der HTML-Seite im Browser oder Appletviewer wird das Applet auf einer Fläche
der angegebenen Größe ausgeführt.

(c) 2005 bei Prof. Dr. Uwe Kastens

--------------------------------------------------------------------------------


Vorlesung Grundlagen der Programmierung 2 SS 2005 / Folie 127

Ziele:
HTML-Seite für Applets verstehen

in der Vorlesung:
* HTML-Sprache kurz erläutern
* HTML-Text zeigen
* Unterschied zu WYSIWIG-Textsystemen (What-you-see-is-what-you-get)

nachlesen:
Judy Bishop: Java lernen, 2.Aufl., Abschnitt 12.1

Übungsaufgaben:

Verständnisfragen:
Finden Sie mindestens 5 verschieden HTML-Klammern und geben Sie deren Bedeutung an.

--------------------------------------------------------------------------------


GP-128
Java-Programm in Applet umsetzen

Ein Java-Programm kann man in folgenden Schritten in ein Applet transformieren:

1. Alle Datei-E/A in Benutzung von Swing-Komponenten umsetzen, z. B.
System.out.println(ellipsis ) in g.drawString(ellipsis ) in der Methode paint.

2. Programm nicht anhalten, System.exit-Aufrufe und close-Button bzw. Aufrufe von
setDefaultCloseOperation entfernen.

3. Layoutmanager ggf. explizit wählen, Vorgabe ist BorderLayout (wie bei JFrame).

4. javax.swing.JApplet importieren,
Hauptklasse als Unterklasse von JApplet definieren

5. Konstruktor durch init-Methode ersetzen; darin wird der Objektbaum der Komponenten
aufgebaut.

6. main-Methode entfernen;
die Hauptklasse des Java-Programms entfällt einfach, wenn sie nur die main-Methode
enthält und darin nur das JFrame-Objekt erzeugt und platziert wird.
7. HTML-Datei herstellen mit <applet>-Element zur Einbindung der .class-Datei.
8. Testen des Applets; erst mit dem appletviewer dann mit dem Browser.

siehe Beispiel Ampel-Simulation GP-104 bis 108.

(c) 2005 bei Prof. Dr. Uwe Kastens

--------------------------------------------------------------------------------


Vorlesung Grundlagen der Programmierung 2 SS 2005 / Folie 128

Ziele:
Einfache Umsetzungsregeln lernen

in der Vorlesung:
Erläuterungen dazu am Beispiel

nachlesen:
Judy Bishop: Java lernen, 2.Aufl., Abschnitt 12.1

Übungsaufgaben:
Wandeln Sie das Java-Programm zur Ampel-Simulation in ein Applet um. Welche der Schritte sind nötig?

Verständnisfragen:
Wie muss die Hauptklasse eines Java-Programms beschaffen sein, damit sie für das Applet einfach entfallen kann?

--------------------------------------------------------------------------------

GP-129
Parameter zum Start des Applet

Dem Applet können zum Aufruf von der HTML-Seite Daten mitgegeben werden.

Notation: Paare von Zeichenreihen für Parametername und Parameterwert

<param name="Parametername" value="Parameterwert">

eingesetzt im Applet-Aufruf:

<applet code="CoffeeShop.class" width="600" height="200">
<param name="Columbian" value="12">
<param name="Java" value="15">
<param name="Kenyan" value="9">
</applet>
Im Applet auf die Parameterwerte zugreifen:

preis = Integer.parseInt (getParameter ("Java"));

(c) 2005 bei Prof. Dr. Uwe Kastens

--------------------------------------------------------------------------------


Vorlesung Grundlagen der Programmierung 2 SS 2005 / Folie 129

Ziele:
Technik der Applet-Parameter kennenlernen

in der Vorlesung:
Erläuterungen dazu

nachlesen:
Judy Bishop: Java lernen, 2.Aufl., Abschnitt 12.2

Übungsaufgaben:

Verständnisfragen:
Unter welchen Umständen sind solche Parameter sinnvoller als Programmkonstante?

--------------------------------------------------------------------------------


GP-130
Sicherheit und Applets

Beim Internet-Surfen kann man nicht verhindern, dass fremde Applets auf dem eigenen
Rechner ausgeführt werden. Deshalb sind ihre Rechte i. a. stark eingeschränkt:

Operation          Java      Applet im      lokales Applet fremdes Applet
Programm appletviewer im Browser   im Browser

lokale Datei zugreifen          X        X
lokale Datei löschen          X
anderes Programm starten         X        X
Benutzernamen ermitteln          X        X          X
zum Sender des Applet verbinden  X        X          X          X
zu anderem Rechner verbinden     X        X          X
Java-Bibliothek laden          X       X          X
System.exit aufrufen          X       X
Pop-up Fenster erzeugen          X        X          X          X

Diese Einstellungen der Rechte können im Browser geändert werden.

Man kann auch signierten Applets bestimmter Autoren weitergehende Rechte geben.

Außerdem wird der Bytecode jeder Klasse auf Konsistenz geprüft, wenn er in die JVM
geladen wird.

(c) 2005 bei Prof. Dr. Uwe Kastens

--------------------------------------------------------------------------------


Vorlesung Grundlagen der Programmierung 2 SS 2005 / Folie 130

Ziele:
Rechte der Applets im Vergleich

in der Vorlesung:
* Erläuterungen und Begründungen dazu
* Java Web Start als Alternative für"automatische" Programminstallation

nachlesen:
Judy Bishop: Java lernen, 2.Aufl., Abschnitt 12.2

Übungsaufgaben:

Verständnisfragen:
Warum ist es einem Applet nicht erlaubt, lokale Dateien zu lesen?

--------------------------------------------------------------------------------


GP-130a
Applets als Beispiel für Erweiterungsmodule (plug-ins)

Erweiterungsmodule (plug-ins) sind keine selbständigen Programme, sondern werden in ein
anderes Programm (host program) eingebettet, um dessen Funktionalität zu erweitern.

Zusammenarbeit zwischen Erweiterungsmodul und Programm basiert (in der Regel) auf:
* fest vorgegebener (abstrakter) Oberklasse für das Erweiterungsmodul

* Methoden, die das Modul unbedingt anbieten muss (Eintrittspunkte)

* Methoden, die das Programm speziell für solche Module bereitstellt (call backs, services)

* sonstigen Methoden des Programms, die auch zur Verwendung in Erweiterungsmodulen
geeignet sind
Oberklasse

Erweiterungs-Erweiterungs-         Eintrittspunkte       Programm
modulmodul
plug-inplug-in          call backs        host program

sonstige Methoden

(c) 2005 bei Prof. Dr. Uwe Kastens

--------------------------------------------------------------------------------


Vorlesung Grundlagen der Programmierung 2 SS 2005 / Folie 130a

Ziele:
Schnittstelle zwischen Erweiterungmodul und Programm kennenlernen

in der Vorlesung:
* Erläuterung der unterschiedlichen Bestandteile der Schnittstelle
* Applets als Erweiterungsmodule des Web-Browsers
* Erweiterungsmodule für die Java-Bildverarbeitung ImageJ

nachlesen:
Judy Bishop: Java lernen, 2.Aufl., Abschnitt 12.2

Übungsaufgaben:

Verständnisfragen:
Woraus besteht die Schnittstelle, wenn man ein gewöhnliches Java-Programm als Erweiterungsmodul der Java-
Laufzeitumgebung (bzw. des Betriebssystems) auffasst?

--------------------------------------------------------------------------------