Universität Stuttgart Institut für Automatisierungs- und Softwaretechnik Prof. Dr.-Ing. Dr. h. c. P. Göhner. Java-Kurs am IAS. Java 2012, IAS.

Transkript

1 Universität Stuttgart Institut für Automatisierungs- und Softwaretechnik Prof. Dr.-Ing. Dr. h. c. P. Göhner -Kurs 2012, IAS 1

2 Kursüberblick Erster Tag Teil 1: Erster Überblick Grundlagen Teil 2: Grundlagen der Objektorientierung Klassen und Objekte in 2012, IAS 2

3 Erster Überblick Was ist? ein Projekt von Sun: Programmierumgebung WWW-Browser die Programmierumgebung (DevelopersKit) besteht aus: einem -Compiler verschiedenen Bibliotheken einem Laufzeitsystem einem Debugger Kennzeichen der Programmiersprache: objektorientiert plattformunabhängig streng typisiert sicher in Netzen ähnliche Syntax wie C , IAS 3

4 Erster Überblick Geschichtliches... August 1991: James Gosling (SUN) entwickelt Oak () Entwicklungsziel: einfache Programmiersprache für Consumer Electronics (z.b Interactive TV, Settop-Boxes) Anfang 1994: Nach Misserfolgen im Bereich Consumer Electronics und zunehmendem Erfolg des WWW - Neuausrichtung auf Internet Februar 1995: Erste Version von Oak (jetzt: ) und einem WWW-Browser (Hotjava) werden veröffentlicht August 1995: SUN lizensiert an Netscape, IBM und Microsoft Dezember 1998: JDK 1.2 aktuelle Version , IAS 4

5 Erster Überblick Allgemeine Konzepte wird interpretiert (schneller Entwicklungszyklus) Hohe Zuverlässigkeit und Robustheit durch Speichermanager Verzicht auf (herkömmliche) Zeigertechniken strikte Typenüberprüfung zur Kompilier- und Laufzeit hohe Verfügbarkeit - Code kann jederzeit über das Netzwerk nachgeladen werden Portabilität - Write once, run everywhere GUI-Klassenbibliothek (AbstractWindowingToolkit) 2012, IAS 5

6 Erster Überblick Plattformunabhängigkeit - Interpreter (Pentium) -Compiler (Pentium) - Code *.java -Compiler (SPARC)... *.class - Interpreter (SPARC) - Bytecode (plattformunabhängig) - Interpreter (...) 2012, IAS 6

7 Erster Überblick Vergleich mit C++ (1) baut auf C++ auf: größtenteils identische Syntax Ausnahmebehandlung (exception handling) Meta-Objekt-Informationen vermeidet folgende (teilweise kritische ) C++ Elemente: Zeiger (Pointer) Mehrfachvererbung Präprozessor, keine Header-Dateien generischen Klassen, Templates enthält zusätzliche Elemente Garbage Collection Interface-Konzept Unicode Threads 2012, IAS 7

8 Erster Überblick Vergleich mit C++ (2) ist schlechter als C++: ist nicht standarisiert (Sprache und Bibliotheken) C++ Code ist hardwarenäher 2012, IAS 8

9 Erster Überblick Werkzeuge des JDK Interpreter ( Virtual Machine): java Testumgebung für Applets: appletviewer -Compiler: javac Generierung von HTML-Dokumentation für Klassen: javadoc -Debugger: jdb Headerfile-Generator zur Einbindung von C-Funktionen: javah Disassembler für -Bytecode: javap werden im Rahmen des Kurses nicht behandelt! JDK kostenlos verfügbar: index-jsp html#javasejdk 2012, IAS 9

10 Erster Überblick Applikation contra Applet Applikation: normales, -Programm, vergleichbar mit anderen (interpretierten) Programmiersprachen Bytecode wird von einem Interpreter ausgeführt Applets: werden in HTML-Seiten eingebunden und von Web-Browsern ausgeführt können über das Netz geladen werden unterliegen strengen Sicherheitsanforderungen (z.b. kein Schreiben im lokalen Dateisystem) ermöglichen interaktive Web-Seiten 2012, IAS 10

11 Erster Überblick HelloWorld-Applikation (1) // Datei: HelloWorld.java public class HelloWorld { public static void main( String[] args ) { System.out.println( Hello World! ); das gesamte Programm befindet sich innerhalb der Klassendefinition public class HelloWorld { -Programm = Menge von Klassendefinitionen die Klassendefinition HelloWorld muss in einer gleichnamigen Datei HelloWorld.java abgespeichert sein main()-methode ist der Einstiegspunkt des Programms Bildschirmausgabe mit System.out.println() 2012, IAS 11

12 Erster Überblick HelloWorld-Applikation (2) Übersetzung der Applikation (Compiler): % javac HelloWorld.java nach fehlerfreier Übersetzung entsteht die Bytecode-Datei: HelloWorld.class ausführbares Programm = Menge von.class-dateien Ausführen der Applikation (Interpreter): % java HelloWorld Ausgabe von HelloWorld auf dem Bildschirm 2012, IAS 12

13 Erster Überblick HelloWorld-Applet (1) // Datei: HelloWorld.java import java.awt.graphics; public class HelloWorld extends java.applet.applet { public void paint( Graphics g ) { g.drawstring( Hello World!, 50, 25); import ermöglich Zugriff auf AWT-Bibliothek (Abstract Windowing Toolkit, JDK) keine main-methode Überschreiben von vorgegebenen Methoden (paint), die in der AWT-Klasse Applet definiert sind Compiler-Aufruf wie bei Applikation 2012, IAS 13

14 Erster Überblick HelloWorld-Applet (2) // minimale HTML-Datei mit eingebundenem Applet <HTML> <HEAD> <TITLE>HelloWorld Applet</TITLE> </HEAD><BODY> <APPLET CODE= HelloWorld.class WIDTH=100 HEIGHT=100> </APPLET> </BODY> </HTML> CODE gibt Name der Appletklasse an WIDTH und HEIGHT bestimmen die (Pixel-)Größe des Applets HTML-Datei und HelloWorld.class sollten im gleichen Verzeichnis liegen HTML-Datei in -fähigen Browser oder mit appletviewer aufrufen 2012, IAS 14

15 Kursüberblick Erster Tag Teil 1: Erster Überblick Grundlagen Teil 2: Grundlagen der Objektorientierung Klassen und Objekte in 2012, IAS 15

16 Grundlagen Prinzip: Die Syntax von ist stark an C/C++ angelehnt und größtenteils identisch. Anweisungen einzelne -Operationen: Zuweisungen (int i = 1) Ablaufsteuerung (if/else, do-while) Methodenaufrufe (System.out.println( Hallo )) Instanziierungsaufrufe (Date today = new Date()) sonstige Anweisungen (import java.awt.font) Wichtig: Anweisungen werden durch Semikolon (;) getrennt, z.b.: import java.awt.font; int i = 1; System.out.println( Hallo ); 2012, IAS 16

17 Grundlagen Variablen (1) Stellen im Speicher, die Werte aufnehmen können bestehen aus Typ, Namen und Wert: int i = 12; müssen vor der Benutzung deklariert werden: zaehler = 7; // Fehler: Variable zaehler unbekannt! Deklaration mit Anfangswerten erlaubt: boolean muede = false; Mehrfachdeklarationen in einer Zeile möglich: int i = 0, j = 3, k = 5; Variablennamen müssen mit einem Buchstaben, einem Unterstreichungsstrich (_) oder einem Dollarzeichen ($) beginnen 2012, IAS 17

18 Grundlagen Variablen (2) unterscheidet Groß/Kleinbuchstaben aussagekräftige Variablennamen wählen! Variablentyp darf sein: primitiver Datentyp Klassenname Array neue (benutzerspezifische) Variablentypen können nur durch neue Klassen erzeugt werden (kein typedef wie in C/C++!) 2012, IAS 18

19 Grundlagen Primitive Datentypen Typ Bedeutung Größe boolean true oder false 1 Bit char Unicode-Zeichen 16 Bits byte Ganze Zahl mit Vorzeichen 8 Bits short Ganze Zahl mit Vorzeichen 16 Bits int Ganze Zahl mit Vorzeichen 32 Bits long Ganze Zahl mit Vorzeichen 64 Bits float IEEE 754-Fließkommazahl 32 Bits double IEEE 754-Fließkommazahl 64 Bits keine Implementierungsabhängigkeiten 2012, IAS 19

20 Grundlagen Kommentare // Text Kommentar bis zum Ende der Zeile /* Text */ mehrzeilige Kommentare möglich, aber kein Verschachteln von Kommentaren! /** Text */ spezielle Kommentare für javadoc Zeichenketten keine Zeichen-Arrays sondern Objekte der Klasse String bestehen aus mehreren Zeichen zwischen doppelten Anführungszeichen ( Hallo ) Verkettung (+) möglich ( Hallo +, World ) können Escape-Zeichen enthalten (Auszug): \n neue Zeile \t Tab \b Rückschritt \r Return \\ Backslash \ doppeltes Anführungszeichen \xdd Hexadezimal \uddd Unicode-Zeichen 2012, IAS 20

21 Grundlagen Operatoren (1) Arithmetik Operator Bedeutung Beispiel + Addition Subtraktion 5-7 * Multiplikation 5 * 5 / Division 14 / 7 % Modulo 20 % 7 Zuweisungen Ausdruck Bedeutung x += y x -= y x *= y x /= y x = x + y x = x - y x = x * y x = x / y 2012, IAS 21

22 Operatoren (2) Inkrement/Dekrement Grundlagen Ausdruck Bedeutung x++ x = x + 1, Inkrementieren (postfix) x-- x = x 1, Dekrementieren (postfix) ++x x = x + 1, Inkrementieren (prefix) --x x = x - 1, Dekrementieren (prefix) postfix: Der Wert wird nach dem auslesen verändert. prefix: Der Wert wird bevor dem auslesen verändert. Bsp.: int x = 5; // Initialisierung der Variable x mit dem Wert 5 System.out.println(x++); // Ausgabe von 5 System.out.println(x); // Ausgabe von 6 x = 5; // Zuweisung des Wertes 5 an die Variable x System.out.println(++x); // Ausgabe von 6 System.out.println(x); // Ausgabe von , IAS 22

23 Grundlagen Operatoren (3) Vergleiche und Boolean Operator Bedeutung Beispiel == Gleich x == 3!= Ungleich x!= 3 <, > Kleiner als, Größer als x < 3, x > 3 <=, >= Kleiner gleich, Größer gleich x <= 3, x >= 3 && Und (x > 0) && (x < 1) Oder (x > 0) (x < 1) 2012, IAS 23

24 Grundlagen Operatoren (3) Bitweise Operatoren Operationen auf einzelne Bits in Ganzzahlen (z.b. Verschiebungen, Komplement, AND, OR,...) spielen in diesem Kurs keine Rolle Operatorpräzedenz Reihenfolge, in der Ausdrücke mit Operatoren bewertet werden, z.b y = / 2 ist 8 und nicht 5! Reihenfolge (kann durch Klammerung geändert werden): 1) Klammern ([], ()) und Methoden- und Variablenzugriffe (.) 2) Inkrement/Dekrementausdrücke (++, --) 3) Multiplikation, Division, Modulo (*, /, %) 4) Addition, Subtraktion (+, -) 5) Bitweise Operationen 6) Vergleiche (<, >, ==,!=) 7) Logische (Boolsche) Operatoren (&&, ) 8) Zuweisungen (=, +=, -=, *=, /=,...) 2012, IAS 24

25 Grundlagen Operatoren (4) Beispiel: // Datei: OperatorTest.java class OperatorTest { public static void main(string[] args) { int x = 6; int y = 4; System.out.println( x + y = + (x + y)); // = 10 System.out.println( x / y = + (x / y)); // = 1 System.out.println( x % y = + (x / y)); // = 2 System.out.println( ++x : + (++x)); // = 7 System.out.println( --x : + (--x)); // = , IAS 25

