Einführung in die objektorientierte Programmierung Teil 4 und Exception Handling · 2014-05-26 ·...

Patrick Förster, Michael Hasseler

Programmieren in Java

Einführung in die objektorientierte Programmierung Teil 4

und Exception Handling


Übersicht der heutigen Inhalte

• Interfaces

• Modifikatoren bei der Klassendefinition

• Exception Handling

2 Objektorientierte Programmierung


Interfaces

• Interfaces (Schnittstellen) sind vorstellbar als abstrakte Klassen, die abstrakte

public-Methoden als Elemente enthalten

• Interfaces werden mit dem Schlüsselwort implements bei einer Klasse

angegeben.

• In der Klasse müssen alle Methoden des Interfaces implementiert werden oder die

Klasse ist abstract.

• Klassen können mehrere Interfaces implementieren

• Ein Interface kann mit extends von einem oder auch mehreren Interfaces ableiten


public interface Umkehrbar { public void umkehren(); } public class Textpassage implements Umkehrbar { public void umkehren() { … } }


Trennung von Schnittstelle und Implementierung

• Allgemeines Design-Prinzip: „Programmiere gegen Schnittstellen, nicht gegen

Implementierungen.“ (Quelle: http://openbook.galileocomputing.de/oop/oop_kapitel_03_005.htm)

• Trennung ermöglicht ein einfacheres Austauschen der Implementierungen

• Ermöglicht ein Aufteilen in mehrere Arbeitspakete, die von verschiedenen

Personen parallel bearbeitet werden können.



Vergleich von Schnittstelle und abstrakter Klasse

• Schnittstelle hat als Elemente:

• Konstanten

• Methodensignaturen

• Abstrakte Klasse hat als Elemente:

• Konstanten

• Variablen

• Methodensignaturen

• ohne Methodenrumpf => abstract

• Mit Methodenrumpf => nicht abstract

• Klasse kann maximal eine abstrakte Basisklasse haben

• Klasse kann mehrere Schnittstellen implementieren



Modifikatoren und weitere Angaben bei der Klassendefinition

• Syntax bei der Klassendeklaration:

[<modifiers>] class <Klassenname> [extends <SuperklassenName>] [implements <Schnittstellenname1>, <Schnittstellenname2>, …] • Zugelassene Modifier sind:

• Keine Modifizierer: Die Klasse ist in allen Klassen desselben Pakets verfügbar

• public: Die Klasse ist auch in anderen Paketen verfügbar

• abstract: Die Klasse wird nur als Basisklasse für Subklassen verwendet

• final: Die Klasse kann nicht als Basisklasse für weitere Klassen verwendet

werden

• protected,private,strictfp,static: auch zugelassen, aber nur für

innere Klassen oder nur für spezielle Klassen benötigt



Beispiel mit Schnittstelle und Polymorphie: Geometrie 1/9





package de.wwu.ziv.vorlesung.java.beispiel7.geometrie.interfaces; public interface IForm { public double getFlaeche(); public double getUmfang(); }




package de.wwu.ziv.vorlesung.java.beispiel7.geometrie import de.wwu.ziv.vorlesung.java.beispiel7.geometrie.formen.*; import de.wwu.ziv.vorlesung.java.beispiel7.geometrie.interfaces.IForm; public class Geometrie { public static void main(String[] args) { Rechteck rechteck1 = new Rechteck(8, 9); Rechteck rechteck2 = new Rechteck(2, 6); Kreis kreis1 = new Kreis(4); Quadrat quadrat1 = new Quadrat(4); Quadrat quadrat2 = new Quadrat(8); Kreis kreis2 = new Kreis(5); Kiste kiste = new Kiste(10); kiste.hinzufuegen(rechteck1); // Anwendung der Polymorphie kiste.hinzufuegen(rechteck2); kiste.hinzufuegen(kreis1);




kiste.hinzufuegen(kreis2); kiste.hinzufuegen(quadrat1); kiste.hinzufuegen(quadrat2); kiste.formenAuflisten(); // Form mit dem kleinsten Flächeninhalt ermitteln IForm form = kiste.getKleinsteForm(); if (form != null) { System.out.println("Die kleinste Form ist: " + form); } // Form mit dem größten Flächeninhalt ermitteln form = kiste.getGroessteForm(); if (form != null) { System.out.println("Die größte Form ist: " + form); } } }




package de.wwu.ziv.vorlesung.java.beispiel7.geometrie import de.wwu.ziv.vorlesung.java.beispiel7.geometrie.IForm; public class Kiste { private IForm[] formen; private int index; public Kiste(int anzahl) { formen = new IForm[anzahl]; index = 0; } public boolean hinzufuegen(IForm ware) { if (index < this.formen.length) { this.formen[index] = ware; index += 1; return true; } return false; }




public IForm getGroessteForm() { IForm formMax = null; for (IForm form : formen) { if (form != null) { if (formMax == null || formMax.getFlaeche() < form.getFlaeche()) { formMax = form; } } } return formMax; } public IForm getKleinsteForm() { IForm formMin = null; for (IForm form : formen) { if (form != null) { if (formMin == null || formMin.getFlaeche() > form.getFlaeche()) { formMin = form; } } } return formMin; }




public String toString() { return "Regal: " + this.formen.length; } public void formenAuflisten() { System.out.println("Liste der Formen, die sich in der Kiste befinden: "); for (IForm form : formen) { if (form != null) { System.out.println(form.toString()); } } } }


Beispiel mit Schnittstelle und Polymorphie: Geometrie 9/9 run:

Liste der Formen, die sich in der Kiste befinden:

Ein Rechteck mit einer Länge von 8.0, einer Breite von 9.0, einer Fläche von 72.0 und

einem Umfang von 34.0.

Ein Rechteck mit einer Länge von 2.0, einer Breite von 6.0, einer Fläche von 12.0 und


Ein Kreis mit einem Radius von 4.0, einer Fläche von 50.2654816 und einem Umfang von

25.1327408.

Ein Kreis mit einem Radius von 5.0, einer Fläche von 78.539815 und einem Umfang von

31.415926.

Ein Quadrat mit einer Länge von 4.0, einer Fläche von 16.0 und einem Umfang von 16.0.

Ein Quadrat mit einer Länge von 8.0, einer Fläche von 64.0 und einem Umfang von 32.0.

Die kleinste Form ist: Ein Rechteck mit einer Länge von 2.0, einer Breite von 6.0, einer

Fläche von 12.0 und einem Umfang von 16.0.

Die größte Form ist: Ein Kreis mit einem Radius von 5.0, einer Fläche von 78.539815 und


BUILD SUCCESSFUL (total time: 0 seconds)



Fehler = Exceptions?

• Die Exception- bzw. Ausnahmebehandlung in Java ist eine spezielle Form der

Fehlerbehandlung

• Typischerweise treten beim Programmieren folgende Fehler auf:

• Syntaktische Fehler: Diese werden bereits vom Compiler erkannt und das

geschriebene Programm kann erst nach der Behebung vom Compiler übersetzt

werden

• Logische Fehler und Bugs: Sind meistens schwer zu lokalisieren (z.B. + und -

vertauscht). Können durch systematisches Ausgeben eigener Debug-Informationen

oder mit Hilfe eines Debuggers behoben werden.

• Laufzeitfehler: Meistens liegt die Fehlerquelle außerhalb des Programms. Hier

können Benutzerangaben oder Ressourcenanforderungen(z.B. Dateien) die Ursache

sein. Diese Fehler müssen im Programm abgefangen bzw. behandelt werden.



Fehler an Ort und Stelle vermeiden

• Grundsätzlich sollten Fehler an dem Ort Ihres Auftretens vermieden oder

behandelt werden

• Beispiel: Bevor man auf die Argumente eines Programmaufrufs zugreift, sollte

man sich vergewissern, das diese auch vorhanden sind


public static void main(String[] args) {

if (args.length != 1){

System.out.println("\nFalsche Anzahl Argumente!");

System.out.println("Aufruf: java Programmname <Argument>");

System.exit(0);

}

else {

System.out.println(args[0]);

}

}


Fehlerbehandlung durch Codierung in Rückgabewerten • Wenn eine Methode einen Fehler „bemerkt“ kann sie durch spezielle Rückgabewerte

außerhalb des normalen Wertebereichs eine Fehlerbehandlung an dem Ort ermöglichen an

dem sie aufgerufen wurde.

• Das führt zu Problemen wenn der Rückgabewert kein primitiver Datentyp ist sondern

zum Beispiel ein Objekt einer selbst definierten Klasse

• Dieses Vorgehen erschwert die Lokalisierung von Fehlern da scheinbar ein vernünftiges

Ergebnis zurückgegeben wird


public static double division(double zaehler, double nenner){ if (nenner == 0.0) return Double.NaN; else return zaehler/nenner; }

quotient = division(zaehler,nenner);

if (Double.isNaN(quotient)){ System.out.println("Fehler: Division durch Null"); } else{ System.out.println("Divisionsergebnis: " + quotient); }


Exceptions

• Exceptions dienen dazu das Auftreten und Erkennen eines Fehlers räumlich im Code zu

trennen

• Code für eine bessere Übersicht nicht durch aufwendige Fehlerbehandlung

unterbrochen

• sinnvolle Fehlerbehandlung am Ort des Auftretens nicht möglich • Eine Exception ist ein Objekt der Klasse Exception oder einer abgeleiteten Klasse von

Exception

• Die Behandlung von Fehlern mit Exceptions soll die Vorgehensweisen auf den zuvor

genannten Folien nicht ersetzen.



Exceptions erzeugen

• Mit dem Schlüsselwort throw wird eine Exception ausgelöst

• Compiler prüft, ob Exceptions behandelt werden oder in der Signatur der Methode

throws <Exceptionliste> enthalten sind und somit weitergeleitet werden

(Checked Exceptions)

• Bei RuntimeException und deren Subklassen nimmt der Compiler keine

Überprüfung vor (Unchecked Exceptions)


public static double division(double zaehler, double nenner) throws Exception {

if (nenner == 0.0)

throw new Exception();

else

return zaehler / nenner;

}


Exceptions abfangen und finally

• Nach dem Werfen einer Exception wird der Ablauf des Programms unterbrochen

• Die ausgelöste Exception wird von „innen nach außen“ zu den umliegenden Blöcken

und Methoden weitergeleitet

• Wird auf dem Weg passender catch-Handler von einem try-Block erreicht, so wird die

Exception von diesem abgefangen

• finally-Block wird optional, sobald ein catch-Block vorhanden ist.


try { … // z. B. Ausführen einer Methode division(..) } catch (Exception ex) { … // division hat eine Exception geworfen } finally { … // finally-Block wird immer ausgeführt nach Abarbeitung // des try-catch-Blockes um z. B. eine Datei zu schließen }


Exception-Hierarchie • Es können mehrere catch-Handler definiert werden

• Catch-Handler werden in der Reihenfolge ihrer Definition durchsucht.

• Exception-Objekte können implizit zu ihrem Basisobjekt umgewandelt werden,

• catch (Exception e) { .. } fängt alle Exceptions.

• Mit der Definition des speziellsten Handlers anfangen, damit keine Verdeckung durch

einen Allgemeineren erfolgt.

• Basisklasse Exception extends Throwable stellt folgende Methoden:

Throwable(String meldung) //Konstruktor erlaubt die Übergabe einer Meldung

Throwable getCause() // zum Verketten von Exceptions (nächste Folie)

String getMessage() // Meldungstext einer Exception

Void printStackTrace() // Beschreibung plus Liste der Methoden auf dem Stack

String toString() // Beschreibung der Exception(Klassennamen,Meldungstext)

• Methoden können im Catch-Handler genutzt werden durch Zugriff auf Objektreferenz e



Beispiel: EigeneException 1/4


package de.wwu.ziv.vorlesung.java;

public class ExceptionBeispiel {

public static double division(double zaehler, double nenner) throws NullDivisionException { if (nenner == 0.0) { throw new NullDivisionException("Nulldivision", zaehler); } else { return zaehler / nenner; } }

public static void main(String[] args) { double zaehler = 0, nenner = 0, bruch = 0;




try { zaehler = 23.56; nenner = 3.0; bruch = division(zaehler, nenner); System.out.println("\n\t" + zaehler + " : " + nenner + " = " + bruch); zaehler = 23.56; nenner = 0.0; bruch = division(zaehler, nenner); System.out.println("\n\t" + zaehler + " : " + nenner + " = " + bruch); } catch (NullDivisionException e) {

System.out.println("\n\t Fehler: Exception wurde abgefangen"); } catch (Exception e) {

System.out.println("\n\t Fehler: Exception wurde abgefangen"); } }




package de.wwu.ziv.vorlesung.java; public class NullDivisionException extends Exception { private double zaehler; public double getZaehler() { return zaehler; } public NullDivisionException(String meldung) { super(meldung); } public NullDivisionException(String meldung, double zaehler) { super(meldung); this.zaehler = zaehler; } }




run: 23.56 : 3.0 = 7.853333333333333 Nulldivision Zaehler war gleich: 23.56 BUILD SUCCESSFUL (total time: 0 seconds)


Zusammenfassung

• Sie kennen die folgenden Dinge und können diese anwenden:

• Schnittstellen

• try-catch-finally-Block

• Die Schlüsselwörter throw, throws und implements

• Modifikatoren bei der Klassendefinitionen

• Sie kennen die Unterschiede zwischen Schnittstellen und abstrakte Klassen



Aufgaben

1. Erweitern Sie das Projekt der Aufgabe zur 6.Vorlesung um das Interface IWare:

a) Das Interface definiert nur die Methode: public float getWert()

b) Ersetzen Sie den Objekttyp mit der Basisklasse Ware durch den Schnittstellentyp

IWare.

2. Tests zum Exceptionhandling:

a) In der Klasse Schuhbeispiel soll das Regal nun mit nur 5 Plätzen instanziiert

werden. Was beobachten Sie bei einem Run des Projekts?

b) Entfernen Sie in der Klasse Regal in der Methode hinzufuegen(IWare ware) den

if-Satz und lassen Sie das Projekt erneut laufen. Was beobachten Sie nun?

c) Umschließen Sie die hinzufuegen-Methoden in der main-Funktion mit einem try-

catch-Block, bei dem die ArrayIndexOutOfBoundsException abgefangen werden

soll. Im catch-Block soll folgende System.out.println-Meldung erfolgen, wobei

die getMessage() von der Exception angehängt werden soll: "Das Regal ist zu

klein. Die Waren konnten nicht vollständig eingeräumt werden!" Führen Sie das

Projekt erneut aus und welche Ausgabe beobachten Sie nun?



Klassendiagramm zur Aufgabe


Einführung in die objektorientierte Programmierung Teil 4 und Exception Handling · 2014-05-26 ·...

Documents

Transcript of Einführung in die objektorientierte Programmierung Teil 4 und Exception Handling · 2014-05-26 ·...