Fortgeschrittene Konzepte

Transkript

1 Java: Kapitel 4 Fortgeschrittene Konzepte Programmentwicklung WS 2008/2009 Holger Röder holger.roeder@informatik.uni-stuttgart.de

2 Überblick über Kapitel 4 Autoboxing Erweiterte for-schleife Aufzählungen Ausnahmebehandlung Generische Klasn Reflection Annotationen Garbage Collection 2

3 Autoboxing Zu jedem primitiven Datentyp existiert in Java eine Wrapper-Klas (int: Integer, char: Character, byte: Byte etc.), die den jeweiligen Datentyp in einem Objekt aufnehmen. Autoboxing: primitive Datentypen und Wrapper-Objekte werden bei Bedarf implizit ineinander umgewandelt: Integer i = 3; // Boxing, int -> Integer int j = i; // Unboxing, Integer -> int Damit sind in Verbindung mit variablen Parameterlisten Methoden möglich, die beliebige Parameter beliebigen Typs akzeptieren: public void print(object... o) {... for (int i = 0; i < o.length; i++) System.out.println("Parameter: "+ o[i]); print("hallo",3, 17.2, new Integer(4), 'x', fal); 3

4 Erweiterte for-schleife Seit Java 5 existiert eine erweiterte for-schleife mit folgender Syntax: for (formalerparameter: ausdruck) anweisung; Dabei gilt: formalerparameter ist eine Parameterdeklaration, z. B. String s ausdruck implementiert die Schnittstelle java.lang.iterable (wie z. B. die Listenklasn aus der Standardbibliothek) oder ist ein []-Array String[] texte = new String[3]; texte[0] = "Hallo "; texte[1] = "Welt"; texte[2] = "!"; /* "Neue" Variante (mit Array): */ for(string s: texte) { System.out.print(s); 4

5 Aufzählungen Mit dem Schlüslwort enum können Aufzählungen definiert werden: public enum Farbe { ROT, GELB, GRUEN Aufzählungen sind Klasn, jedes Element einer Aufzählung ist ein Objekt. Farbe f1 = Farbe.GELB; Standard-Methoden erlauben das Arbeiten mit Aufzählungsklasn und Aufzählungsobjekten. int i = f1.ordinal(); // liefert 1 (ROT=0, BLAU=2) String s = f1.tostring(); // liefert "GELB" boolean b = f1.equals(farbe.gelb); // liefert true Farbe f2 = Farbe.valueOf("ROT"); // ok Farbe f3 = Farbe.valueOf("BLAU"); // Exception! 5

6 Aufzählungen in switch-anweisungen Aufzählungen können in switch-anweisungen unterschieden werden: Farbe f1 = Farbe.GELB;... switch (f1) { ca GELB: System.out.println("Farbe ist GELB."); break; ca GRUEN: System.out.println("Farbe ist GRÜN"); break; 6

7 Ausnahmebehandlung: Exceptions In Java werden Ausnahmen (Exceptions) zur Fehlerbehandlung verwendet. Viele Methoden der Java-Standardbibliothek werfen im Fehlerfall eine Exception. Grundsätzlich gilt: Tritt eine Exception auf, muss sie entweder lokal behandelt oder weitergegeben werden. Sonderfall: Ausnahmen vom Typ RuntimeException (z. B. NullPointerException) können, müsn aber nicht behandelt oder weitergegeben werden. Für die lokale Ausnahmenbehandlung können Exceptions in einem (try-)catch-block gefangen werden: try { double d = Double.parDouble("Hallo"); System.out.println("Alles ok!"); // nie erreicht! catch (NumberFormatException e) { System.out.println("Ungültiges Zahlenformat"); 7

8 Behandlung von Exceptions Verschiedene Exceptions können über nacheinander folgende catch- Blöcke gefangen werden. Der Typ der geworfenen Exception wird mit dem Typ der zu fangenden Exception verglichen. Bei Übereinstimmung wird zum jeweiligen catch-block gesprungen. Der (optionale) finally-block wird immer aufgerufen (egal, ob eine Exception bearbeitet wurde oder nicht). try { //... Hier können Exceptions geworfen werden... catch(ioexception e) { System.out.println("IO-Fehler: " + e.getmessage()); catch(exception e) { System.out.println("Fehler: " + e.getmessage()); finally { System.out.println("Programmende"); Anschließend fährt das Programm mit der ersten Anweisung nach dem try-catch-(finally-)-abschnitt fort. 8

9 Weitergabe von Exceptions Wenn die Ausnahmenbehandlung nicht lokal erfolgen soll, können Exceptions an die aufrufende Methode weitergegeben werden. Dazu muss der Methodenkopf mit einer throws-klaul und der Liste aller möglicherwei weitergegebenen Exceptions erweitert werden: import java.io.*;... public String liesein() throws IOException { BufferedReader in = new BufferedReader(new InputStreamReader(System.in)); String eingabe = in.readline(); return eingabe; Wird eine Exception geworfen, wird die an die aufrufende Methode weitergegeben. Weitergegebene Exceptions müsn in der aufrufenden Methode behandelt oder ebenfalls weitergegeben werden. 9

10 Kombination von Behandlung und Weitergabe Lokale Behandlung von Ausnahmen und Weitergabe können kombiniert werden, wenn innerhalb eines catch-blocks die gefangene Exception mit throw weitergegeben wird. public double lieszahl() throws IOException, NumberFormatException {... try { String eingabe = in.readline(); catch (IOException e) { System.out.println("Fehler bei der Eingabe!"); throw e; Zunächst lokale Fehlerbehandlung... dann Weitergabe der Exception 10

11 Eigene Exceptions Auftretende Ausnahmen werden durch Objekte vom Typ Exception (oder einer Unterklas) repräntiert. Eigene Ausnahmen können als Unterklasn der Klas Exception erstellt werden. MeineException.java public class MeineException extends Exception { public int fehlercode;... Exceptions können mit der throw-anweisung geworfen werden: MeineException e = new MeineException(); e.fehlercode = 127; throw e; 11

12 Generische Klasn Generische Klasn (Generics) können verwendet werden, um eine Implementierung, die prinzipiell alle Klasn unterstützt, typsicher auf die Verwendung mit bestimmten Klasn zu beschränken. Beispiel: Datenspeicher für 1 Element IntegerSpeicher.java public class IntegerSpeicher { private Integer element; public void put(integer e) { element = e; public Integer get() { return element; Doppelter Code! StringSpeicher.java public class StringSpeicher { private String element; public void put(string e) { element = e; public String get() { return element; 12

13 Generische Klasn (2) Implementierung als generische Klas: T dient als Platzhalter und wird bei der Deklaration und Initialisierung durch einen konkreten Typ ertzt. Aufruf: Speicher<Integer> i = new Speicher<Integer>(); i.put(new Integer(42)); Speicher<String> s = new Speicher<String>(); s.put("ein String"); Speicher.java public class Speicher<T> { private T element; public void put(t e) { element = e; public T get() { return element; // s.put(new Integer(42)); // unzulässig, nur Strings! 13

14 Generische Klasn Polymorphie Erinnerung: Polymorphie bei normalen Klasn class A {... class B extends A {... // abgeleitete Klas... B b_obj = new B(); A a_obj = b_obj; // zulässig, Polymorphie Eine analoge Zuweisung mit generischen Klasn, die mit Ober- und Unterklasn typisiert sind, ist jedoch nicht zulässig: Speicher<B> b_speicher = new Speicher<B>; Speicher<A> a_speicher = b_speicher; // nicht zulässig! Wäre die letzte Anweisung zulässig, könnte beispielswei folgende Typinkompatibilität auftreten: a_speicher.put(new A()); B obj1 = b_speicher.get(); /* B-Objekt erwartet, aber A-Objekt im Speicher! */ 14

15 Generische Klasn Einschränkungen Die Information über die Typisierung generischer Klasn ist zur Laufzeit nicht bekannt (Type Erasure). Bei der Verwendung gibt es deshalb Einschränkungen. Der instanceof-operator ist bei generischen Klasn nur zur Prüfung der untypisierten generischen Klas erlaubt. if (b_speicher instanceof Speicher) {... // erlaubt! if (b_speicher instanceof Speicher<B>) {... // nicht erlaubt! Ebenso gilt: Parametrisierte Exception-Typen sind nicht erlaubt. Arrays parametrisierter Typen (Speicher<B>[] ) sind nicht erlaubt. 15

16 Generische Klasn Wildcards Die Wildcard? kann bei der Typisierung generischer Klasn anstelle eines konkreten Typs angegeben werden: Speicher<B> b_speicher = new Speicher<B>; Speicher<?> o_speicher = b_speicher; Bei Verwendung der Wildcard? sind Methoden, die einen generisch typisierten Rückgabewert haben, nur noch mit Object typisiert: Object obj2 = o_speicher.get(); // ok, liefert Object B obj3 = o_speicher.get(); // nicht ok! Der Aufruf von Methoden mit generisch typisierten Parametern ist nicht mehr erlaubt: o_speicher.put(new Object()); // nicht zulässig! 16

17 Generische Klasn Bounded Wildcards Gebundene Wildcards (bounded wildcards) erlauben die Typisierung mit der angegebenen Klas oder einer Unterklas: Speicher<B> b_speicher = new Speicher<B>; Speicher<? extends A> a_speicher = b_speicher; Der Aufruf von Methoden mit generisch typisierten Parametern (z. B. Schreiboperationen) ist ebenfalls nicht erlaubt: A obj4 = a_speicher.get(); // Len ok a_speicher.put(new A()); // Schreiben nicht ok! Mit dem Schlüslwort super können gebundene Wildcards mit unteren Grenzen definiert werden: Speicher<? super B> speicher =... /* kann mit B oder Oberklas von B typisiert werden */ 17

18 Generische Methoden Auch einzelne Methoden können Typen generisch vorschreiben: Auswahl.java public class Auswahl { public static <T> T zufall(t arg1, T arg2) { // zufällig einen der beiden Parameter zurückgeben return Math.random() > 0.5? arg1 : arg2;... String s = Auswahl.zufall("Hallo", "Welt"); // ok Integer i = Auswahl.zufall(2, 3); // auch ok Integer i = Auswahl.zufall("Hallo", "Welt"); // Fehler! 18

19 Reflection Das Reflection-API ermöglicht den Umgang mit Klasn und Objekten zur Laufzeit. Dazu gehören etwa: das Laden und Instanziieren von Klasn, der Aufruf von Methoden und der Zugriff auf Attribute. Reflection kommt häufig bei der Entwicklung generischer, hochkonfigurierbarer oder durch Plug-Ins erweiterbarer Anwendungen zum Einsatz (z. B. OR-Datenbank-Mapper etc.) 19

20 Reflection Class-Objekte Die Klas Class repräntiert eine Java-Klas zur Laufzeit und ermöglicht den Zugriff auf Eigenschaften der Klas. Class-Objekte können auf verschiedene Wei erhalten werden: Die Methode getclass() der Klas Object liefert ein pasndes Class-Objekt für das jeweilige Objekt. String s = "Hallo"; Class c = s.getclass(); System.out.println(c.getName()); // Ausgabe: java.lang.string Jede Klas besitzt ein statisches Class-Attribut namens class: Class c = String.class; Die statische Methode Class.forName() liefert das Class- Objekt für die angegebene Klas zurück: Class c = Class.forName("java.lang.String"); Analog zu Class existieren die Klas Method für Methodenzugriff und Field für Attributzugriff. 20

21 Reflection Beispiel public static void printmethods(string classname) throws ClassNotFoundException { Sucht Klas anhand des Klasnnamens Class c = Class.forName(className); for (Method m : c.getmethods()) { System.out.print(m.getReturnType(). getsimplename() + " "); System.out.print(m.getName() + "("); String delim = ""; for (Class param : m.getparametertypes()) { System.out.print(delim); System.out.print(param.getSimpleName()); delim = ", "; System.out.println(")"); Liefert alle Methoden der Klas 21

22 Reflection Beispiel (Ausgabe) printmethods("java.lang.string"); liefert int hashcode() int compareto(string) int compareto(object) int indexof(int, int) int indexof(int) int indexof(string) int indexof(string, int) boolean equals(object) String tostring() char charat(int) int codepointat(int) int codepointbefore(int) int codepointcount(int, int) int comparetoignoreca(string) String concat(string) boolean contains(charsequence) boolean contentequals(stringbuffer) boolean contentequals(charsequence)... 22

23 Annotationen Annotationen sind Metadaten, die im Quellcode dokumentiert werden. Sie können zum Kommentieren des Codes verwendet werden, sind aber anders als normale Kommentare Teil des Syntaxbaums. Es existiert eine Reihe vordefinierter Annotationen, z. kennzeichnet Klas/Methode als kennzeichnet überlagerte Methoden Beispiel: public class Person { public double berechnegehalt() {... public class Angestellter extends Person public double berechngehalt() {... Compiler meldet Fehler: die definierte Methode überlagert keine Methode der Oberklas! 23

24 Eigene Annotationen Die Definition eigener Annotationstypen erfolgt ähnlich wie die Definition von Schnittstellen. Damit Annotationen zur Laufzeit verfügbar sind, muss die Annotationsklas lbst entsprechend annotiert import java.lang.annotation.*; // für Reflection (Zugriff zur Autor { String vorname(); // Elemente des Annotationstyps String nachname(); String firma() default "Firma XYZ"; // Standardwert 24

25 Eigene Annotationen (2) Nach der Definition können eigene Annotationen verwendet werden. Die Elemente der Annotation werden über Schlüsl-Wert-Paare zugewien. public class Person (vorname = "Carl", nachname = "Coder") public double berechnegehalt() {... 25

26 Annotationen und Reflection Annotationen können per Reflection abgefragt werden: Person p = new Person(); for (Method m : p.getclass().getmethods()) { if (m.isannotationprent(autor.class)) { Autor autor = m.getannotation(autor.class); System.out.println("Methode '" + m.getname() + "' entwickelt von " + autor.vorname() + " " + autor.nachname()); Ausgabe: Methode 'berechnegehalt' entwickelt von Carl Coder 26

27 Garbage Collection in Java Java besitzt ein automatisches Speichermanagement. Speicher muss nicht explizit allokiert oder freigegeben werden. Objekte, die nicht mehr referenziert werden, werden automatisch (irgendwann) vom Garbage Collector gelöscht. Der Garbage Collector läuft mit niedriger Priorität im Hintergrund. Person carl = new Person(); // 1 Referenz auf das Objekt Person p1 = carl p1 = null; carl = null; // jetzt 2 Referenzen auf das Objekt // nur noch 1 Referenz auf das Objekt // Objekt ohne Referenz Vor dem Löschen eines Objekts wird jeweils die Destruktor-Methode finalize() des Objekts aufgerufen. Der Garbage Collector kann explizit gestartet werden: System.gc(); 27