26 Grundlagen Ablaufsteuerung (1) if-anweisung if( wert >= 1 ){ summe = summe + wert; else { wert = 0; // Bedingung // Anweisungen // alternativer Zweig // Anweisungen else-zweig ist optional bei nur einem Befehl im if/else-zweig kann die {- Klammerung weggelassen werden: if( wert >= 1 ) summe = summe + wert; 2012, IAS 26

27 Grundlagen Ablaufsteuerung (2) switch-anweisung switch( wert ){ case 1: summe++; // wert = 1! case 2: summe = summe + 2; // wert = 2! break; // springt aus der {-Klammer default: summe = 0; // Vergleich immer erfüllt! zur Variablen wert passender Ausdruck und/oder Default- Ausdruck wird ausgeführt 2012, IAS 27

28 Grundlagen Ablaufsteuerung (3) while-schleife while( summe >= 1 ){ summe--; // Schleifen-Bedingung // Anweisungen Wiederholung der Anweisungen bis Schleifen-Bedingung falsch do-while-schleife do{ summe--; while( summe >= 1 ); // Anweisungen wie while-schleife, Anweisungen werden jedoch mindestens einmal durchlaufen 2012, IAS 28

29 Grundlagen Ablaufsteuerung (4) for-schleife for( int i = 0; i < 10; i++ ){ System.out.println(i); // Anweisungen zunächst Ausführung der Initialisierungsanweisung (int i = 0) Auswertung des Boolschen Ausdrucks ( i < 10 ): falls wahr, wird zunächst die Anweisung (System.out.println(i)) und dann die Inkrementierunganweisung (i++) ausgeführt Ablauf wiederholen solange Boolscher Ausdruck wahr ist in der for-schleife deklarierte Variablen sind nur innerhalb der Schleife gültig 2012, IAS 29

30 Grundlagen Ablaufsteuerung (5) continue-anweisung for( int i = 0; i < 10; i++ ){ if( i > 6 ) continue; System.out.println(i); // continue springt hierher springt an das Ende des Schleifenrumpfes return-anweisung return i; beendet Methode und liefert (falls vorhanden) Rückgabewert der Methode 2012, IAS 30

31 Grundlagen Zusammenfassung ist eine objektorientierte Sprache von Sun, die für den Einsatz in Netzen konzipiert ist Portabilität wird durch plattformunabhängigen Bytecode erreicht: Write once, run everywhere vereinfacht C++ (Zeiger, Präprozessor) und bietet zusätzliche Elemente (Garbage Collection) mit können sowohl normale Programme als auch Applets geschrieben werden Anweisungen, Variablen, Operatoren und Ablaufsteuerung sind bis auf wenige Ausnahmen mit C/C++ identisch das JDK ist kostenlos verfügbar 2012, IAS 31

32 Kursüberblick Erster Tag Teil 1: Erster Überblick Grundlagen Teil 2: Grundlagen der Objektorientierung Klassen und Objekte in 2012, IAS 32

33 Grundlagen der Objektorientierung Begriffe Objektorientierte Analyse OOA ist Analysemethode, Anforderungen aus der Perspektive der Klassen und Objekte, die sich im Vokabular des Problembereichs finden Objektorientiertes Design OOD ist Designmethode, Prozess der objektorientierten Zerlegung Notation für Beschreibung der logischen und physikalischen wie auch statischen und dynamischen Modelle des betrachteten Systems Objektorientierte Programmierung Implementierungsmethode, Programme als Ansammlungen von kooperierenden Objekten jedes Objekte ist Exemplar (Instanz) einer Klasse alle Klassen sind Elemente einer Klassenhierarchie, die durch Vererbungsbeziehungen gekennzeichnet ist 2012, IAS 33

34 Grundlagen der Objektorientierung Hauptelemente des Objektmodells Die folgenden vier Konzepte sind die vier Hauptelemente des Objektmodells (nach G.Booch) Fehlt eines dieser vier Elemente, so ist das Modell nicht objektorientiert: Abstraktion Kapselung Modularität Hierarchie 2012, IAS 34

35 Grundlagen der Objektorientierung Abstraktion konzentriert sich auf die wesentlichen Charakteristika eines Objekts relativ zur Perspektive des Betrachters 2012, IAS 35

36 Grundlagen der Objektorientierung Kapselung verbirgt die Details der Objekt-Implementierung trennt somit die Schnittstelle einer Abstraktion von ihrer Implementierung 2012, IAS 36

37 Grundlagen der Objektorientierung Modularität packt Abstraktionen in eigenständige Einheiten Verbindungen zwischen den Modulen sind die Annahmen, die die Module gegenseitig übereinander anstellen 2012, IAS 37

38 Grundlagen der Objektorientierung Hierarchie Abstraktionen bilden eine Hierarchie Klassenstruktur: ist-ein - Hierarchie (Vererbung) Objektstruktur: Teil-von - Hierarchie (Aggregation) 2012, IAS 38

39 Methode 4 Grundlagen der Objektorientierung Objekt allgemein: Gegenstand des Interesses (einer Beobachtung, Untersuchung, Messung) Objektorientierung: individuelles Exemplar von Gegenständen (Auto, Roboter), Personen (Kunde, Mitarbeiter), Begriffen der realen Welt (Auftrag) oder Begriffen der Vorstellungswelt (Strategie) Kennzeichen von Objekten: Identität: Objekt kann deutlich von anderen unterschieden werden Daten (Variablen): Eigenschaften des Objekts Methoden (Operationen): Lesen und Manipulieren von Daten Geheimnisprinzip: Datenzugriff nur über Methoden Methode 1 Daten Methode 3 Methode , IAS 39

40 Grundlagen der Objektorientierung Klasse allgemein: Gruppe von Gegenständen, Lebewesen, Begriffen mit gemeinsamen Merkmalen Objektorientierung: Objekt-Schablone für Objekte mit denselben Variablen (Daten) und denselben Operationen (Methoden) Objekt-Erzeugungsmechanismus Mitarbeiter-Objekt ändern Name Name Müller Gehalt ändern Name Name Gehalt ändern Gehalt Mitarbeiter- Klasse Mitarbeiter-Objekt ändern Name Name Meier Gehalt ändern Gehalt ändern Gehalt 2012, IAS 40

41 Grundlagen der Objektorientierung Klasse Name : Größe : Farbe : Huhn Eier legen() gackern() Berta Objekte Elfriede Kunigunde Elsa 2012, IAS 41

42 Grundlagen der Objektorientierung Vererbung Stellt eine Verallgemeinerung / Spezialisierung-Hierarchie dar Eine untergeordnete Klasse erbt Eigenschaften und Verhalten einer oder mehrerer übergeordneter Klassen...ist ein... - Beziehung 2012, IAS 42

43 Grundlagen der Objektorientierung Vererbung Fahrzeug Landfahrzeug Wasserfahrzeug PKW Motorrad Amphibienfahrzeug Schiff Cabrio 2012, IAS 43

44 Grundlagen der Objektorientierung Aggregation Stellt Beziehung zwischen einem Ganzen und seinen Teilen dar...hat ein... - oder...ist Teil von... - Beziehung 2012, IAS 44

45 Grundlagen der Objektorientierung Aggregation Auto Motor Lenkrad Rad Auspuff Zündkerze 2012, IAS 45

46 Grundlagen der Objektorientierung Unterschied zwischen Vererbung und Aggregation: Vererbung: Ein Cabrio ist ein PKW. Ein Cabrio ist ein Fahrzeug. Ein Amphibienfahrzeug ist ein Landfahrzeug und ein Wasserfahrzeug. Aggregation: Ein Auto hat einen Motor, ein Lenkrad, Sitze,... Ein Computer hat eine Grafikkarte, RAM, Prozessor, , IAS 46

47 Kursüberblick Erster Tag Teil 1: Erster Überblick Grundlagen Teil 2: Grundlagen der Objektorientierung Klassen und Objekte in 2012, IAS 47

48 Klassen und Objekte in Programmstruktur (1) Überblick: Programm *.java *.java *.java... class interface class package 2012, IAS 48

49 Klassen und Objekte in Programmstruktur (2) *.java-dateien: Beinhalten Klassen- und Schnittstellendeklarationen, wobei (genau) eine Klasse/Schnittstelle als public deklariert sein muss Klassen-/Schnittstellenname und Dateiname müssen übereinstimmen (Groß- und Kleinschreibung beachten) Beinhalten package-anweisung Beinhalten import-anweisungen Beispiel: // Datei Test.java package ias.kurs.java; import java.awt.*; public class Test { ; , IAS 49

50 Klassen und Objekte in Programmstruktur (3) packages (Pakete): Organisationseinheit für Klassen und Schnittstellen beliebig tiefe Schachtelung von Paketen ist möglich, z.b. java.awt.image Schachtelungsstruktur wird auf Verzeichnisse abgebildet, z.b. java/awt/image ohne Angabe eines Pakets wird ein namenloses Defaultpackage zugeordnet Legen Namensraum fest alle Klassen eines packages können einander direkt referenzieren Klassen anderer Pakete müssen explizit importiert (import) oder qualifiziert (vollständige Pfadangabe) werden alle Klassen aus dem Paket java.lang sind standardmäßig importiert Zur Steuerung von Zugriffsrechten nützlich alle Klassen eines packages können einander sehen 2012, IAS 50

51 Klassen und Objekte in Programmstruktur (4) Applikation: Durch Einfügen einer main()-methode in eine Klasse wird eine Applikation vervollständigt: // Datei: HelloWorld.java public class HelloWorld { public static void main( String[] args ) { System.out.println( Hello World! ); Die main()-methode ist Einstiegspunkt in das Programm Die vor main() stehenden Schlüsselwörter (public static void) sowie die Parameter (String[] args) sind immer gleich 2012, IAS 51

52 Klassen und Objekte in Klassen (1) Überblick: Klasse Variablen Methoden Konstruktoren Variablen (Attribute): primitiver Typ: int i; Referenz: Auto meinauto; Array: int[] intfeld1; Methode: Operation mit möglichen Rückgabewert (return) eindeutig durch Methodenname und Parameter Konstruktor: Zur Instanzierung von Objekten benötigt Default: Klassenname(){; weitere Konstruktoren möglich kein Rückgabewert! 2012, IAS 52

53 Methode Klasse Methode Klassen und Objekte in Klassen (2) Beispiel: // Datei: Motorrad.java class Motorrad { String modell, farbe; boolean motorzustand; Variablen // Referenz auf Strings // Motor an/aus void startemotor(){ // Methode startemotor if(motorzustand == true) System.out.println( Motor ist bereits an! ); else { motorzustand = true; System.out.println( Motor ist jetzt an! ); void zeigedaten(){ // Methode zeigedaten System.out.println( Das Motorrad ist eine + farbe + e + modell); 2012, IAS 53

54 Klassen und Objekte in Klassen (3) Erklärungen: Klassendefinition durch: class Motorrad { drei Variablen: Referenz auf Klasse String (Zeichenkette): model und farbe vom Datentyp boolean: motorzustand zwei Methoden: zum Starten des Motors startemotor(); zur Ausgabe der Motorraddaten zeigedaten(); Einrückungen haben für den Compiler keine Bedeutung keine Trennung von Deklarationen und Implementierung 2012, IAS 54

55 Klassen und Objekte in Objekterzeugung mit new neue Objekte werden aus bestehenden Klassen mit new-operator erzeugt: String str = new String(); Motorrad m2 = new Motorrad(); Klammern dürfen nicht weggelassen werden! der new-operator weist dem Objekt Speicherplatz zu und ruft den passenden Konstruktor (Initialisierung) auf Beispiel: import java.util.date; class DatumAnzeige { public static void main( String args[] ){ Date d1, d2; d1 = new Date(); System.out.println( Datum 1: + d1); d2 = new Date( April :00 AM ); System.out.println( Datum 2: + d2); 2012, IAS 55

56 Klassen und Objekte in Variablen (1) Allgemein: Allgemeine Deklaration einer Variable: [schlüsselwörter] Typ/Klasse variablenname Zugriff mit Hilfe der Punkt-Notation: einobjekt.var1 //Zugriff auf var1 in einobjekt einobjekt.v-aussen.v-innen // verschachtelter Aufruf Beispiel: import java.awt.point; class TestPunkt { public static void main( String args[] ) { Point punkt = new Point (); punkt.x = 5; punkt.y = 12; System.out.println( Punkt(x/y): + punkt.x + / + punkt.y ); 2012, IAS 56

57 Klassen und Objekte in Variablen (2) Klassenvariablen: Klassenvariablen sind im Gegensatz zu normalen Variablen Bestandteil der Klasse und nicht eines Objektes, d.h. sie sind nur einmal pro Klasse vorhanden. Klassenvariablen werden mit dem static Schlüsselwort definiert: class FamilienMitglied { static String nachname = Mueller ; String vorname; der Zugriff auf Klassenvariablen kann entweder über die Klasse oder über das Objekt erfolgen: FamilienMitglied sohn = new FamilienMitglied(); System.out.println(FamilienMitglied.nachname ); // ueber Klasse System.out.println(sohn.nachname ); // ueber Objekt 2012, IAS 57

58 Klassen und Objekte in Variablen (3) Referenzen: kennt keine Zeiger und Zeigerarithmetik, aber ähnliche Möglichkeiten durch Referenzen Arbeiten mit Objekten bedeutet in hauptsächlich Arbeiten mit Referenzen: Beispiel: import java.awt.point; class ReferenzenTest { public static void main( String args[] ) { Point pt1, pt2; pt1 = new Point(100, 100); pt2 = pt1; pt1.x = 200; pt1.y = 200; System.out.println( pt1: + pt1.x +, + pt1.y); System.out.println( pt2: + pt2.x +, + pt2.y); 2012, IAS 58

59 Klassen und Objekte in Variablen (4) Erklärungen zu ReferenzenTest: 1. Referenzen pt1, pt2 anlegen 2. Point-Objekt mit Wert (100, 100) anlegen, Referenz pt1 zeigt auf Objekt pt1 pt2 3. Referenz pt2 zeigt auf selbes Objekt wie pt1 4. Objektwerte werden mit Hilfe von pt1 geändert 5. Werteausgabe mit Hilfe von pt1 und pt2 Point Objekt x: 200 y: , IAS 59

60 Klassen und Objekte in Variablen (5) Arrays: Arrays können beliebig viele Elemente eines Datentyps speichern verschiedene Datentyp-Elemente in einem Array sind nicht möglich Deklaration String[] words; Point[] hits; Erstellen des Array-Objekts oder String words[]; Point hits[]; String[] words = new String[10]; String[] farbe = { weiss, schwarz, rot ; Array kann mit new (s. words) oder mit Initialisierungswerten (s. farbe) erstellt werden mit new werden die Array-Elemente automatisch initialisiert (Initialisierungswerte (abhängig vom Datentyp): 0, false, ) 2012, IAS 60

61 Klassen und Objekte in Variablen (6) Arrays: Zugriff auf Array-Elemente String[] words = new String[10]; words[0] = ; ein Array der Größe n hat die Indizes [0] bis [n-1] Zugriffe außerhalb des Arrays werden von Compiler und von der Laufzeitumgebung erkannt, z.b. words[10] = Error die Instanzenvariable length enthält die Größe des Arrays int laenge = words.length; // gibt 10 aus durch Schachtelung können mehrdimensionale Arrays erzeugt werden: int koord[][] = new int[5][10]; koord[0][0] = 4; koord[4][9] = 123; 2012, IAS 61

62 Klassen und Objekte in Methoden (1) Definition: eine Methode besteht aus mindestens vier Teilen: Name der Methode Parameter (Argumentliste) Datentyp, der von der Methode zurückgegeben wird (void: kein Rückgabewert) Methodenkörper returntype methodenname(typ1 arg1, typ2 arg2,...){... optional können Zugriffsrechte und Ausnahmen festgelegt werden mit this auf das aktuelle Objekt zugegriffen werden Signatur t = this.x; // Zuweisung Objektvariable x this.methode1(this); // Methodenaufruf mit this return this; // Rueckgabe des aktuellen Objekts 2012, IAS 62

63 Klassen und Objekte in Methoden (2) Methodenaufruf: Methoden werden mit Hilfe der Punkt-Notation und Argumentliste (in Klammern) aufgerufen: einobjekt.methode1(arg1, arg2, arg3); verschachtelte Methodenaufrufe sind möglich: einobjekt.var1.methode1(arg1, arg2); in der Parameterliste werden primitive Datentypen als Wert, alle anderen als Referenz an die Methode übergeben, d.h. wird ein referenziertes Objekt von der Methode verändert, so bleibt die Veränderung nach Beendigung der Methode bestehen 2012, IAS 63

64 Klassen und Objekte in Methoden (3) Beispiel:... class RefArgument { int One2Zero( int arg[]) { int count = 0; for( int i = 0; i < arg.length; i++ ) { if(arg[i] == 1) { count++; arg[i] = 0; return count; public static void main (String[] args) { int arr[] = {1, 5, 3, 1, 1, 6, 8, 1; int neins; RefArgument test = new RefArgument(); for( int i = 0; i < arr.length; i++ ) System.out.print(arr[i] + ); neins = test.one2zero(arr); System.out.println( Gefundene Einsen: + neins); for( int i = 0; i < arr.length; i++ ) System.out.print(arr[i] + ); , IAS 64

65 Klassen und Objekte in Methoden (4) Klassenmethoden: Klassenmethoden wirken sich (wie Klassenvariablen) auf ganze Klassen und nicht nur auf einzelne Objekte aus werden dort benützt, wo Objekte nicht vorausgesetzt sind, z.b. Klasse Math der -Klassenbibliothek: float root = Math.sqrt(453.2); Klassenmethoden werden mit dem static Schlüsselwort definiert: static int max( int arg1, int arg2) {... Regel: Alle Methoden, die von allgemeiner Nützlichkeit sind und nicht auf einzelne Objekte anwendbar sind, sollten als Klassenmethoden definiert werden. Frage: Kennen Sie bereits eine Klassenmethode? Antwort: Die main-methode 2012, IAS 65

66 Klassen und Objekte in Vergleichen von Objekten die meisten Operatoren sind nur auf primitive Datentypen (int, byte, char), aber nicht auf Objekte anwendbar Ausnahme: == und!= prüfen Objekt(un)gleichheit, aber keine Werte(un)gleichheit Wertevergleich in Klasse String durch Methode equals(): Beispiel: class EqualsTest { public static void main(string args[]) { String str1, str2; str1 = macht Spass! ; str2 = str1; System.out.println( Gleiches Objekt? + (str1 == str2)); str2 = new String(str1); System.out.println( Gleiches Objekt? + (str1 == str2)); System.out.println( Gleicher Wert? + str1.equals(str2)); // wahr // falsch // wahr 2012, IAS 66

67 Klassen und Objekte in Kopieren von Objekten mit copy() kann ein Objekt in eine Instanz derselben Klasse kopiert werden im kopierten Objekt enthaltene Objekte werden nicht mitkopiert Point pt1, pt2, pt3; pt1 = new Point(0, 0); pt2 = new Point(100, 100); pt2.copy(pt1); // alle pt1-werte werden in pt2 kopiert mit clone() kann eine neue Instanz der Quellobjekt-Klasse erzeugt und mit den Quellobjektwerten initialisiert werden pt3 = (Point) pt2.clone(); 2012, IAS 67

68 Klassen und Objekte in Zusammenfassung Paradigma Objektorientierung: Abstraktion Kapselung Modularität Hierarchie Struktur eines -Programms: Klassen und Pakete Dateien und Verzeichnisse Aufbau einer Klasse: objekt- und klassenbezogene Variablen und Methoden Arbeiten mit Objekten heißt arbeiten mit Referenzen Elementare Operationen auf Objekten: Erzeugen, Vergleichen und Kopieren 2012, IAS 68

69 Kursüberblick Zweiter Tag Teil 1: Overloading, Konstruktoren, Vererbung Ausnahmebehandlung Teil 2: Datenstreams und Dateien 2012, IAS 69

70 Overloading, Konstruktoren, Vererbung Überladen von Methoden (1) Überladen von Methoden (Overloading): gleicher Methodenname, aber unterschiedliche Argumentliste (Anzahl und Typ) in können nur Methoden überladen werden (Operatoren-Overloading ist nicht möglich) Überladen bewirkt Vereinfachung der Schnittstelle: nur ein Methodenname muss gelernt werden, richtige Methode wird in Abhängigkeit von Argumentliste aufgerufen Wichtig: Rückgabetyp kann beim Überladen nicht zur Unterscheidung verwendet werden 2012, IAS 70

71 Overloading, Konstruktoren, Vererbung Überladen von Methoden (2) Beispiel - Initialisierung mit Methoden class Rechteck1 { int x1 = 0; // Punktkoordinaten oben rechts int y1 = 0; int x2 = 0; // Punktkoordinaten unten links int y2 = 0; Rechteck initrecht(int x1, int y1, int x2, int y2) { this.x1 = x1; this.y1 = y1; this.x2 = x2; this.y2 = y2; return this; Rechteck initrecht(point oblinks, Point unrechts) { x1 = oblinks.x; y1 = oblinks.y; x2 = unrechts.x; y2 = unrechts.y; return this; 2012, IAS 71

72 Overloading, Konstruktoren, Vererbung Konstruktor (1) besondere Methodenart, die bei der Instanziierung einer Klasse (new) automatisch aufgerufen wird Konstruktoren bestimmen die Initialisierung der Objekte Ablauf der Instanziierung mit new: Speicherplatz für Objekt reservieren Initialisierung der Instanzvariablen mit Defaultwerten Konstruktor-Aufruf Konstruktor-Definition: gleicher Name wie Klasse kein Rückgabewert! Konstruktoren können wie Methoden überladen werden Aufräumarbeiten können mit der finalize-methode veranlasst werden (Dekonstruktor) 2012, IAS 72

73 Overloading, Konstruktoren, Vererbung Konstruktor (2) Beispiel - Initialisierung mit Konstruktoren: class Rechteck { int x1 = 0; int y1 = 0; int x2 = 0; int y2 = 0; // Punktkoordinaten oben rechts // Punktkoordinaten unten links Rechteck(int x1, int y1, int x2, int y2) { this.x1 = x1; this.y1 = y1; this.x2 = x2; this.y2 = y2; Rechteck(Point oblinks, Point unrechts) { x1 = oblinks.x; y1 = oblinks.y; x2 = unrechts.x; y2 = unrechts.y; 2012, IAS 73

74 Overloading, Konstruktoren, Vererbung Vererbung (1) ermöglicht Hierarchisierung von Klassen übergeordnete Superklassen vererben Variablen und Methoden an Subklassen, d.h. Subklassen erben von Superklassen in erben alle Klassen implizit von der Klasse Object, welche allgemeingültige Verhaltensregeln definiert Klassenhierarchie: A B Hierarchie-Wurzel: Klasse A (in Klasse Object) abgeleitete Klasse B, erbt von A C D E abgeleitete Klassen C, D und E erben jeweils von B und A 2012, IAS 74

75 Overloading, Konstruktoren, Vererbung Vererbung (2) Vererbungsvarianten: Einfach- und Mehrfachvererbung Einfachvererbung: jede Klasse hat höchstens eine Superklasse Mehrfachvererbung: jede Klasse kann von mehreren Superklassen erben (in nicht erlaubt) Einfachvererbung (Baum): Mehrfachvererbung (Netz): 2012, IAS 75

76 Overloading, Konstruktoren, Vererbung Vererbung (3) Beispiel: class Punkt { int x; int y; // x-koordinate // y-koordinate void printinfopunkt() { System.out.println( Punkt: + x + / + y); class Pixel extends Punkt { String farbe; // Punktfarbe void printinfopixel() { System.out.println( Pixel: + x + / + y); System.out.println( Pixelfarbe: + farbe ); Subklasse erbt automatisch alle Variablen und Methoden der Superklasse Regel: Ableiten macht nur Sinn, wenn eine allgemeingültige Klasse durch neue Methoden/Variablen erweitert/verändert werden soll 2012, IAS 76

77 Overloading, Konstruktoren, Vererbung Vererbung (4) Wie funktioniert ein Methodenaufruf in? zunächst in der aktuellen Klasse nach passender Methodendefinition suchen falls Suche in aktueller Klasse erfolglos, Aufruf in der Klassenhierarchie nach oben weiterreichen Konsequenzen: bereits definierte Methoden können in Subklassen ohne Codeduplizierung wiederverwendet werden die Methode einer Superklasse kann in der Subklasse entweder unverändert übernommen oder überschrieben/redefiniert werden Wichtig: Überschreiben (Signatur gleich) nicht mit Überladen (Argumentliste unterschiedlich) verwechseln! 2012, IAS 77

78 Overloading, Konstruktoren, Vererbung Methoden überschreiben (1) Methoden mit identischer Signatur wie in Superklasse, aber unterschiedliche Methodenkörper Warum überschreibt man Methoden? um geerbte Methoden vollständig zu ersetzen um geerbte Methoden zu erweitern Beispiel: class PrintKlasse { int x = 0; int y = 1; void drucken() { System.out.println( x, y = + x + + y); class PrintSubKlasse extends PrintKlasse { int z = 3; void drucken() { // geerbte Methode ersetzen System.out.print( x, y, z = + x + + y + + z); 2012, IAS 78

79 Overloading, Konstruktoren, Vererbung Methoden überschreiben (2) das Schlüsselwort super ermöglicht den Zugriff auf die verdeckte Orginalmethode in der Superklasse Beispiel: class PrintKlasse { int x = 0; int y = 1; void drucken() { System.out.println( x, y = + x + + y); class PrintSubKlasse extends PrintKlasse { int z = 3; void drucken() { // geerbte Methode erweitern super.drucken(); System.out.print( z = + z); 2012, IAS 79

80 Overloading, Konstruktoren, Vererbung Konstruktoren überschreiben? Konstruktoren werden grundsätzlich nicht vererbt und können somit auch nicht überschrieben werden beim Konstruktoraufruf für ein Objekt werden automatisch alle Konstruktoren der Superklassen aufgerufen mit dem Schlüsselwort super wird der richtige Konstruktor der Superklasse aufgerufen Beispiel: class BenannterPunkt extends Point{ String name; BenannterPunkt(int x, int y, String name) { super(x, y); this.name = name; 2012, IAS 80

81 Overloading, Konstruktoren, Vererbung Zugriffsrechte für Klassen in wird die Kapselung (OO-Hauptelement) mit Hilfe von Schlüsselwörtern (modifier) verwirklicht für Klassen stehen zwei Zugriffsebenen zur Verfügung: public und package public mit public definierte Klassen sind für alle anderen Klassen sichtbar package ohne zusätzliche Angaben sind Klassen automatisch nur innerhalb des gleichen Pakets sichtbar (kein package- Schlüsselwort notwendig) 2012, IAS 81

82 Overloading, Konstruktoren, Vererbung Zugriffsrechte für Methoden und Variablen (1) in stehen für Methoden und Variablen 4 Zugriffsebenen zur Verfügung: public, package, protected und private das Zugriffs-Schlüsselwort steht vor dem Methoden- /Variablen-namen und wird jeweils einzeln vereinbart public mit public definierte Methoden/Variablen sind für alle anderen Klassen sichtbar, d.h. es gibt keine Zugriffsbeschränkungen Beispiel: public class OffeneKlasse { public int offenesint; public String offenerstring; public float offenemethode() { , IAS 82

83 Overloading, Konstruktoren, Vererbung Zugriffsrechte für Methoden und Variablen (2) package mit dem package-schlüsselwort werden Klassen in Pakete gruppiert falls explizit kein Zugriffsebene definiert wird gilt automatisch die package-schutzebene (kein package- Schlüsselwort) alle Methoden/Variablen dieser Ebenes sind nur innerhalb des gleichen Pakets sichtbar Beispiel: package paket1; public class PaketKlasse { int paketint = 2; String paketstring = a bis z ; float paketmethode() { , IAS 83

84 Overloading, Konstruktoren, Vererbung Zugriffsrechte für Methoden und Variablen (3) protected nur Elemente der gleichen und davon abgeleiteter Klassen haben Zugriff Beispiel: public class ProtectedKlasse { protected int protint = 4; protected String pstr = a bis z ; protected float protectedmethod() {... public class GleichesPaket { public void test() { ProtectedKlasse pk = new ProtectedKlasse(); System.out.println(pk.pstr); pk.protectedmethod(); Nicht erlaubt! 2012, IAS 84

85 Overloading, Konstruktoren, Vererbung Zugriffsrechte für Methoden und Variablen (4) private strengster Schutz: Methoden und Variablen nur innerhalb der eigenen Klasse zugreifbar im Sinne einer umfassenden Kapselung sollten Daten möglichst private deklariert werden spezielle get/set-methoden ermöglichen den kontrollierten Zugriff auf die private-elemente Beispiel: public class Kreis { private int x, y, radius; public int getradius() { return radius; public int setradius( int value ) { radius = value; return radius; 2012, IAS 85

86 Overloading, Konstruktoren, Vererbung Zugriffsrechte im Überblick Klasse Methode/ Variable public für alle Klassen (auch außerhalb des Pakets) - nur für Klassen innerhalb des Pakets public für alle Klassen (auch außerhalb des Pakets) - nur für Klassen innerhalb des Pakets protected private abgeleitete Klassen und Klassen innerhalb des Pakets nur für eigene Klasse Empfehlung: Datenelemente (Variablen) private Methoden protected get-/set-methoden für Zugriff auf private Daten definieren 2012, IAS 86

87 Overloading, Konstruktoren, Vererbung final-modifier (1) mit dem final-schlüsselwort können zusätzl. Einschränkungen definiert werden, die Compiler-Optimierungen ermöglichen Klassen mit final deklarierte Klassen können nicht abgeleitet werden public final class FinalKlasse1 {... Methoden final-methoden können in Subklassen nicht überschrieben werden public class FinalKlasse2 { public final void finalmethode() {... alle Methoden in einer final-klasse sind final alle private-methoden sind implizit final 2012, IAS 87

88 Overloading, Konstruktoren, Vererbung final-modifier (2) Variablen mit final werden in Konstanten deklariert public class FinalKlasse3 { public final int CONSTINT = 243; public final String CSTR = Kaffee ; der konstante Wert wird während der Deklaration zugewiesen lokale Variablen können nicht als final deklariert werden while( summe <= 10 ) {... final int LOCALINT;... Nicht erlaubt! 2012, IAS 88

89 Overloading, Konstruktoren, Vererbung abstract-modifier abstrakte Klassen sind ein Design-Element: mit abstract gekennzeichnete Klassen können nicht instanziiert werden in einer abstrakten Klasse werden Methoden ohne Implementierung (Methodenkörper) mit abstract gekennzeichnet Beispiel: public abstract class AbstrakteKlasse { int i; public void tuwas() {... public abstract void absmethode(); Object a = new AbstrakteKlasse(); Nicht erlaubt! 2012, IAS 89

90 Overloading, Konstruktoren, Vererbung Schnittstellen (1) Problem: Tierhierarchie Tier Säugetier Vogel Merkmale: + lebende Jungen + legen Eier + Fell + Schnabel Wohin gehört das Schnabeltier (Fell & Schnabel)? Ziel: Lösung: gemeinsames Verhalten verwenden, ohne Codeduplizierung a) Mehrfachvererbung: in nicht erlaubt b) Schnittstellen 2012, IAS 90

91 Overloading, Konstruktoren, Vererbung Schnittstellen (2) Schnittstelle: Sammlung von abstrakten Methodendeklarationen und Konstanten ohne Methodenimplementierungen und Instanzvariablen Definition Deklaration mit Schlüsselwort interface Schnittstellenmethoden sollten als public abstract und Konstanten als public static final deklariert sein Schnittstellen gehören zu Paketen und können andere Pakete importieren Schnittstellen können mit extends in Hierarchien organisiert werden public interface Iface { public static final int incr = 10; public static final long maxnum = ; public abstract void doit(); 2012, IAS 91

92 Overloading, Konstruktoren, Vererbung Schnittstellen (3) Anwendung Schnittstellen werden durch das Schlüsselwort implements in eine Klassendefinition eingebunden alle in der Schnittstelle deklarierten Methoden müssen von der einbindenden Klasse implementiert werden eine Klasse darf mehrere Schnittstellen implementieren Regel: Schnittstellen können mit wenigen Ausnahmen überall dort verwendet werden, wo auch Klassen verwendet werden Beispiel: public interface Fruchtartig { public abstract void verfallen(); public abstract void auspressen(); public class Frucht implements Fruchtartig { private Color farbe; public void verfallen() {... public void auspressen() { , IAS 92

93 Kursüberblick Zweiter Tag Teil 1: Overloading, Konstruktoren, Vererbung Ausnahmebehandlung Teil 2: Datenstreams und Dateien 2012, IAS 93

94 Ausnahmebehandlung Ausnahmefälle (1) Design und Implementierung von Klassen und Methoden beschreiben normalen Ablauf, nicht jedoch den Ablauf in Ausnahmefällen bietet die Möglichkeit, Ausnahmefälle zu deklarieren und zu behandeln, d.h. ungewöhnliche Situationen werden handhabbar, ohne den normalen Quellcode aufzubrechen Ausnahmefälle sind Objekte, die in einer Klassenhierarchie organisiert sind kennt drei Arten von Ausnahmefällen, die alle von der Superklasse Throwable abgeleitet sind: Ausnahmen (Exception): ClassNotFound, FileNotFound Laufzeitausnahmen (RuntimeException): IndexOutOfBounds Fehler (Error): OutOfMemory, StackOverflow 2012, IAS 94

95 Ausnahmebehandlung Ausnahmefälle (2) Ausnahmefälle deklarieren Ausnahmefälle, die innerhalb einer Klasse oder Methode auftreten können, werden mit dem throws-schlüsselwort deklariert public class AusnahmeKlasse { public void ausnahmemethode1() throws AusnameFall1 {... Fehler und Laufzeitausnahmen müssen nicht deklariert werden Wenn in einer Methode Ausnahmen auftreten können, müssen diese a) potentiellen Aufrufern mit der throws-deklaration explizit bekanntgegeben werden oder b) von der Methode selbst gehandhabt werden 2012, IAS 95

96 Ausnahmebehandlung Ausnahmefälle (3) Ausnahmen handhaben (Exception Handling) Ausnahmefälle werden mit den try/catch-anweisungen gehandhabt public void methode2() { AusnahmeKlasse aklasse = new AusnahmeKlasse(); try { // ausnahmeträchtiger Code aklasse.ausnahmemethode1(); catch ( AusnahmeFall1 ) {... eingetretene Ausnahmen werden in der Methoden- Aufrufhierarchie nach oben gereicht, bis sie a) behandelt werden oder b) das Programm mit einer Fehlermeldung abgebrochen wird 2012, IAS 96

97 Ausnahmebehandlung Ausnahmefälle (4) Ausnahmen auswerfen mit Hilfe der throw-anweisung werden Ausnahmen ausgeworfen public class AusnahmeKlasse { public void ausnahmemethode1() throws AusnahmeFall1 { // normaler Code if( ungewoehnlichervorfall() ) { throw new AusnahmeFall1(); // hier wird die Ausfuehrung abgebrochen tritt eine Ausnahme ein, so werden alle Anweisungen hinter der throw-anweisung ignoriert 2012, IAS 97

98 OO-Konzepte & Ausnahmebehandlung Zusammenfassung Überladen von Methoden Konstruktoren Vererbung Überschreiben von Methoden/Konstruktoren Zugriffsrechte für Klassen, Methoden und Variablen final-modifier abstrakte Klassen und Methoden Schnittstellen Behandlung von Ausnahmen 2012, IAS 98

99 Kursüberblick Zweiter Tag Teil 1: Overloading, Konstruktoren, Vererbung Ausnahmebehandlung Teil 2: Datenstreams und Dateien 2012, IAS 99

100 Datenstreams und Dateien Datenstreams Informationen aus einer Quelle einlesen Informationen an ein Ziel ausgeben z.b. Datei, Bildschirm allgemeiner Ablauf: Lesen Einen Stream öffnen Solange noch Informationen vorhanden Information lesen Stream schließen Schreiben Einen Stream öffnen Solange noch Informationen vorhanden Information schreiben Stream schließen 2012, IAS 100

101 Datenstreams und Dateien Datenstreams von Quelle/Ziel muss nur der Name bekannt sein Package java.io Basis: abstrakte Klassen JDK 1.0 (8bit) InputStream OutputStream seit JDK 1.1 (16 bit) Reader Writer notwendig wegen 16bit Unicode höhere Interpretationsebenen darauf aufbauend möglich (z.b. Serialisation > 1.0) Fehlerbehandlung: IOExceptions Unterklasse von Exception behandelt alle bei Datenstreams möglichen Ein- und Ausgabefehler 2012, IAS 101

102 Datenstreams und Dateien Datenstreams Trennung der Klassenhierarchie in - Eingabe-(Input-)Streams und - Ausgabe-(Output-) Streams Trennung der Klassenhierarchie in - Charakter-Streams (Zeichen) und - Byte-Streams (Binärdaten) 2012, IAS 102

103 Datenstreams und Dateien Überblick Zeichen-Streams (Character Streams) BufferedReader LineNumberReader Reader CharArrayReader InputStreamReader FilterReader PipedReader StringReader FileReader PushbackReader Lesen/Schreiben Daten verarbeiten 2012, IAS 103

104 Datenstreams und Dateien Überblick Zeichen-Streams (Character Streams) (Forts.) BufferedWriter CharArrayWriter OutputStreamWriter FileWriter Writer FilterWriter PipedWriter StringWriter PrintWriter Lesen/Schreiben Daten verarbeiten 2012, IAS 104

105 Datenstreams und Dateien Überblick Byte-Streams FileInputStream InputStream PipedInputStream FilterInputStream ByteArrayInputStream SequenceInputStream StringBuffferInputStream ObjectInputStream LineNumberInputStream DataInputStream BufferedInputStream PushbackInputStream OutputStream FileOutputStream PipedOutputStream FilterOutputStream ByteArrayOutputStream PrintStream DataOutputStream BufferedOutputStream ObjectOutputStream 2012, IAS 105

106 Datenstreams und Dateien EingabeStreams (InputStream) und Leser (Reader) Grundlage aller Eingabeoperationen von InputStream (Reader) definiert die Grundlagen für das Lesen eines Byte-Streams (Zeichen-Datenstream) von einer Quelle. Identität der Quelle und Art der Erstellung und Beförderung von Bytes (Zeichen) nicht relevant Reader und seine Unterklassen sind weitgehend analog der Klasse InputStream, sie benutzen nur Zeichen anstelle Bytes. Alle auf InputStream (Reader) aufbauende Datenstream- Klassen besitzen die auf den folgenden drei Folien vorgestellten Methoden. 2012, IAS 106

107 Datenstreams und Dateien EingabeStreams und Leser (Forts.) Methode read(): Liest Bytes (Zeichen) von einer Quelle wartet, bis alle angeforderten Eingaben zur Verfügung stehen --> Threads import java.io.* notwendig Beispiel (versucht, den gesamten Puffer zu füllen) notw. da abstrakte Klasse InputStream s = getaninputstream(); byte[] bbuffer = new byte[256]; // beliebige Größe if (s.read(bbuffer)!= bbuffer.length) System.out.println( Weniger erhalten als erwartet. ); read() liefert Anzahl der gelesen Byte (Zeichen) zurück bzw. -1 zurück, wenn der Eingabestring zu Ende oder leer ist. weitere read() Methoden, um einen Bereich des Puffers zu füllen oder einzelne Bytes (Zeichen) einzulesen 2012, IAS 107

108 Datenstreams und Dateien EingabeStreams und Leser (Forts.) skip(anz): überspringt anz Bytes (Zeichen) im Datenstream available(): gibt an, wieviele Bytes (Zeichen) ein Datenstream momentan umfasst. Antwort nicht immer möglich. ready(): gibt an, ob weitere Bytes (Zeichen) bereitstehen Antwort nicht immer möglich. mark() und reset(): Markierung einer Position im Datenstream und Zurücksetzen auf die Position, um die Bytes (Zeichen) erneut einzulesen Wird nicht von allen Datenstreams unterstützt --> Methode marksupported(): prüft, ob Markierung möglich 2012, IAS 108

109 Datenstreams und Dateien EingabeStreams und Leser (Forts.) Methode close(): Schließen des Datenstreams und Freigabe der Ressourcen Beispiel Reader r = makeareader(); if (r!= null) { try {... // r benutzen finally { r.close(); Durch Verwendung von finally wird der Datenstream auf jeden Fall geschlossen. Durch Prüfung auf null wird der Misserfolg bei der Erzeugung des Datenstreams abgefangen. 2012, IAS 109

110 Datenstreams und Dateien ByteArrayInputStream und CharArrayReader lesen Byte-(Zeichen-)Arrays aus dem Speicher Beispiel byte[] bbuffer = new byte[256]; fillbuffer(bbuffer); // Puffer (Datenquelle) // irgendwie füllen InputStream s = new ByteArrayInputStream(bbuffer); // Erstellen(!) eines Streams StringBufferInputStream und StringReader analog ByteArrayInputStream bzw. CharArrayReader, nur dass Zeichenketten statt Byte-(Zeichen-)Arrays verwendet werden. PipedInputStream und PipedReader zweiwegige Kommunikation zwischen Threads 2012, IAS 110

111 Datenstreams und Dateien PushbackInputStream und PushbackReader Parser: einzelne Bytes (Zeichen) werden zurückgeschrieben ObjectInputStream Serilisation: Umwandlung eines Objektes in einen Datenstream (zusammen mit ObjectOutputStream) FileInputStream und FileReader Datenstream aus einer Datei Beispiel Reader r = new FileReader(new File( /Pfad/datei.ext )); FileReader ist triviale Unterklasse der Klasse InputStreamReader: kapselt beliebigen Eingabestream und wandelt ihn in einen Zeichenstream um 2012, IAS 111

112 Datenstreams und Dateien SequenceInputStream ermöglicht die Bildung zusammengesetzter Datenstreams Beispiel InputStream s1 = new FileInputStream( dat1.ext )); InputStream s2 = new FileInputStream( dat2.ext )); InputStream s = new SequenceInputStream(s1, s2); Mit read() wird nacheinander aus jedem beteiligten Stream gelesen. Wird eingesetzt bei Methoden, die nur einen InputStream erwarten. 2012, IAS 112

113 Datenstreams und Dateien FilterInputStream und FilterReader zur Verarbeitung der durchfließenden Bytes (Zeichen) besitzen Unterklassen für bestimmte Verarbeitungen können verschachtelt werden Beispiel InputStream s = getinputstream(); FilterInputStream s1 = new FilterInputStream(s) Bei einer Leseoperation auf s1 wird die Anfrage an s übergeben. FilterReader ist eine abstrakte Klasse! Zwei Filtertypen (Stream/Reader) lassen sich nicht mischen. 2012, IAS 113

114 Datenstreams und Dateien BufferedInputStream und BufferedReader verwenden ein gepuffertes Byte-(Zeichen-)Array effizient, Vorauslesen von Daten möglich Beispiel (Gepufferter FileReader) Reader r = new BufferedReader(new FileReader( dat.ext )); Möglichkeit, mit readline() Zeichenzeilen zu lesen (mit \r, \n oder \r\n abgeschlossen): BufferedReader String r = new BufferedReader(new FileReader( dat.ext )); line = r.readline; // Nächste Zeile // einlesen 2012, IAS 114

115 Datenstreams und Dateien DataInputStream besitzt Methoden für komplexere Datenstreams und zum Lesen primitiver Datentypen void readfully(byte[] bbuffer) throws IOException; boolean readboolean() throws IOException; int readint() throws IOException;... String readline() throws IOException; // Zeilen lesen EOFException, wenn das Ende eines Streams erreicht wird: DataInputStream s = new DataInputStream(getAnInpStream()); try { while (true) { byte b = (byte) s.readbyte();... // b verarbeiten catch (EOFException e) {... // Ende erreicht 2012, IAS 115

116 Datenstreams und Dateien LineNumberInputStream und LineNumberReader ermöglichen eine Zeilennummerierung Beispiel LineNumberReader String r = new LineNumberReader(new FileReader( dat.ext )); line; while ((line = r.readline())!= null) {... // Zeilen verarbeiten System.out.println(r.getLineNumber() + Zeilen. ); Beim Verschachteln von Streams auf die Reihenfolge achten. Filterstreams und Puffer immer in die Mitte der Kette. Beispiel new DataInputStream(new LineNumberInputStream( new BufferedInputStream(new FileInputStream( dat.ext )))); 2012, IAS 116

117 Datenstreams und Dateien AusgabeStreams (OutputStream) und Writer Zu (fast) jedem InputStream bzw. Reader existiert ein passender OutputStream bzw. Writer. OutputStream (Writer) sind abstrakte Klassen, welche die Grundlagen der Unterklassen für das Schreiben eines Byte- Streams (Zeichen-Datenstream) in ein Ziel definieren. Writer und seine Unterklassen sind analog der Klasse OutputStream, sie benutzen nur Zeichen anstelle Bytes. Alle auf OutputStream (Writer) aufbauende Datenstream- Klassen besitzen die auf der folgenden Folie vorgestellten Methoden. 2012, IAS 117

118 Datenstreams und Dateien Ausgabestreams (OutputStream) und Writer (Forts.) Methode write(): Schreibt Bytes (Zeichen) in ein Ziel Beispiel OutputStream s = getanoutputstream(); byte[] bbuffer = new byte[256]; // beliebige Größe fill(bbuffer); // Auszugebende Daten s.write(bbuffer); weitere write() Methoden, um einen Bereich des Puffers auszugeben oder einzelne Bytes (Zeichen) zu schreiben Methode flush(): leert den Ausgabestream und schreibt alle gepufferten Daten aus Methode close(): schließt den Datenstream 2012, IAS 118

119 Datenstreams und Dateien ByteArrayOutputStream und CharArrayWriter schreibt Byte-(Zeichen-)Arrays in den Speicher Beispiel Writer w = new CharArrayWriter(); w.write( \n ); size() gibt aktuelle Anzahl Bytes (Zeichen) im geschriebenen Byte-(Zeichen-) Array an. StringWriter analog CharArrayWriter, nur dass Zeichenketten statt Zeichen-Arrays verwendet werden. PipedOutputStream und PipedWriter zweiwegige Kommunikation zwischen Threads 2012, IAS 119

120 Datenstreams und Dateien FileOutputStream und FileWriter Datenstream in eine Datei Beispiel import java.io.*; public class FileWriterBeispiel { public static void main(string[] args) { String str = "Hallo Welt.\r\n"; FileWriter fw; try { fw = new FileWriter( welt.txt"); fw.write(str); fw.close(); catch (IOException e) { System.out.println("Fehler beim Dteierstellen"); 2012, IAS 120

121 FilterOutputStream und FilterWriter zur Verarbeitung der durchfließenden Bytes (Zeichen) können verschachtelt werden BufferedOutputStream und BufferedWriter verwenden ein gepuffertes Byte-(Zeichen-)Array Writer w = new BufferedWriter(new FileWriter( dat.ext )); Möglichkeit, mit newline() systemabhängige Zeichenzeilen zu schreiben (z.b. \r, \n oder \r\n als Zeilenabschluss). DataOutputStream besitzt Methoden für komplexere Datenstreams und zum Schreiben primitiver Datentypen void void... void Datenstreams und Dateien writeboolean(boolean b) throws IOException; writeint(int i) throws IOException; writechars(string s) throws IOException; 2012, IAS 121

122 Datenstreams und Dateien PrintStream und PrintWriter für formatierte Ausgabe häufigster Einsatz: Ausdruck in die Standardausgabe System.out.println(...); // Instanz von PrintStream in der // Variablen out der Klasse // System löst keine IOException aus implementiert flush(), close(), write() implementiert verschiedene Methoden zur Ausgabe primitiver Datentypen und Zeichenketten: void print(string s); void print(char c); void print(int i); , IAS 122

123 Datenstreams und Dateien Dateien verarbeiten z.b. Öffnen, zeilenweises Lesen, Ausgeben in andere Datei DataInput DataOut String adi = new DataInputStream( new FileInputStream( in )); ado = new DataOutputStream( new FileOutputStream( out )); line; while ((line = adi.readline())!= null) { StringBuffer modifiedline = new StringBuffer(line);... // Zeile modifiedline verarbeiten ado.writebytes(modifiedline.tostring()); adi.close(), ado.close(); Einbettung in Methode notwendig, die IOException auslöst. 2012, IAS 123

124 Datenstreams und Dateien Klasse file Abstraktion eines Dateinames File-Objekt kann für eine Datei oder ein Verzeichnis stehen Konstruktor: public File(String pathname) // Dateiname inkl. Pfad public File(String parent, String child) // Pfad und Dateiname getrennt Beispiel new File("c:\\temp\\bsp.txt") Methoden zum Zugriff auf Bestandteile des Dateinames: getname(): Name der Datei bzw. des Verzeichnisses ohne Pfad getpath(): kompletter Name inklusive Verzeichnisinfo getparent(): Name des Vaterverzeichnisses... Methoden zum Zugriff auf Informationen über die Datei: lastmodified(): Zeitpunkt der letzten Änderung isdirectory(), isfile(): zur Unterscheidung Datei/Verzeichn. canwrite(): Schreibzugriff möglich? , IAS 124

125 Datenstreams und Dateien Zugriff auf Verzeichnisse weitere Methode der Klasse File, falls das Objekt ein Verzeichnis ist list(): Verzeichnisinhalt (Ergebnis vom Typ String[]) mkdir(): Unterverzeichnis erstellen... Methoden um Verzeichnisse und Dateien zu Löschen oder umzubennen: renameto(file dest): Umbenennen einer Datei delete(): Löschen einer Datei/eines Verzeichnisses , IAS 125

126 import java.io.*; import java.util.*; Datenstreams und Dateien public class FileTest { public static void main(string[] args) { File f = new File("TestFile.java"); TestFile.printFileInfo(f); f = new File(".."); TestFile.printFileInfo(f); Ausgabe verschiedener Dateiund Verzeichnisinformationen static void printfileinfo(file f) { System.out.println("Name= "+f.getname()); System.out.println("Path= "+f.getpath()); System.out.println("Parent= "+f.getparent()); System.out.println("exists= "+f.exists()); System.out.println("canWrite= "+f.canwrite()); System.out.println("isFile= "+f.isfile()); System.out.println("isDirectory= "+f.isdirectory()); if (f.isdirectory()) { String fils[] = f.list(); for (int i=0; i<fils.length; ++i) { System.out.println(" "+fils[i]); System.out.println( "lastmodified= "+(new Date(f.lastModified()))); System.out.println("length= "+f.length()); System.out.println(""); 2012, IAS 126

127 Kursüberblick Vierter Tag Teil 1: Applet-Grundlagen Teil 2: Elemente des AWT 2012, IAS 127

128 Applet-Grundlagen Applet contra Applikation Applikation eigenständiges Programm keine Beschränkungen Applet Einbettung in HTML-Seite, Ausführung im Browser kein Zugriff auf Client-Dateisystem keine Kommunikation mit anderen Netzwerk-Servern keine Ausführung anderer Programme auf dem Client-System Sandbox Applikation und Applet sind nicht unvereinbar - ein - Programm kann gleichzeitig Applikation und Applet sein 2012, IAS 128

129 Applet-Grundlagen Applet-Erstellung Applets sind immer eine Subklasse von java.applet.applet die Applet Superklasse ist Teil der AWT-Hierarchie, d.h. Applets können auf graphische Oberflächenelemente und Ereignisbehandlung zurückgreifen public class MeinApplet extends java.applet.applet {... Applets benötigen keine main()-methode die Applet-Klasse muss public deklariert werden, alle anderen Sub- und Hilfsklassen können beliebige Zugriffsrechte vereinbaren 2012, IAS 129

130 Applet-Grundlagen Applet-Methoden (1) der Lebenszyklus eines Applets besteht aus verschiedenen Aktivitäten, die jeweils durch eine eigene Methode repräsentiert sind: Initialisieren, Starten, Stoppen, Zerstören und Anzeigen Initialisieren Vorgang, bei dem das Applet geladen wird definiert grundlegendes Aussehen/Verhalten (z.b. Lesen von Parametern, Erstellen von Hilfsobjekten, Laden von Bildern) init()-methode: public void init() {... // Initialisierungaktivitaeten 2012, IAS 130

131 Applet-Grundlagen Applet-Methoden (2) Starten erfolgt nach der Initialisierung jedes Applet wird nur einmal initialisiert, kann jedoch mehrfach gestartet werden start()-methode: public void start() {... Stoppen Vorgang, wenn Benutzer Seite verlässt oder Applet manuell gestoppt wird stop()-methode: public void stop() { , IAS 131

132 Applet-Grundlagen Applet-Methoden (3) Zerstören Aufräumen (z.b. Resourcen freigeben), wenn Applet oder Browser beendet wird destroy()-methode public void destroy() {... Zeichnen bestimmt, was und wie auf den Bildschirm gezeichnet wird wird im Applet-Lebenszyklus sehr häufig aufgerufen paint()-methode public void paint(graphics g) {... benötigt Argument: Objekt der Klasse java.awt.graphics 2012, IAS 132

133 Applet-Grundlagen Graphiken (1) Graphikoperationen sind in meistens Methoden der java.awt.graphics-klasse jedes Applet verfügt über ein Koodinatensystem die Koordinaten werden in Pixel (Integerwerte) angegeben Ursprung (0,0) X (10,10) (30,20) Y 2012, IAS 133

134 Applet-Grundlagen Graphiken (2) Linien werden mit drawline() gezeichnet: g.drawline( x1, y1, x2, y2 ); Anfangspunkt Endpunkt Rechtecke werden mit drawrect() oder fillrect() gezeichnet: g.drawrect( x1, y1, dx, dy ); Ausdehnung Polygone werden mit drawpolygon() oder fillpolygon() gezeichnet: int x[] = { x1, x2, x3, x4 ; int y[] = { y1, y2, y3, y4 ; int punkte = x.length; g.drawpolygon( x, y, punkte ); 2012, IAS 134

135 Applet-Grundlagen Graphiken (3) Polygone werden automatisch geschlossen. Für offene Polygone steht die Methode drawpolyline() zur Verfügung: int x[] = { x1, x2, x3, x4 ; int y[] = { y1, y2, y3, y4 ; int punkte = x.length; g.drawpolyline( x, y, punkte ); Ovale werden mit drawoval() oder filloval() gezeichnet: g.drawoval( x1, y1, dx, dy ); Bögen werden mit drawarc() oder fillarc() gezeichnet: g.drawarc( x1, y1, dx, dy, start, grad ); umgebendes Rechteck Startwinkel überstrichener Winkel , IAS 135

136 Applet-Grundlagen Graphiken (4) mit copyarea() wird ein rechteckiger Bereich in eine andere Position (transx, transy) kopiert g.copyarea( x1, y1, dx, dy, transx, transy ); mit clearrect() wird ein Bereich auf die aktuelle Hintergrundfarbe gesetzt g.clearrect( x1, y1, dx, dy ); mit Hilfe der size()-methode wird das gesamte Applet gelöscht g.clearrect( 0, 0, size().width, size().height ); 2012, IAS 136

137 Applet-Grundlagen Graphiken (5) Beispiel: // Graphik-Beispiel import java.awt.*; public class Grafik extends java.applet.applet { public void paint( Graphics g ) { g.drawline(80, 20, 80, 140); g.drawline(20, 80, 140, 80); g.drawrect(40, 70, 20, 20); g.drawrect(100, 70, 20, 20); g.filloval(70, 70, 20, 20); g.drawoval(50, 50, 60, 60); g.drawarc(20, 20, 120, 120, 90, 90); g.drawarc(20, 20, 120, 120, 0, -90); 2012, IAS 137

138 Applet-Grundlagen Graphiken (6) Beispiel (Forts.): 2012, IAS 138

139 Applet-Grundlagen Text & Schrift (1) im Zusammenhang mit Text und Schriften sind zwei Klassen wichtig: java.awt.font bestimmt Schriftart, Stil, Punktgröße java.awt.fontmetrics zusätzliche Informationen über die aktuelle Schriftart neue Schriften werden vor der Benutzung instanziiert: Font f = new Font( TimesRoman, Font.BOLD, 24); Schriftart Fontstil Schriftgröße Courier Font.PLAIN (in Punkten) Helvetica Font.ITALIC prinzipiell können alle auf einem System installierten Schriften verwendet werden, Standardschriften sind jedoch vorzuziehen 2012, IAS 139

140 Applet-Grundlagen Text & Schrift (2) mit drawstring() bzw. drawchar() werden einzelne Strings und Zeichen ausgegeben Beispiel: public void paint( Graphics g ) { Font f = new Font( TimesRoman, Font.BOLD, 32); g.setfont(f); g.drawstring(, 40, 40); die Klasse FontMetrics liefert spezifische Informationen über die aktuelle Schriftart stringwidth(string): volle Breite des Strings in Pixel charwidth(): Breite eines bestimmten Zeichens getleading(): Freiraum zwischen zwei Zeilen getheight(): Gesamthöhe der Schriftart 2012, IAS 140

141 Applet-Grundlagen Text & Schrift (3) Beispiel // Zentrieren eines Strings im Applet import java.awt.*; public class Zentriert extends java.applet.applet { public void paint( Graphics g ) { Font f = new Font( TimesRoman, Font.PLAIN, 32); FontMetrics fm = getfontmetrics(f); g.setfont(f); String s = im Zentrum! ; int xstart = (getsize().width - fm.stringwidth(s))/2; int ystart = getsize().height / 2; g.drawstring( s, xstart, ystart ); 2012, IAS 141

142 Applet-Grundlagen Farben (1) Farbmodell die Klasse java.awt.color bietet Unterstützung bei der Arbeit mit Farben das Farbmodell in verwendet 24-Bit-Farben, wobei jede Farbe eine Kombination aus Rot-, Grün- und Blauwerten ist, z.b. Weiß: (255, 255, 255) Blau: (0, 0, 255) das Farbmodell wird auf die Systemmöglichkeiten abgebildet zur Arbeitserleichterung ist ein Set von Standardfarben vordefiniert: Color.white Color.black... eigene Farben können jederzeit definiert werden: Color meinefarbe = new Color( 7, 242, 128 ); 2012, IAS 142

143 Applet-Grundlagen Farben (2) Farben verwenden eine neue Farbe wird vor der Benutzung für Text/Zeichnungen eingerichtet g.setcolor( Color.green ); die Hinter- und Vordergrundfarbe für ein Applet kann eingestellt werden setbackground( Color.green ); setforeground( Color.white ); mit entsprechenden get-methoden kann die aktuelle Farbe sowie die Hinter- und Vordergrundfarbe abgefragt werden getbackground(); getforeground(); 2012, IAS 143

144 Applet-Grundlagen Bilder (1) mit den Methoden der Klasse java.awt.image können Bilder geladen und in einem Applet angezeigt werden Bilder laden mit getimage() wird ein Bild als Image-Objekt geladen Image img = getimage( new URL( )); um absolute Pfadangaben zu vermeiden kann getdocumentbase() oder getcodebase() verwendet werden Image img = getimage( getdocumentbase(), files/imi01.gif ); unterstützt z. Zt. nur Bilder im GIF oder JPEG Format 2012, IAS 144

145 Applet-Grundlagen Bilder (2) Bilder zeichnen die Ausgabe des Bildes im Applet erfolgt mit der drawimage()-methode g.drawimage( img, 20, 20, this ); Bildpunkt links oben durch zusätzliche Angabe einer gewünschten Breite und Höhe nach der Angabe des linken oberen Bildpunktes kann eine Skalierung/Verzerrung erreicht werden die Orginaldimension des Bildes wird mit getwidth() und getheight() ermittelt int bildbreite = img.getwidth(this); int bildhoehe = img.getheight(this); 2012, IAS 145

146 Applet-Grundlagen Bilder (3) Beispiel: // Text und Bilder import java.awt.*; public class IAS extends java.applet.applet { Image logo; public void init() { logo = getimage( getcodebase(), "ias.gif"); setbackground( Color.white ); public void paint( Graphics g ) { g.setcolor( Color.red ); Font f = new Font( "TimesRoman", Font.BOLD, 36 ); g.setfont(f); g.drawstring( " ", 20, 40 ); int iwidth = logo.getwidth( this ); int iheight = logo.getheight( this ); g.drawimage( logo, 40, 60, iwidth, iheight, this ); 2012, IAS 146

147 Applet-Grundlagen Bilder (4) Beispiel (Forts.) 2012, IAS 147

148 Applet-Grundlagen Ereignisse & Interaktivität (1) Ereignisse sind eine wichtige Kommunikationsform in der Computerwelt für -Programme sind Ereignisse interessant, die vom Benutzer oder System verursacht werden: Mausklicks Mausbewegungen Tastaturanschläge Ereignisse der Benutzeroberfläche Fensterereignisse unterstützt z.zt. in der AWT zwei verschiedene Ereignismodelle: JDK 1.02 seit JDK 1.1 Event-Listener-Konzept 2012, IAS 148

149 Applet-Grundlagen Ereignisse & Interaktivität (2) JDK 1.02 alle Ereignisse werden in einer einzigen handleevent()- Methode behandelt Applet Ereignis: Maustaste gedrückt handleevent() mousedown() Ereignis: Taste gedrückt keydown() weiterleiten 2012, IAS 149

150 Applet-Grundlagen Ereignisse & Interaktivität (3) ab JDK 1.1 Applet Fensterereignis init()... initialize applet... register mouse listener... initialize button... register buttonaction listener Mausereignis Tastenereignis Registriert mouse listener Registriert actions listener Schaltflächenereignis 2012, IAS 150

151 Applet-Grundlagen JDK Ereignismodell (1) Das Verwenden von Ereignissen in einem Applet erfolgt nach festgelegten Spielregeln: Schritt 1: entscheiden, welche Ereignisse für das Applet wichtig sind und zugehörige Listener-Typen herausfinden Schritt 2: Code für diese Listener und die Ereignisverarbeitung erstellen Schritt 3: Listener mit Applet registrieren 2012, IAS 151

152 Applet-Grundlagen JDK Ereignismodell (2) Schritt 1: Ereignisse und Listener-Schnittstellen die API-Dokumentation gibt Auskunft über Ereignisse und ihre zugehörigen Listener-Schnittstellen Listener-Interface Ereignis Definition (alle public void) MouseListener mousedown mousepressed (MouseEvent e) mouseup mousereleased (MouseEvent e) mouseenter mouseentered (MouseEvent e) mouseexit mouseexited (MouseEvent e) mouseclicks mouseclicked (MouseEvent e) MouseMotion- mousemove mousemoved (MouseEvent e) Listener mousedrag mousedragged (MouseEvent e) KeyListener keyup keyreleased (KeyEvent e) keydown keypressed (KeyEvent e) keytyped keytyped (KeyEvent e) 2012, IAS 152

153 Applet-Grundlagen JDK Ereignismodell (3) Schritt 2: Listener-Schnittstellen implementieren der Ereignis-Listener ist eine Klasse, die die Listener- Schnittstelle implementiert Schnittstellen-Implementierung kann auf zwei Arten erfolgen: zu (A): (A) separate Listener-Klasse: elegante Lösung für größere Programme (B) Listener wird direkt in der Applet-Klasse implementiert: schnelle Lösung für kleinere Applets separate Listener-Klasse muss Schnittstelle vollständig implementieren für viele Listener stehen in java.awt.event sog. Adapterklassen mit Default-Implementierungen zur Verfügung, z.b.: MouseAdapter für MouseListener MouseMotionAdapter für MouseMotionListener KeyAdapter für KeyListener 2012, IAS 153

154 Applet-Grundlagen JDK Ereignismodell (4) Schritt 2 (Forts.): Listener-Schnittstellen implementieren zu (A): von den Listener-Adapterklassen werden eigene Listener- Klassen abgeleitet, welche die relevanten Ereignisbehandlungs-Methoden (z.b. mousepressed()) überschreiben import java.awt.event.*; class MeinMausListener extends MouseAdapter { public void mousepressed( MouseEvent e ) { , IAS 154

155 Applet-Grundlagen JDK Ereignismodell (5) Schritt 2 (Forts.): Listener-Schnittstellen implementieren zu (B): das Applet ist sein eigener Event-Listener: import java.awt.event.*; public class MeinApplet extends java.applet.applet implements MouseListener, KeyListener { // Ereignisbehandlung public void mousepressed( MouseEvent e ) {... // Leer-Implementierungen der Schnittstelle public void mousereleased( MouseEvent e ) {... Wichtig: gesamte Schnittstelle muss implementiert werden 2012, IAS 155

156 Applet-Grundlagen JDK Ereignismodell (6) Schritt 3: Listener registrieren Verbindung zwischen Listener und Applet mit Registrierungsmethoden herstellen: addmouselistener(); addmousemotionlistener(); addkeylistener(); für separate Listener-Klasse m1 = new MeinMausListener(); addmouselistener( m1 ); Applet ist Listener addmouselistener( this ); 2012, IAS 156

157 Applet-Grundlagen Mausereignisse (1) Beispiel: folgendes Applet zeichnet gerade Linien auf den Bildschirm durch Ziehen der Maus vom Anfangs- zum Endpunkt. Es können maximal 10 Linien gezeichnet werden. // Linien.java import java.awt.*; import java.awt.event.*; public class Linien extends java.applet.applet implements MouseListener, MouseMotionListener { final int MAXLINES = 10; Point starts[] = new Point[MAXLINES]; // Startpunkte Point ends[] = new Point[MAXLINES]; // Endpunkte Point anchor; // Start aktuelle Linie Point currentpoint; // Ende aktuelle Linie int currline = 0; // Anzahl Linien 2012, IAS 157

158 Applet-Grundlagen Mausereignisse (2) Beispiel (Forts.) public void init() { setbackground( Color.white ); // Event-Listener registrieren addmouselistener( this ); addmousemotionlistener( this ); // Leerimplementierungen der Schnittstellen public void mousemoved( MouseEvent e) { public void mouseclicked( MouseEvent e) { public void mouseentered( MouseEvent e) { public void mouseexited( MouseEvent e) { public void mousepressed( MouseEvent e ) { if( currline < MAXLINES ) anchor = new Point( e.getx(), e.gety() ); else System.out.println( "Too many lines..." ); 2012, IAS 158

159 Applet-Grundlagen Mausereignisse (3) Beispiel (Forts.) public void mousereleased( MouseEvent e ) { if( currline < MAXLINES ) addline( e.getx(), e.gety() ); public void mousedragged( MouseEvent e ) { if( currline < MAXLINES ) { currentpoint = new Point( e.getx(), e.gety() ); repaint(); void addline( int x, int y ) { starts[currline] = anchor; ends[currline] = new Point(x, y); currline++; currentpoint = null; anchor = null; repaint(); 2012, IAS 159

160 Applet-Grundlagen Mausereignisse (4) Beispiel (Forts.) public void paint( Graphics g ) { for ( int i = 0; i < currline; i++ ) { g.drawline( starts[i].x, starts[i].y, ends[i].x, ends[i].y ); g.setcolor( Color.blue ); if( currentpoint!= null ) g.drawline( anchor.x, anchor.y, currentpoint.x, currentpoint.y); // Linien-Applet Ende 2012, IAS 160

161 Applet-Grundlagen Mausereignisse (5) Beispiel (Forts.) 2012, IAS 161

162 Applet-Grundlagen Zusammenfassung Unterschied Applet - Applikation Applet-Aktivitäten: Initialisieren, Starten, Stoppen, Zerstören, Anzeigen einfache Graphikoperationen: Linien, Rechtecke,... Umgang mit Schriften Applet-Farben Bilder in Applets Ereignismodelle 1.1 und 1.02 Ereignisbehandlung in 2012, IAS 162

163 Kursüberblick Vierter Tag Teil 1: Applet-Grundlagen Teil 2: Elemente des AWT 2012, IAS 163

164 Elemente des AWT AWT-Übersicht AWT bietetet eine Vielzahl von Komponenten für graphische Benutzeroberflächen AWT-Elemente können in Containern verschachtelt werden wichtige AWT-Komponenten Container ermöglichen Verschachtelungen, sie können konkrete Komponenten oder andere Container enthalten. Häufigster Vertreter: Panel (Applet ist von Panel abgeleitet) Canvas ist ein Zeichenbereich zur Erstellung von Graphiken GUI-Komponenten, wie z.b. Labels, Schaltflächen, Listenfelder, Textfelder, Kontrollfelder, u.s.w. Fensterkomponenten, wie z.b. Fenster, Rahmen, Menüleisten, Dialogfelder alle Elemente sind als Klassenhierarchie im java.awt-paket organisiert 2012, IAS 164

165 Elemente des AWT AWT- Label (1) Label: nicht-editierbare Zeichenkette, die zur Beschriftung anderer Komponenten dient Vorteile von Labels (gegenüber drawstring()): keine paint()-anweisungen notwendig automatische Layout-Anpassungen Label-Konstruktoren: Label() erzeugt leeres, links ausgerichtetes Label Label( String ) erzeugt Label mit Zeichenkette Label( String, int ) ermöglicht Ausrichtung mit Hilfe von Label-Klassenvariablen Label.RIGHT, Label.LEFT, Label.CENTER die Schrift des Labels kann mit setfont() beliebig geändert werden 2012, IAS 165

166 Elemente des AWT AWT- Label (2) Beispiel import java.awt.*; public class LabelTest extends java.applet.applet { public void init() { setfont( new Font( Helvetica, Font.BOLD, 16)); setlayout( new GridLayout( 3, 1 )); add( new Label( linksgerichtet, Label.LEFT)); add( new Label( zentriert, Label.CENTER)); add( new Label( rechtsgerichtet, Label.RIGHT)); Label-Methoden: gettext() gibt die Zeichenkette des Labels aus settext(string) ändert den Label-Text getalignment() gibt die Ausrichtung des Label als Integer zurück: 0 (links), 1 (zentriert) oder 2 (rechts) setalignment(int) ändert die Label-Ausrichtung 2012, IAS 166

167 Elemente des AWT AWT - Schaltflächen Schaltfläche (Button): kann mit der Maus angeklickt werden und Aktionen auslösen Konstruktoren: Button() erzeugt Schaltfläche ohne Beschriftung Button( String ) erzeugt Schaltfläche mit String als Beschriftung Methoden: getlabel() gibt die Beschriftung der Schaltfläche zurück Beispiel setlabel( String ) beschriftet die Schaltfläche mit String public class ButtonTest extends java.applet.applet { public void init() { add( new Button( OK )); add( new Button( Cancel )); 2012, IAS 167

168 Elemente des AWT AWT - Kontrollfelder Kontrollfelder (Checkbox) stellen Optionen bereit, die gewählt oder nicht gewählt werden können. Die Optionen schließen sich nicht gegenseitig aus (Mehrfachauswahl möglich) Konstruktoren: Checkbox() erzeugt unbeschriftetes, nicht gewähltes Kontrollfeld Checkbox( String ) erzeugt Kontrollfeld mit String- Beschriftung Checkbox( String, boolean ) erzeugt beschriftetes Kontrollfeld, welches ausgewählt (true) oder nicht ausgewählt (false) ist Methoden: getlabel() gibt Feldbeschriftung aus setlabel( String ) ändert Feldbeschriftung getstate() gibt true oder false (je nach Selektion) aus setstate(boolean) ändert Auswahlstatus des Kontrollfeldes 2012, IAS 168

169 Elemente des AWT AWT - Optionsfelder Optionsfelder (CheckboxGroup) sind ähnlich wie Kontrollfelder, es kann allerdings nur eine Option gewählt werden. Die einzelnen Optionen werden in einer CheckboxGroup gruppiert Beispiel public void init() { setlayout( new FlowLayout( FlowLayout.LEFT )); CheckboxGroup cbg = new CheckboxGroup(); add( new Checkbox( Rot, false, cbg)); add( new Checkbox( Gruen, false, cbg)); add( new Checkbox( Blau, true, cbg)); Methoden: getcheckboxgroup() gibt das aktuelle Optionsfeld zurück setcheckboxgroup(checkboxgroup) setzt aktuelles Optionsfeld getselectedcheckbox() gibt aktuell angewähltes Option zurück setselectedcheckbox(checkbox) wählt die gewünschte Option an 2012, IAS 169

170 Elemente des AWT AWT - Auswahlmenüs Auswahlmenüs (Choice) sind Pop-Up-Listen, aus denen ein Listenelement ausgewählt werden kann Beispiel public void init() { Choice c = new Choice(); c.add( ); c.add( C++ ); c.add( Ada95 ); add( c ); Methoden: getitem( int ) gibt Zeichenkette der gewählten Stelle (0,...) aus getitemcount() gibt die Anzahl der Menüelemente aus getselectedindex() gibt Index des gewählten Elements zurück getselecteditem() gibt Zeichenkette des gewählten Elements zurück select( int ) wählt Element an der angegebenen Stelle select( String ) wählt Element mit der angegebenen Zeichenkette 2012, IAS 170

171 Elemente des AWT AWT - Textfelder (1) Textfelder (TextField) stellen editierbaren Bereich für die Eingabe einer Textzeile zur Verfügung Konstruktoren: TextField() erzeugt leeres Textfeld TextField( String ) erzeugt mit Zeichenkette initialisiertes Textfeld, Breite wird durch aktuellen Layout-Manager vorgegeben TextField( String, int ) erzeugt initialisiertes Textfeld mit vorgegebener Breite (Zeichen) TextField tf = new TextField( Erstes Textfeld, 30); add( tf ); zur Beschriftung des Textfeldes muss ein zusätzliches Label verwendet werden 2012, IAS 171

172 Elemente des AWT AWT - Textfelder (2) Methoden: gettext() gibt Text als Zeichenkette aus settext( String ) setzt Zeichenkette in das Feld getcolumns() gibt Breite des Textfeldes aus select( int, int ) wählt Text zwischen beiden Positionen aus selectall() wählt den gesamten Text aus iseditable() gibt aus, ob Text editierbar ist (true/false) seteditable( boolean ) ermöglicht (true) oder verbietet (false) editieren des Textes Beispiel public void init() { setlayout( new GridLayout( 1, 2, 5, 15 ) ); add( new Label( Name: ) ); add( new TextField( Ihren Namen bitte, 40) ); 2012, IAS 172

173 Elemente des AWT Layout-Manager jedes Applet (Panel) kann konkrete Komponenten oder weitere Panels enthalten ein Layout-Manager bestimmt, wie die AWT-Elemente in einem Panel dynamisch angeordnet werden jedes Panel kann einen eigenen Layout-Manager besitzten das AWT beinhaltet fünf verschiedene Layout-Manager: FlowLayout, GridLayout, BorderLayout, CardLayout und GridBagLayout ein Manager wird in einem Panel verwendet, indem a) eine Instanz einer Layout-Manager-Klasse gebildet wird und b) die setlayout()-methode für das umgebende Panel aufgerufen wird die Reihenfolgen, in der AWT-Elemente in das Layout eingefügt werden (add()-methode), ist entscheidend für ihre Positionierung 2012, IAS 173

174 Elemente des AWT FlowLayout das FlowLayout ordnet die Komponenten zeilenweise von links nach rechts an. Passt eine Komponente nicht in die Zeile, wird automatisch eine neue Zeile begonnen die zentrierte Zeilenausrichtung kann mit den Klassenvariablen FlowLayout.RIGHT und FlowLayout.LEFT verändert werden der horizontale und vertikale Abstand kann durch zwei Integer-Argumente angegeben werden Beispiel import java.awt.*; public class FlowTest extends java.applet.applet { public void init() { setlayout(new FlowLayout(FlowLayout.LEFT, 20, 20)); add(new Button("Eins")); add(new Button("Zwei")); add(new Button("Drei")); add(new Button("Vier")); 2012, IAS 174

175 Elemente des AWT GridLayout bei GridLayout wird das Panel in Zeilen und Spalten unterteilt. Die Komponenten werden von links nach rechts und von oben nach unten eingefügt auch hier können zusätzliche horizontale und vertikale Abstände zwischen den Komponenten angegeben werden Beispiel import java.awt.*; public class GridTest extends java.applet.applet { public void init() { setlayout(new GridLayout(2, 2, 3, 10)); add(new Button("Eins")); add(new Button("Zwei")); add(new Button("Drei")); add(new Button("Vier")); 2012, IAS 175

176 Elemente des AWT BorderLayout beim BorderLayout werden Komponenten mit Hilfe von geographischen Angaben (North, East, South, West, Center) angeordnet Beispiel import java.awt.*; public class BorderTest extends java.applet.applet { public void init() { setlayout(new BorderLayout(5, 10)); add("north", new Button("Eins")); add("east", new Button("Zwei")); add("south", new Button("Drei")); add("west", new Button("Vier")); 2012, IAS 176

177 Elemente des AWT Card- und GridBagLayout die Karten in einem CardLayout sind unterschiedliche Panels, die nacheinander eingefügt und angezeigt werden. Es kann jeweils nur eine Karte angezeigt werden, aber man kann zwischen den Karten wechseln das GridBagLayout ist der mächtigste, aber auch der komplizierteste Layout-Manager - er ermöglicht die Anordnung der Komponenten in einem rasterähnlichen Layout im GridBagLayout kann zusätzlich die Weite der einzelnen Zellen, sowie die Proportionen zwischen Zeilen und Spalten kontrolliert werden die Fähigkeiten des GridBag-Manager können meistens durch Verschachteln einfacherer Manager nachgebildet werden 2012, IAS 177

178 Elemente des AWT Listener für GUI-Komponenten (1) Listener-Interface Ereignis Definition (alle public void) ActionListener Aktion actionperformed(actionevent e) ItemListener Liste itemstatechanged(itemevent e) gewählt FocusListener Fokuserhalt focusgained(focusevent e) Fokusverlust focuslost(focusevent e) TextListener Text geändert textvaluechanged(textevent e) die meisten dieser Listener-Schnittstellen (bis auf FocusListener) besitzten keine Adapterklassen, d.h. die Schnittstellen müssen von Hand implementiert werden 2012, IAS 178

179 Elemente des AWT Listener für GUI-Komponenten (2) bei der Implementierung der Listener-Schnittstelle kann mit Hilfe der getsource()-methode eine Referenz auf die Komponente ermittelt werden, die das Ereignis erhalten hat public void actionperformed( ActionEvent e ){ Button ursprung = e.getsource(); if( ursprung.getlabel().equals( OK )) { // Behandlung von OK else if( ursprung.getlabel().equals( Cancel )) { // Behandlung von Cancel Listener werden durch spezielle Methoden mit den GUI-Elementen verbunden addactionlistener(); additemlistener(); addfocuslistener(); 2012, IAS 179

180 Elemente des AWT Listener für GUI-Komponenten (3) für die Registrierung des Listeners in der init()-methode muss bei jeder empfangenden Komponente einzeln registriert werden Button OKButton = new Button( OK ); // OKButtonAction implementiert ActionListener OKButtonAction ok = new OKButtonAction(); OKButton.addActionListener( ok ); Details können der API-Dokumentation des jeweiligen Oberflächenelements oder der Schnittstelle entnommen werden 2012, IAS 180

181 Elemente des AWT Listener für GUI-Komponenten (4) Beispiel import java.awt.*; import java.awt.event.*; public class MultiListener extends java.applet.applet implements ActionListener { TextArea lefttextarea; TextArea righttextarea; Button button1, button2; public void init() { GridLayout gridbag = new GridLayout(3, 2, 5, 5); setlayout(gridbag); Label l = new Label("Das Applet hoert:"); add(l); Label r = new Label("Die externe Klasse hoert:"); add(r); 2012, IAS 181

182 Elemente des AWT Listener für GUI-Komponenten (5) Beispiel (Forts.) lefttextarea = new TextArea(5, 20); lefttextarea.seteditable(false); add(lefttextarea); righttextarea = new TextArea(5, 20); righttextarea.seteditable(false); add(righttextarea); button1 = new Button("Schaltflaeche 1"); add(button1); button2 = new Button("Schaltflaeche 2"); add(button2); button1.addactionlistener(this); button2.addactionlistener(this); button2.addactionlistener(new ExtListener(rightTextArea)); // Ende init()-methode 2012, IAS 182

183 Elemente des AWT Listener für GUI-Komponenten (6) Beispiel (Forts.) public void actionperformed(actionevent e) { lefttextarea.append(e.getactioncommand() + "\n"); // Ende MultiListener-Klasse class ExtListener implements ActionListener { TextArea mytextarea; public ExtListener(TextArea ta) { mytextarea = ta; public void actionperformed(actionevent e) { mytextarea.append(e.getactioncommand() + "\n"); 2012, IAS 183

184 Elemente des AWT Listener für GUI-Komponenten (7) 2012, IAS 184