Objektorientierte Programmierung mit JAVA

© Klasse Wie in C++ ist die Klasse das primäre Mittel um ein Entity abzubilden Die Eigenschaften eines Entities werden als Datenfelder der Klasse abgebildet Das Verhalten wird in Form von Methoden abgebildet Beispiel: Entity: ein geometrischer PunktKlasse:Point Attribute: x & y KoordinatenDatenfelder: int x, y Operation: Abstand vom UrsprungMethode: void distance()

© Definition Im Gegensatz zu C++ ist eine Klassendefinition vollständig, d.h. alles ist an einer Stelle in einer Datei festgelegt public class ClassName { // definition of the class } public - Sichtbarkeit (Schlüsselwort) class - Definition einer Klasse (Schlüsselwort) ClassName - der Name der Klasse (Identifier) { } - Block, definiert die Grenzen der Klasse Alle Methoden und Datenfelder kommen hier rein

© Beispiel public class Point{ } private int x; private int y; public double distance () { return Math.sqrt(x* x + y * y); } Andere Methoden Alle Datenfelder werden hier definiert Alle Methoden werden hier definiert

© Design einer Klasse Der Prozeß, die angemessenen Informationen über ein Entity herauszufinden, ohne sich in Details zu verlieren Unwichtige Details werden ignoriert Die Klasse stellt unsere Sicht des Entities in der Programmiersprache dar Die Qualität des Entwurfs ergibt sich daraus, ob unsere Abstraktion dem Problem angemessen ist Beispielsweise ist eine Drahtmodell-Darstellung eines Autos - obwohl eine korrekte Abstraktion - ungeeignet, um das Fahren eines Autos darzustellen Verschiedene Programmierer erzeugen unter Umständen unterschiedliche Abstraktionen des selben Entities

© Objekte Üblicherweise wird ein Objekt durch den new Operator dynamisch erzeugt. Ein Objekt kann auch indirekt erzeugt werden - später public class AnyClass { public static void main(String args[]) { Point p1 = new Point(); Point p2 = new Point(); } } Bei der Erzeugung eines Objekts wird - wie in C++ - der notwendige Speicher reserviert.

© Speicherverwaltung Point p1 = new Point(); p1 ist eine Referenz auf ein Point Objekt Point p1; p1 = new Point(); Jedes Objekt hat eine eigene Kopie der Datenfelder (Attribute) p1 x=0 y=0 Beim Compilieren wird Speicher- platz für die Referenz belegt Speicherplatz für das Objekt wird vom System angefordert. In diesem Platz werden die Instanzvariablen (Datenfelder) des Objekts gespeichert

© Zugriff auf Member Auf Attribute und Operationen kann mit dem (  ) Operator zugegriffen werden Point p1 = new Point(); p1.x = 20; p1.y = 30; double d = p1.distance (); Annahme: Member x und y sind für das Objekt, das p1 anlegt, sichtbar Member eines Objekts werden durch object  member angesprochen, nicht durch class  member

© Sichtbarkeit Klassenmember können als public, private, oder protected definiert werden Beispiel: public members public class Point { public int x; public int y; public void setX( int d) { x = d; } // Rest der Klassendefinition } Auf public Attribute kann von jedem anderen Objekt zugegriffen werden (auch schreibend) - keine Kapselung

© private Attribute Attribute und Methoden können private sein public class Point { private int x; private int y; public void setX( int d) { x = d; } // Rest der Klassendefinition } private Member sind von außen nicht sichtbar protected Member sind nur für abgeleitete Klassen sichtbar

© Beispiel public class Point { private int x; private int y; public void setPoint(int a, int b) { x = a; y = b; } public void showCoordinates() { System.out.println("x = "+x+ " y = "+y); } public class PointUser { public static void main(String args[]) { Point p1 = new Point(); p1.setPoint(20,15); p1.showCoordinates(); } Kapselung: Attribute private machen, geeignete public Funktionen zum Zugriff Kapselung verbirgt Implementierungsdetails

© Default-Sichtbarkeit Im Gegensatz zu C++ ist der default Sichtbarkeit im package public class Point { int x; int y; void setX( int d) { x = d; } // Rest der Klassendefinition } Package bedeutet im wesentlichen alle Dateien in einem Unterverzeichnis Andere Klassen im selben package können auf diese Variablen zugreifen

© Sichtbarkeit in der Klasse Attribute werden von lokalen Variablen überdeckt public class Point { private int x; private int y; public void setPoint(int a, int b) { int x; x = a; y = b; } public void showCoordinates() { System.out.println("x = "+ x +" y = "+y); } Lokale Variable x verdeckt Attribut x Die lokale Variable x wird initialisiert, nicht das Attribut Dieses x ist das Attribut

© explizite Initialisierung Instanzvariablen können explizit initialisert werden public class Point { private int x = 20; private int y = 18; public void setPoint(int a, int b) { x = a; y = b; } public void showCoordinates() { System.out.println("x = "+x+" y = "+y); } x wird mit 20, y mit 18 initialisiert wenn ein Point Objekt erzeugt wird

© Methoden wie Funktionen in C return type Name ( Argumente) { // Implementierung der Methode } modifier - public, private, protected, static modifier sind optional - (def. package) return type - ist notwendig, void falls nichts zurückgegeben werden soll Argumente durch Komma getrennt (kann leer sein) Name und Argumentliste sind die Signatur der Methode

© Argumente Parameter werden immer by value übergeben public class Point { private int x = 20; private int y = 18; public void setPoint(int a, int b) { x =a; b = 82; } public class TestPoint { public static void main(String args[]) { int k = 100; Point p = new Point(); p.setPoint(300,k); System.out.println(“k is immer noch “+k); } k = 100; Änderung von b in setPoint hat keinen Einfluß auf k b = k also b = 100 b (nicht k) wird auf 82 gesetzt

© Objekte als Parameter Parameter, die Referenzen auf Objekte sind, werden auch by value übergeben, die Attribute dieser Objekte können (natürlich) geändert werden Der Wert der referenz selbst ändert sich nicht public class MyObject { private int x; public void setX(MyObject mo) { mo.x = 300; } public static void main(String args[]) { MyObject obj = new MyObject(); obj.x = 20; System.out.println(“Obj vor Änderung “+obj.x); obj.setX(obj); System.out.println(“Obj nach Änderung “+obj.x); } x = 20 x = 300

© Überladen von Methoden Methoden können überladen werden z.B. aus java.Math: public static int max(int a, int b) { … } public static long max(long a, long b) { … } public static float max(float a, float b) { …} public static double max(double a, double b) { … } Regeln (Wie in C++) Name der Methoden ist gleich Argumente müssen unterschiedlich sein (Zahl und/oder Typ) Rückgabetyp kann verschieden sein (reicht aber nicht aus) Compiler wählt beim Aufruf die passende aus Kein Operator overloading in Java

© Konstruktoren Konstruktor Syntax Klassenname ( Argumente) { // Implementierung } meistens default oder public modifier Name des Konstruktors ist der Klassenname Konstruktoren dürfen nichts zurückgeben Wenn ein Rückgabetyp angegeben wird, behandelt der Compiler dies als normale Methode Konstruktoren dürfen (müssen aber nicht) Argumente haben Ein Konstruktor ohne Argumente heißt Default Konstruktor und wird vom Compiler automatisch erzeugt, falls kein Konstruktor implementiert

© Konstruktoren public class Point { private int x, y; public Point() { x = 0; y = 0; } public Point(int a, int b) { x = a; y = b; } // rest of the class } public class TestPoint { public static void main(String args[]) { Point p = new Point(); // Verwendung von p p = new Point(20,20); // neues p } Mehrere Konstruktoren - Overloading Da Konstruktoren Methoden sind, können sie überladen werden Default

© Ablauf beim Erzeugen public class TestPoint { public static void main(String args[]) { Point p = new Point(); // Verwendung von p } Speicher für die Instanz wird allokiert Instanzvariablen werden mit Defaultwerten initialisiert Explizite Initialisierung wird durchgeführt (falls vorhanden) Konstruktor wird aufgerufen public class Point { private int x = 2; private int y = 2; public Point() { x = 2; y = 2; } public Point(int a, int b) { x = a; y = b; } // Rest der Klasse }

© this this ist ein Schlüsselwort Referenz auf das eigene Objekt public class Point { private int x, y; public Point() { this.x = 20; //this ist hier nicht nötig this.y = 25; } public Point(int x, int y) { this.x = x; //hier schon this.y = y; } // Rest der Klasse }

© überladene Konstruktoren public class Point { private int x, y; public Point() { this(20,25); } public Point(int a, int b) { x = a; y = b; } // Rest der Klasse } public class TestPoint { public static void main(String args[]) { Point p = new Point(); // Verwendung von p Point p2 = new Point(18,99); } l Wenn this in einem Konstruktor verwendet wird, muß es in der ersten Zeile sein

© Destruktoren Speicher wird durch garbage collection automatisch freigegeben, andere Resourcen nicht Offene Dateien Netzwerkverbindungen temporäre Dateien löschen Destruktor wird automatisch irgendwann (vielleicht ?) vor garbage collection aufgerufen public class foobar {... public finalize()// oder protected { tempfile.delete(); }

© packages Wie organisiert man Klassen ? In Modulen - hier packages Alle Klassen eines package im gleichen Verzeichnis zu Beginn jeder Datei package Name; bei Verwendung import Name.*;// alle Klassen des package import Name.Klasse;// oder nur bestimmte Verzeichnishierarchien ergeben package-Hierarchien package com.till.util.database.*; Klassen im Verzeichnis com\till\util\database

© static Methoden auch Klassenmethoden dürfen nur auf static Attribute und lokale Variablen zugreifen kann direkt als SqrtTest.calcSqrRoot(25) aufgerufen werden ein Objekt ist dazu nicht nötig deshalb static main public class SqrtTest { public static double calcSqrRoot(double x) { double sqrt = x/2; double xprev; do { xprev = sqrt; sqrt = ( xprev + x/xprev)/2; } while (Math.abs(sqrt-xprev) > 1E-6) ; return sqrt; }

© static Attribute auch Klassenattribute haben für alle Objekte der Klasse den gleichen Wert wenn public, Zugriff mit Klassenname.Attribut möglich (z.B. System.out,...) Anwendung: Referenzzähler Liste mit Objekten static Initialisierung werden beim Laden der Klasse einmal ausgeführt z.B. um Libraries zu laden

© Vererbung Java unterstützt nur einfache Vererbung Mit dem Schlüsselwort extends kann eine Subklasse abgeleitet werden class Child extends Parent { // } Durch Interfaces kann so etwas ähnliches wie Mehrfachvererbung realisiert werden Die abgeleitete Klasse erbt alle public und protected Methoden und Attribute Eine abgeleitete Klasse kann Methoden der Superklasse aufrufen super.methodName()

© Beispiel: Basisklasse public class Circle { protected double radius; public Circle() { this(1.0); } public Circle(double r) { radius = r; } public double area() { return radius*radius*Math.PI; } //Andere Methoden von Circle }

© abgeleitete Klasse public class Cylinder extends Circle { private double length; public Cylinder() { super(); length = 1.0; } public Cylinder(double r,double l) { super(r); length = l; } public double volume() { return radius*radius* Math.PI*length; } //Andere Methoden von Cylinder } Konstruktoren werden nicht vererbt Konstruktor der Basisklasse

© Klassenhierarchien Shape CircleHexagonSquare Cylinder Cube

© Hierarchie in Java Alle Klassen in Java erben von Object Container,… Wir hätten also schreiben können: public class Circle extends Object.... public class Cylinder extends Circle... Vererbung kann als is-a Beziehung verstanden werden Zwei praktische Methoden der Klasse Object toString() clone()

© Polymorphie Polymorphie ist die Fähigkeit, unterschiedliche Gestalten anzunehmen Ein Objekt hat genau eine Gestalt Eine Referenz hat mehrere Gestalten, d.h. eine Referenz kann sich auf Objekte unterschiedlicher Klassen beziehen Beispiel: Circle c = new Cylinder(); // OK Für den Compiler ist c eine Referenz auf ein Circle Objekt, über c können also nur Methoden und Attribute von Circle angesprochen werden double v = c.volume() // Fehler (volume gehört zu Cylinder)

© welche Methoden ? Cylinder c = new Cylinder(); double v = c.area(); area() ist kein Member von Cylinder Zur Laufzeit wird geprüft, ob die Subklasse die aufgerufene Methode besitzt Wenn nicht, wird bei der Superklasse gesucht area() wird bei Circle gefunden und aufgerufen Die Fähigkeit eines Objekts, zur Laufzeit zu entscheiden, welche Methode - abhängig von der Position in der Klassenhierarchie - augerufen werden soll, nennt man Polymorphie Vorraussetzung: Der Code für den Methodenaufruf wird erst zur Laufzeit erzeugt (late binding)

© überschreiben von Methoden wenn eine Methode in der Subklasse eine anderes Verhalten implementieren soll, als in der Superklasse, kann diese überschrieben werden (gleicher Name, gleiche Argumente, gleicher Rückgabetyp) kann durch modifier final verhindert werden Beispiel: Gehaltsberechnung Klasse Angestellter, Methode berechneGehalt Manager bekommen festes Gehalt + Provision Programmierer bekommen nur Gehalt

© Casting von Objekten Man kann nicht jedes Objekt auf jedes andere casten nur möglich, wenn der Compiler von der Richtigkeit überzeugt ist Regeln: Cast von der Subklasse auf die Superklasse ist unnötig Zuweisung eines Objekts der Superklasse an eine Referenz der Subklasse nur mit cast, der cast funktioniert nur, wenn es sich tatsächlich um ein Objekt der Subklasse handelt Angestellter A = new Manager("Hans",50000); Manager M = A; // Compiler-Fehler Manager M = (Manager) A; // OK Programmierer P = (Programmierer) A; // Laufzeitfehler

© Abstrakte Basisklassen Klasse ist abstract, wenn mind. eine Methode abstract abstract Methode hat keine Implementierung public abstract int berechneGehalt(); Klasse kann abstract deklariert werden, auch wenn keine abstract Methoden vorkommen abstrakte Klassen können nicht instantiiert werden Subklassen müssen die abstrakten Methoden überschreiben Variablen vom Type der abstrakten Klasse können deklariert werden, müssen aber abgeleitete referenzieren

© abstrakte Basisklassen contd. Shape CircleHexagonSquare Cylinder Cube Shape ist ziemlich Abstrakt (welche Attribute),… kann (und sollte ?) deshalb als abstract Klasse implementiert werden

© Interfaces Klassen, bei denen alle Methoden abstract sind können Attribute enthalten, diese müssen dann jedoch alle static final sein können für multiple inheritance verwendet werden Definition von API's/Schnittstellen public interface EventHandler { public void HandleEvent(Event E); }... public class MyHandler implements EventHandler { public void HandleEvent(Event E) {... } }

© Zusammenfassung Kapselung erleichtert Wiederverwendung von Komponenten entspricht (in etwa) der realen Welt Vererbung erleichtert Wiederverwendung (Varianten, Spezialisierung) Hierarchien können aber auch unübersichtlich werden tiefe Hierarchien deshalb heute eher unüblich eher komponentenbasierte Ansätze Polymorphie generische Programmierung macht Code übersichtlicher (Fallunterscheidungen)