Praktische Informatik 1 Prof. Dr. H. Schlingloff 28. 1. 2008

8.3 Applets, Internetprogrammierung Applets sind Java-Programme, die aus HTML-Seiten aufgerufen werden können Virtuelle Java-Maschine als Browser-Plugin Grund für den Erfolg von Java, neue Technologie der „Web Services“ Aus Sicherheitsgründen eingeschränkte Rechte (z.B. Cookies statt Dateizugriff)

Vorgehensweise Erstellung in Eclipse Einbindung in Webseite: <applet code="AppletDemo.HalloWelt.class„ width=320 height=240></applet> package AppletDemo; import java.awt.*; import java.applet.*; public class HalloWelt extends Applet { public void paint (Graphics g) { g.drawString("Hallo Welt!", 30, 20); } } package AppletDemo; import java.awt.*; import java.applet.*; public class HalloWelt extends Applet { public void paint (Graphics g) { g.drawString("Hallo Welt!", 30, 20); } }

Tips&Tricks .class-Datei muss in mit Paketnamen benannten Unterverzeichnis des Verzeichnisses der .html-Datei liegen Parameterübergabe aus HTML: Webseite ...</applet><param name="farbe" value = "grün"> public void paint (Graphics g) { String col = getParameter("farbe"); if (col==null) setBackground(Color.lightGray); else if(col.equals("blau")) setBackground(Color.blue); g.drawString(col+"e Welt!", 60, 80); } package AppletDemo; import java.awt.*; import java.applet.*; public class HalloWelt extends java.applet.Applet { public void paint (Graphics g) { String col = getParameter("farbe"); if (col==null) setBackground(Color.lightGray); else if(col.equals("blau")) setBackground(Color.blue); else if(col.equals("grün")) setBackground(Color.green); g.drawString(col+"e Welt!", 60, 80); showStatus("Applet läuft"); }

Kapitel 9: Algorithmen und Datenstrukturen 9.1 Listen, Bäume, Graphen 9.2 Suchen und Sortieren 9.3 Graphalgorithmen

Alg&DS… … wurden klassischerweise als „das“ Thema der praktischen Informatik betrachtet … Bedeutung rückläufig wegen umfangreicher Bibliotheken … Forschungsfragen und Überraschungseffekte … Kenntnis der Funktionsweise für Informatiker unerläßlich

9.1 Listen, Bäume, Graphen rekursive Datentypen jedes Objekt gehört zu einer bestimmten Klasse Beispiel: int i; Thread f; PKW herbie; Objekte können andere Objekte als Bestandteile enthalten Beispiel: Auto enthält Tachostand kann ein Objekt andere Objekte der selben Klasse enthalten?

rekursive Datenstrukturen Rekursion in Delphi mit Zeigern aufgelöst In Java gibt es keine Zeiger (-typen), aber es gibt Objekte Es ist erlaubt, dass ein Objekt eine Komponente vom selben Typ enthält wie das Objekt selbst Rekursionsende: null

verkettete Listen Listen sind endliche Folgen von Elementen Beispiel für dynamische Datenstruktur: Im Unterschied zu Arrays können Listen beliebig wachsen und schrumpfen neue Elemente werden an die Liste angehängt nicht mehr benötigte Elemente können entfernt werden Verkettete Listen kann man sich wie eine Perlenschnur vorstellen von jeder Perle gibt es eine Verbindung zur folgenden in den Perlen befindet sich die Information Die Liste besteht aus Zellen: jede Zelle hat einen Inhalt, und einen Verweis auf die folgende Zelle

Listen als Perlenschnur

Drucken einer Liste class Zelle{ int inhalt; Zelle next; public String toString(){ return inhalt+((next==null)?"": " -> " + next.toString()); } } class Liste{ ... public String toString(){return anfang.toString();} public class ListenAnwendung { static Liste l = new Liste(); public static void main(String[] args) { l.insert(101); l.insert(38); l.insert(42); System.out.println(l); } package Listen; class Zelle{ int inhalt; Zelle next; Zelle(int inh, Zelle nxt){ inhalt = inh; next = nxt; } public String toString() { return inhalt+((next==null)?"": " -> " + next.toString()); class Liste{ Zelle anfang; void insert(int n) { Zelle z = new Zelle(n, anfang); anfang = z; return anfang.toString(); public class ListenAnwendung { static Liste l = new Liste(); public static void main(String[] args) { l.insert(101); System.out.println(l); l.insert(38); System.out.println(l); l.insert(42); System.out.println(l); l.insert(17); System.out.println(l);

Entfernen des ersten Elementes Um das erste Element zu löschen, setzen wir den Anfang einfach auf das zweite Element: Der vorherige Anfang ist damit nicht mehr zugreifbar! Natürlich darf das nur ausgeführt werden, falls die Liste nicht leer ist anfang inhalt next inhalt next inhalt next 333 222 101 anfang = anfang.next

Entfernen eines inneren Elementes Um ein inneres Element zu löschen, verbinden wir die Vorgängerzelle mit der Nachfolgerzelle: Die Liste wird dadurch verändert! Das abgeklemmte Element wird irgendwann von der Speicherbereinigung entdeckt, der Platz wiederverwendet

Entfernen des n-ten Elementes

void removeNth(int n) { if(anfang !=null) { Zelle v = anfang; void removeFirst() { anfang = anfang.next; } void removeNth(int n) { if(anfang !=null) { Zelle v = anfang; while (v.next!=null && n>1) { v = v.next; n--;} if(v.next!=null) v.next = v.next.next; } Achtung: removeFirst() ist nicht das selbe wie removeNth(1)

weitere Listenoperationen int länge(){ int i = 0; Zelle z = anfang; while (z!=null) { i++; z=z.next; } return i; } boolean enthält(int n) { boolean gefunden = false; Zelle z = anfang; while (z!=null && !gefunden) { if (z.inhalt==n) gefunden=true; z=z.next; } return gefunden; } package Listen; class Zelle{ int inhalt; Zelle next; Zelle(int inh, Zelle nxt){ inhalt = inh; next = nxt; } public String toString() { return inhalt+((next==null)?"": " -> " + next.toString()); class Liste{ Zelle anfang; void insert(int n) { Zelle z = new Zelle(n, anfang); anfang = z; return anfang.toString(); void removeFirst() { anfang = anfang.next; void removeNth(int n) { if(anfang !=null) { Zelle v = anfang; while (v.next!=null && n>1) { v = v.next; n--;} if(v.next!=null) v.next = v.next.next; int länge(){ int i = 0; Zelle z = anfang; while (z!=null) { i++; z=z.next; } return i; boolean enthält(int n) { boolean gefunden = false; Zelle z = anfang; while (z!=null && !gefunden) { if (z.inhalt==n) gefunden=true; z=z.next; } return gefunden; Zelle suche(int n){ while (z!=null) { if (z.inhalt==n) return z; return z; public class ListenAnwendung { static Liste l = new Liste(); public static void main(String[] args) { l.insert(101); System.out.println(l); l.insert(38); System.out.println(l); l.insert(42); System.out.println(l); l.insert(17); System.out.println(l); l.removeFirst(); System.out.println(l); l.insert(99); System.out.println(l); l.removeNth(2); System.out.println(l); System.out.println(l.länge()); System.out.println(l.enthält(42)); System.out.println(l.suche(42)); System.out.println(l.suche(333)); Zelle suche(int n){ Zelle z = anfang; while (z!=null) { if (z.inhalt==n) return z; z=z.next; } return z; }

Realisierung von Kellern mit Listen class Stapel extends Liste { Stapel() {} Stapel(Zelle z) { anfang = z; } boolean isEmpty(){ return anfang==null; } Stapel push(int i) { Zelle z = new Zelle(i, anfang); return new Stapel(z);} Stapel pop() { return new Stapel(anfang.next); } int top() { return anfang.inhalt; } } package Listen; class Stapel extends Liste { Stapel() {} Stapel(Zelle z) { anfang = z; } boolean isEmpty(){ return anfang==null; } Stapel push(int i) { Zelle z = new Zelle(i, anfang); return new Stapel(z);} Stapel pop() { return new Stapel(anfang.next); } int top() { return anfang.inhalt; } } class StapelDemo{ static Stapel empty = new Stapel(); public static void main(String[] args) { System.out.println(empty.isEmpty()); System.out.println(empty); System.out.println(empty.push(111)); Stapel s = empty.push(111).push(222).push(333); System.out.println(s); System.out.println(s.pop().push(444)); System.out.println(s.pop().push(444).pop().pop().top()); }

Problem Durch diese Art der Implementierung wird bei jedem push und pop ein neuer Listenanfang generiert wird von der Speicherbereinigung aufgesammelt trotzdem ein gewisser Effizienzverlust

nichtfunktionale Implementierung Stapel pop() { return new Stapel(anfang.next); } Stapel push(int n) { Zelle z = new Zelle(n, anfang); return new Stapel(z); } Stapel popSE() { removeFirst(); return this; } Stapel pushSE(int n) { insert(n); return this; } *********************** System.out.println(s); System.out.println(s.popSE().pushSE(555)); Stapel popSE() { removeFirst(); return this; } Stapel pushSE(int n) { insert(n); return this; }

Ausführung Jetzt wird nur noch auf ein und derselben Liste gearbeitet!

Unterschied? public class StapelDemo { Stapel s1 = new Stapel(); int sampleMethod() { s1=s1.push(111).push(222).push(333); s2=s1.pop(); return s1.top(); } } Stapel s1 = new Stapel(), s2 = new Stapel(); s1=s1.push(111).push(222).push(333); s2=s1.pop(); System.out.println(s1); System.out.println(s2); Was passiert beim Austausch von pop durch popSE?

Schlangen Zur Implementierung von Schlangen braucht man einen zusätzlichen Zeiger auf den Anfang der Schlange Um den Aufbau am Schlangenende und den Abbau am Anfang zu implementieren, wird die Verkettung sozusagen „umgedreht“

Realisierung von Schlangen public class Queue extends Liste { Zelle ende; boolean isEmpty(){ return anfang==null; } int head() { return anfang.inhalt; } void tail() {anfang=anfang.next; } void append(int n) { Zelle z = new Zelle(n, null); if (isEmpty()) { anfang = z; ende = z; } else { ende.next = z; ende = z; } } package Listen; public class Schlange extends Liste { Zelle ende; boolean isEmpty(){ return anfang==null; } int head() { return anfang.inhalt; } void tail() {anfang=anfang.next; } void append(int n) { Zelle z = new Zelle(n, null); if (isEmpty()) { anfang = z; ende = z; } else { ende.next = z; ende = z; } } } class SchlangenDemo{ static Schlange s = new Schlange(); public static void main(String[] args) { s.append(100); System.out.println(s); s.append(200); s.append(300); System.out.println(s.head()); s.tail();

Doppelt verkettete Listen Für Listen, die auf beiden Seiten zugreifbar sein sollen, bietet sich eine symmetrische Lösung an Für jede Zelle wird Nachfolger und Vorgänger in der Liste gespeichert Beim Einfügen und Löschen müssen die doppelten Verkettungen beachtet werden

Sequenzen als doppelt verkettete Listen public class Sequenz { Item erstes, letztes; Sequenz() {} Sequenz(Item e, Item l) { erstes=e; letztes=l; } boolean isEmpty() { return (erstes==null); } int first (){ return erstes.inhalt; } Sequenz rest() { return new Sequenz(erstes.rechts.erstes,letztes); } Sequenz prefix(int i) { Item neu = new Item(); neu.inhalt = i; if (this.isEmpty()) { return new Sequenz(neu,neu); } else { neu.rechts = erstes.rechts; erstes.links = neu.links; return new Sequenz(neu, letztes); } …} class Item{ int inhalt; SeqInt links, rechts; }