Einführung in die Objektorientierung Enums, innere-klassen, Exceptions
2 Vererbung Repräsentiert eine ist ein Beziehung zwischen Klassen x: float y: float Point Form origin: Point Vererbung Rectangle width: float height: float Circle radius: float Ein Rechteck ist eine (geometrische) Form Ein Kreis ist eine (geometrische) Form
3 Vererbung in Java Sprachgebrauch: Elternklasse: Klasse von der geerbt wird Kindklasse: Alle von einer Elternklasse erbenden Klassen Eine Kindklasse erbt: Alle Attribute der Elternklasse Alle Methoden der Elternklasse Alle Konstruktoren der Elternklasse Zugriff auf Elemente (Attribut, Methode, Konstruktor) zur Laufzeit: Ist das Element in der Klasse der aktuellen Instanz definiert? Falls nein: Ist das Element ein der Elternklasse definiert? Falls nein: Hat die Elternklasse eine Elternklasse? Falls ja: Die Hierarchie durchlaufen, bis das Element gefunden wurde Ansonsten: Compiler-Fehler
4 Klassenhierarchie in Java In Java fängt jede Klassenhierarchie mit der Klasse Object an D.h. jede Klasse, die nicht explizit von einer anderen Klasse erbt, erbt von Object, ohne dass dies angegeben werden muss Am Beispiel der geometrischen Figuren Object x: float y: float Point Form origin: Point Circle radius: float Rectangle width: float height: float
5 Vererbung in Java Das Schlüsselwort zu Deklaration von Vererbung ist extends public class BEZEICHNER extends KLASSEN-BEZEICHNER { public class Form { private Point origin; public class Rectangle extends Form { private float width; private float height; public class Circle extends Form { private float radius; Java kennt nur einfache Vererbung, Die Hierarchietiefe ist allerdings beliebig
6 Vererbung und Konstruktoren Bei der Erzeugung einer Instanz wird in jeder Hierarchieebene ein Konstruktor ausgeführt Angenommen die Elternklasse Form hat folgenden Konstruktor public class Form { private Point origin; public Form(Point origin) {this.origin = origin; Damit ist der Default-Konstruktor überschrieben In erbenden Klassen muss ein Konstruktor explizit aufgerufen werden Der Aufruf des Eltern-Konstruktors erfolgt über das Schlüsselwort super public class Rectangle extends Form { private float width; private float height; public Rectangle(Point origin, float width, float height) { super(origin); this.width = width; this.height = height; Der Aufruf von super muss dabei immer der erste Satz im Konstruktor sein
7 Vererbung und Variablen public static void main(string[] args) { Form form; Form form = new Rectangle(); System.out.println(form); // Rectangle: Rectangle form = new Circle(); System.out.println(form); // Circle: Circle Rectangle rectangle; Rectangle rectangle = new Circle(); rectangle = new Form(); Circle Form Insbesondere Object object; object = new Circle(); object = "Hello World"; object = new Computer(); Object Circle String Computer
8 Vererbung und Methoden Die abgeleitete Klasse erbt alle Methoden der Elternklasse Damit erben auch alle Instanzen die Funktionalität der Elternklasse public class Form { private Point origin; public Form(Point origin) {this.origin = origin; public void print() { System.out.print(this.origin); public static void main(string[] args) { Form form; form = new Rectangle(new Point(50.0f, 75.0f), 2.0f, 8.0f); form.print(); // (50.0f, 75.0f) form = new Circle(Rectangle(new Point(1.0f, 0.0f), 16.0f); form.print(); // (1.0f, 0.0f) Die Methode print wurde in Form definiert, kann aber über Instanzen von Rectangle und Circle aufgerufen werden
9 Vererbung und Methoden (II) Jede Methode kann nur auf die Instanzattribute und -methoden der eigenen oder der Elternklasse zugreifen Die print-methode von Form kennt daher nur das Attribut origin Es ist möglich Methoden der Elternklasse zu überschreiben: public class Rectangle extends Form { private float width; private float height; public void print() { System.out.print("width:" + this.width + ", height:" + this.height); Form form; form = new Rectangle(new Point(50.0f, 75.0f), 2.0f, 8.0f); form.print(); // print von Rectangle: width: 2.0f, height: 8.0f form = new Circle(Rectangle(new Point(1.0f, 0.0f), 16.0f); form.print(); // print von Form: (1.0f, 0.0f)
10 Vererbung und Methoden (III) Der Rectangle-Aufruf von print liefert keine Angabe zu origin mehr Mit super kann nicht nur ein Konstruktor aufgerufen werden Auch der Zugriff auf Methoden und Attribute der Elternklasse ist damit möglich public class Rectangle extends Form { public void print() { super.print(); System.out.print("width:" + this.width + ", height:" + this.height); Form form; form = new Rectangle(new Point(50.0f, 75.0f), 2.0f, 8.0f); form.print(); // Rectangle::print (50.0f, 75.0f) width: 2.0f, height: 8.0f form = new Circle(new Point(1.0f, 0.0f), 16.0f); form.print(); // Form::print (1.0f, 0.0f) Der Zugriff auf origin innerhalb von Rectangle scheitert allerdings System.out.print("origin:" + super.origin + ", width:" + this.width + ", height:" + this.height);
11 Sichtbarkeit Es gibt vier Sichtbarkeitsmodifiktoren für Attribute und Methoden public: Zugriff von überall protected: Zugriff innerhalb des Packages und bei Vererbung [keine Angabe]: Zugriff innerhalb des Packages ( package private ) private: Zugriff nur innerhalb der eigenen Klasse/Instanz Das erklärt das Scheitern des Zugriffes im vorherigen Beispiel public class Form { private Point origin; Das Attribut origin ist nur innerhalb von Form verwendbar Es gibt zwei Sichtbarkeitsmodifikatoren für Klassen: public: Zugriff von überall [keine Angabe]: Zugriff innerhalb des Packages ( package private ) Insbesondere: Nur die mit dem Dateinamen übereinstimmende Klasse kann public sein
12 Vererbung und this public class Form {.. public class Rectangle { public String tostring() { return this.getclass().getsimplename(); public String tostring() { return super.tostring() + " width:" + this.width + " height:" + this.height; System.out.println( new Form() ); System.out.println( new Rectangle() ); System.out.println( new Circle() ); Rectangle tostring: String Form tostring: String Circle Form Rectangle width: height: Circle
13 Abstrakte Klassen/Methoden Jede geometrische Figur hat einen Flächeninhalt Im Sinne der Objektorientierung wäre dies eine Methode der Klasse Form public class Form { public double getarea() Ein Flächeninhalt ist abhängig vom Typ der Form (Kreis, Rechteck, etc.) Die Klasse Form kennt ihre allerdings Kindklassen nicht Die Methode getarea kann für Form demnach nicht sinnig definiert werden In solchen Fällen (Zugehörigkeit eindeutig, Implementierung nicht) definiert man eine Methode als abstrakt SICHTBARKEIT abstract RÜCKGABETYP BEZEICHNER ( DATENTYP PARAM- BEZEICHNER, ); optional public abstract double getarea(); Sobald eine Methode abstract ist, muss auch die Klasse abstract sein SICHTBARKEIT abstract class KLASSEN-BEZEICHNER public abstract class Form
14 Abstrakte Klassen/Methoden Es kann keine Instanz einer abstrakten Klasse erstellt werden Eine abstrakte Methode hat keinen Methodenrumpf (Implementierung) Lediglich die Signatur wird angegeben Nur Instanz-Methoden können abstrakt sein Eine erbende Klasse muss entweder eine Implementierung der Methode angeben public class Circle extends Form { public final static double PI = 3.1415926; Form public double getarea() { return this.radius * this.radius * Circle.PI; Circle oder selbst wieder als abstract definiert werden public abstract class UnknownForm extends Form { Form UnknownForm
15 Polymorphie Die getarea()-methode ist den Zugriffsrechten entsprechend aufrufbar Demnach auch von der definierenden Klasse selbst public abstract class Form { public abstract double getarea(); public String tostring() { return this.getclass().getsimplename() + " Fläche=>" + this.getarea(); Warum compiliert dies? Da Form abstract ist kann es keine Instanz der Klasse Form geben tostring kann nur von Instanzen aufgerufen werden D.h. es existiert eine Klasse in der Hierarchie des aufrufenden Objektes, die getarea implementiert Welche Klasse dies ist, steht erst zur Laufzeit fest Dieses Verhalten nennt sich spätes Binden (auch: dynamisches Binden ) Abstrakte Methode werden daher als polymorph bezeichnet
16 Interfaces Ein Interface ist eine abstrakte Klasse, in der alle Methoden public sind (per default, eine Sichtbarkeit muss nicht angegeben werden) abstrakt sind (per default, abstract muss nicht angegeben werden) SICHTBARKEIT interface BEZEICHNER { RÜCKGABETYP BEZEICHNER ( DATENTYP PARAM-, ); BEZEICHNER public interface Identifiable { String getmac(); Eine Klasse implementiert ein Interface Die Beziehung wird nicht per extends sondern mit implements angegeben public class BEZEICHNER implements INTERFACE-BEZEICHNER {
17 Interfaces (II) Innerhalb eines Interfaces können keine Instanz-Attribute definiert werden Klassenattribute sind möglich Eine implementierende Klasse muss entweder alle im Interface angegebenen Methoden definieren oder als abstract deklariert werden public class Computer implements Identifiable { private String id; public Computer(String id) { this.id = id; public String getid() {return this.id; Eine Klasse kann beliebig viele Interfaces implementieren (Aufzählung per,) Dadurch gewinnt man eine Art Pseudo-Mehrfachvererbung Es können Variablen vom Typ eines Interfaces definiert werden: Identifiable identifiable = new Computer("0080.41ae.fd7e"); System.out.print(identifiable.getId());
18 Anwendung Vererbung, Interfaces und abstrakte Klassen sollen nun auf das Computer-Beispiel übertragen werden Nicht immer ist Vererbung so offensichtlich wie im Formen-Beispiel Da Vererbung immer eine ist ein Beziehung abbilden soll, müssen zuerst Gemeinsamkeiten identifiziert werden Sowohl Grafik- als auch Soundkarte sind Platinen mit einem Prozessor Processor CircuitBoard GraphicsCard Soundcard
19 Anwendung Der Computer hat ebenfalls eine Platine (Mainboard) mit Prozessor Sowohl Computer als auch die Grafikkarte verfügen über RAM Computer RAMModule CircuitBoard GraphicsCard Soundcard Processor
20 Anwendung Computer Processor CircuitBoard RAMModule GraphicsCard Soundcard Pluggable Sound-,Grafikkarte und RAM-Module werden auf das Mainboard gesteckt Der Entwurf wirft mindestens zwei Fragen auf: Soll die RAM-Gemeinsamkeit von Computer und GraphicsCard zu einer neuen Elternklassen führen? Wie wird die Mehrfachvererbung für Sound- und Grafikkarte aufgelöst?
21 Anwendung Soll die RAM-Gemeinsamkeit von Computer und GraphicsCard zu einer neuen Elternklassen führen? Das wäre durchaus denk- und machbar Allerdings kann man sich die Klasse sparen, wenn man die RAM- Abhängigkeit auf die Tatsache reduzieren, dass RAMModule Pluggable ist und damit bereits zum CircuitBoard gehört GraphicsCard erbt von CircuitBoard und Computer besitzt eines CircuitBoard muss demnach eine beliebige Anzahl von Pluggable- Instanzen verwalten CircuitBoard 1 n Pluggable Die Verwaltung der Pluggable-Instanz wird immer gleich aussehen und kann daher in der CircuitBoard-Klasse implementiert werden Das beantwortet auch schon Frage zwei: Pluggable muss ein Interface werden
22 Anwendung Auch Processor kann als Pluggable betrachtet werden Daneben existierte im Ursprungsentwurf noch die Klasse Connector, die ebenfalls als Pluggable umsetzbar ist Processor <<interface>> Pluggable? getslot(); Connector RAMModule GraphicsCard Soundcard Die Steckplätze einer Platine sind begrenzt Zudem Unterscheiden sich die einzelnen Steckplätze Es gibt nur einen Prozessor Allerdings bspw. zwei RAM-Steckplätze Pluggable-Instanzen unterscheiden sich daher anhand ihres Steckplatzes
23 Typisierung des Steckplatzes Der Steckplatz wird ein Instanzattribut der Pluggable-Klassen sein D.h. Steckplatz muss typisiert werden Klassisch bieten sich zwei Möglichkeiten an: String oder int Die möglichen Werte sollten als konstante Klassenattribute definieren werden Da Klassenattribute in Interfaces zulässig sind, bietet sich Pluggable an public interface Pluggable { public static final String PROCESSOR = "PROCESSOR"; public static final String RAM = "RAM"; public interface Pluggable { public static final int PROCESSOR = 0; public static final int RAM = 1; Die Zuteilung eines Wertes erfolgt über den Attributnamen String slot = Pluggable.PROCESSOR; int slot = Pluggable.PROCESSOR; Dies hat zum Vorteil: Da der Attribut-Name anstelle des Wertes benutzt wird und dieser vom Compiler auf Existenz überprüft wird, keine Flüchtigkeitsfehler Im int-fall: Attributname sprechender als eine Zahl
24 Typisierung des Steckplatzes Der Ansatz einen bestimmten Satz an Werten über konstante Klassenattribute zu benennen hat allerdings klare Nachteile: Da der Typ der Attribute int oder String ist, kann jeder beliebige String oder int-wert eingesetzt werden String slot = "SUPPE"; int slot = -1111; Der Compiler hat keine Möglichkeit zu überprüfen, ob ein angegebener Wert valide ist Die Werte sind nicht abgeschlossen gegenüber Operatoren String slot = Pluggable.PROCESSOR + Pluggable.RAM; Man könnte meinen, dass dies entweder heißt, beide Slots sind zulässig oder dass ein kombinierter Slot gemeint ist Mit Java (1.)5 wurden Enums in den Java-Sprachumfang eingeführt, die Aufzählungen wie oben konsistent abbilden
25 Enums Enums sind eine Aufzählung von int-werten, wobei jedes Element einem bestimmten Namen zugeordnet ist In Java werden Enums über das Schlüsselwort enum definiert und sind spezielle Klassen und damit jeder Enum-Wert ein Objekt SICHTBARKEIT KLASSEN-BEZEICHNER { enum ENUM-BEZEICHNER, public enum Slot { PROCESSOR, RAM, Lediglich die Namen werden angegeben und werden per Konvention komplett in Großbuchstaben notiert (analog zu konstanten Klassenattributen) Die Werte werden konsekutiv angefangen bei 0 einem int-wert zugeordnet Ein Zugriff erfolgt über die Dereferenzierung des Klassennamens: Slot.PROCESSOR
26 Enums (2) Über die Methoden ordinal() und name() kann die zugordnete Ordnungszahl sowie der Name eines Enums abgefragt werden Slot slot = Slot.PROCESSOR; System.out.print("Das Enum " + slot.name() + " hat die Ordnungszahl " + slot.ordinal()); // Da Enum PROCESSOR hat die Ordnungszahl 0 Enums können in switch-anweisungen genutzt werden: switch (slot) { case PROCESSOR: case RAM: case default: Achtung: Im Gegensatz zum normalen Zugriff wird in der case- Anweisung nur der Enum-Name angeben, keine explizite Dereferenzierung
27 Inner-Class Damit kann der Steckplatz nun über eine Enum-Klasse abgebildet werden Enum-Klassen können in einer eigenen Java-Datei abgelegt werden Das Slot-Enum existiert allerdings nur im direkten Zusammenhang mit dem Pluggable-Interface Um eine solche Abhängigkeit abzubilden bietet Java die Möglichkeit Klassen/Interfaces innerhalb von Klassen/Interfaces zu definieren MODIFIKATOREN class enum KLASSEN-BEZEICHNER { public interface Pluggable { MODIFIKATOREN class enum KLASSEN-BEZEICHNER { public static enum Slot { PROCESSOR, RAM,
28 Inner-Class Der Zugriff auf innere Klassen erfolgt analog zu Klassenattributen über den umschließenden Klassennamen Pluggable.Slot slot = Pluggable.Slot.PROCESSOR; Nur bei inneren Klassen kann der Modifikator static genutzt werden: public class GraphicsCard { public static class Resolution { int width; int height; Innerhalb eines Interfaces sind alle inneren Klassen automatisch static Geeignete Sichtbarkeit vorausgesetzt können von außen nur Instanzen von statischen inneren Klassen erzeugt werden: GraphicsCard.Resolution resolution = new GraphicsCard.Resolution(); public class GraphicsCard { public class Resolution { int width; int height; // Resolution statisch GraphicsCard.Resolution resolution = new GraphicsCard.Resolution(); // Resolution nicht statisch
29 Inner-Class Instanzen nicht statischer innerer Klassen können nur innerhalb von Instanzen der umschließenden Klasse erzeugt werden: public class GraphicsCard { public class Resolution { public Resolution createresolution(int width, int height) { return new Resolution(width, height); GraphicsCard card = new GraphicsCard(); GraphicsCard.Resolution resolution = card.createresolution(1024, 920); Jede Instanz einer nicht statischen inneren Klasse hat automatisch Zugriff auf die Instanz, die sie erzeugt hat public class Resolution { public GraphicsCard getcard() { return GraphicsCard.this; Damit kann die Instanz auch auf alle Attribute und Methoden der erzeugenden Instanz zugreifen
30 Anwendung Mit dem Slot-Enum können Pluggable-Instanzen nun einem Steckplatz auf der Platine zugeordnet werden Die Anzahl Steckplätze eines bestimmten Typs sind begrenzt Die Anzahl kann bspw. im Konstruktor des CircuitBoards festgelegt werden Nun benötigt CircuitBoard eine Methode um Pluggable-Instanzen auf die Platine zu stecken CircuitBoard plugin(pluggable pluggable): void 1 n <<interface>> Pluggable Slot getslot(); Die Methode muss sich die Zuordnung des Steckplatzes merken Zudem muss sie überprüfen, ob überhaupt noch ein Steckplatz frei ist Schlägt diese Überprüfung fehlt, wurde bisher die Ausführung der Methode durch ein return beendet Semantisch bedeutet dies, dass die Methode erfolgreich ausgeführt wurde Die Methode sollte eigentlich signalisieren, dass das Stecken fehlschlug
31 Fehlerbehandlung durch Rückgabewerte Mit den bisherigen Mitteln kann das Fehlschlagen einer Ausführung durch Codierung in der Rückgabe umgesetzt werden public class CircuitBoard { public boolean plugin(pluggable pluggable) { if (!slotavailablefor(pluggable.getslot())) { return false; public class CircuitBoard { public Pluggable plugin(pluggable pluggable) { if (!slotavailablefor(pluggable.getslot())) { return null; return true; return pluggable; Das ist auch durchaus ein nutzbarer Ansatz, allerdings Was wenn die Methode eine Rückgabe liefern soll, die für die Fehlercodierung ungeeignet ist? Ein Nutzer der Methode kann die Rückgabe ignorieren, so dass unter Umständen eine nötige Fehlerbehandlung überhaupt nicht durchgeführt wird
32 Fehlerbehandlung durch Exceptions Java bietet mit Exceptions eine alternative Möglichkeit zur Fehlerbehandlung Die Ausführung einer Methode kann jederzeit durch das Werfen einer Exception beendet werden Methoden, die durch eine Exception abgebrochen werden könnten, müssen diese in ihrer Signatur nach dem Schlüsselwort throws angeben MODIFIKATOREN RÜCKGABETYP BEZEICHNER ( throws EXCEPTION-TYP, ; public void plugin(pluggable pluggable) throws ConfigurationException{ ConfigurationException ist selbstdefinierte Klasse, die von Exception erbt, d.h. Exceptions sind Objekte Alle Kindklassen von Exception können nach throws angegeben werden Innerhalb der Methode muss im Fehlerfall eine Instanz der Klasse erzeugt und mittels throw geworfen werden: if (!slotavailablefor(pluggable.getslot())) { throw new ConfigurationException("FEHLERMELDUNG");
33 Fehlerbehandlung durch Exceptions Eine Methode, die eventuelle Fehler durch Exceptions signalisiert kann nicht mehr einfach unbedacht aufgerufen werden Sie muss durch einen sogenannten try-catch-block umschlossen werden try { AUFRUF EINER METHODE, DIE MIT THROWS DEFINIERT WURDE CircuitBoard board = ; Pluggable pluggable = ; try { board.plugin(pluggable); catch ( EXCEPTION-TYP BEZEICHNER_1 ) { FEHLERBEHANDLUNG catch (ConfigurationException e) { System.out.println( e.getmessage() ); catch ( EXCEPTION-TYP BEZEICHNER_N ) {
34 Fehlerbehandlung durch Exceptions In einem try-catch Block können mehrere Anweisung ausgeführt werden Führt eine Anweisung zum Fehler wird keine der nachfolgenden ausgeführt Jede dieser Anweisung kann das Schmeißen diverser Exceptions signalisieren Für jeden Exception-Typ kann ein catch-block angegeben werden Es müssen alle potentiellen Exceptions durch catch abgefangen werden Ein catch-block kann mehrere Exception-Typen abdecken: Entweder durch die Angabe eines übergeordneten Exception-Typs try { catch (Exception e) { Oder durch Angabe mehrerer Typen: try { catch (ExceptionTyp_1 ExceptionTyp_2 e) { Jede Exception darf allerdings nur einmal durch einen catch-block behandelt werden
35 Fehlerbehandlung durch Exceptions Angenommen ein Aufruf innerhalb des try-blockes führt zu einem illegalen Programmzustand Der catch-block sollte dann dazu genutzt werden, diesen illegalen Zustand wieder aufzulösen Ist dies in der aufrufenden Methode nicht möglich, so kann die Exception an die nächste Methode weitergereicht werden: Dazu muss auch die aufrufende Methode die möglichen Exceptions per throws deklarieren Falls die Methode alle Exceptions definiert, die im try-teil potentiell auftreten könnten, so kann try-catch in der Methode weggelassen werden public void test(circuitboard board) throws ConfigurationException{ Pluggable pluggable = ; board.plugin(pluggable); Alternative kann die Methode eine eigene Exception anderen Typs schmeißen, dann ist allerdings ein try-catch für den plugin-aufruf nötig
36 Fehlerbehandlung durch Exceptions Neben dem catch-block kann optional noch ein finally-block angegeben werden Der Code innerhalb des finally-blockes wird in jedem Fall ausgeführt: Entweder nach erfolgreicher Ausführung aller im try-block befindlichen Anweisungen Oder nachdem ein Fehler durch einen catch-block behandelt wurde CircuitBoard board = ; Pluggable pluggable = ; // Freier Slot FINALLY try { board.plugin(pluggable); catch (ConfigurationException e) { System.out.println(e.getMessage() ); finally { System.out.println("FINALLY" ); // Kein freier Slot Slot not available for pluggable object FINALLY