Klassen

1. Klassen 02 - Klassen

2. Arten von Klassen in JAVA • Reale Klassen (Klassen) • Abstrakte Klassen • Interface • Interne Klassen • Anonyme Klassen 02 - Klassen

3. Reale Klassen • Aufbau: • Klassenkopf • Name der Klasse • Kennzeichnung als finale Klasse (final) • Modifizierer (public) • Ableitung von anderen Klassen (extends) • Implementierung von Interfaces (implements) • Klassenrumpf • Attribute • statische Initialisierungsblöcke • Objektinitialisierungsblöcke • Konstruktoren • Methoden • interne Klassen 02 - Klassen

4. Objektinitialisierunsblock • Syntax: Im Klassenrumpf enthaltener Programmblock{ … } • Alle Objektinitialisierungsblöcke werden in der gegebenen Reihenfolge bei der Initialisierung eines Objektes (new …) vor dem Konstruktor abgearbeitet. 02 - Klassen

5. Beispiel : KlassenB1 public class KlassenB1 { KlassenB1() { System.out.println("Konstruktor"); } { System.out.println("Objektinitialisierungsblock Nr. 1"); } static { System.out.println("statischer Initialisierungsblock Nr. 1"); } { System.out.println("Objektinitialisierungsblock Nr. 2"); } static { System.out.println("statischer Initialisierungsblock Nr. 2"); } public static void main(String[] args) { System.out.println("main"); KlassenB1 k1 = new KlassenB1(); KlassenB1 k2 = new KlassenB1(); KlassenB1 k3 = new KlassenB1(); } } 02 - Klassen

6. Ausgabe von KlassenB1 statischer Initialisierungsblock Nr. 1 statischer Initialisierungsblock Nr. 2 main Objektinitialisierungsblock Nr. 1 Objektinitialisierungsblock Nr. 2 Konstruktor Objektinitialisierungsblock Nr. 1 Objektinitialisierungsblock Nr. 2 Konstruktor Objektinitialisierungsblock Nr. 1 Objektinitialisierungsblock Nr. 2 Konstruktor 02 - Klassen

7. Anwendung von Klassen • Klassen sind die Basis für alle Objekte. • Nur von Klassen und internen Klassen können mehrere Objekte erzeugt werden. • Klassen sind die Basis für die Kapselung der Daten. 02 - Klassen

8. Abstrakte Klassen • Abstrakte Klasse werden durch das Schlüsselwort „abstract“ gekennzeichnet. • Abstrakte Klassen können abstrakte Methoden enthalten. Diese werden ebenfalls durch das Schlüsselwort „abstract“ gekennzeichnet und haben statt des Körpers ({...}) ein Zeichen „;“ . • Von abstrakten Klassen können keine Objekte erzeugt werden! • Es muss zunächst eine konkrete Klasse abgeleitet werden von der dann Objekte erzeugt werden können. • Abstrakte Klassen können Konstruktoren enthalten, dies können bei den Konstruktoren der abgeleiteten Klassen verwendet werden. • Die Konstruktoren selbst dürfen nicht abstrakt sein! 02 - Klassen

9. Beispiel: AbstrakteKlassenB1 abstract public class AbstrakteKlassenB1 { AbstrakteKlassenB1() { System.out.println("AbstrakteKlassenB1.Konstruktor"); } AbstrakteKlassenB1(int i) { System.out.println("AbstrakteKlassenB1.Konstruktor(int)"); } abstract void methode(); } 02 - Klassen

10. public class AbstrakteKlassenB2 extends AbstrakteKlassenB1 { AbstrakteKlassenB2() { System.out.println("AbstrakteKlassenB2.Konstruktor"); } AbstrakteKlassenB2(int i) { super(i); System.out.println("AbstrakteKlassenB2.Konstruktor(int)"); } void methode() { System.out.println("AbstrakteKlassenB2.methode"); } public static void main(String[] args) { System.out.println("main"); AbstrakteKlassenB2 a = new AbstrakteKlassenB2(); a.methode(); AbstrakteKlassenB2 b = new AbstrakteKlassenB2(1); b.methode(); } } 02 - Klassen

11. Ausgabe von AbstrakteKlassenB2 main AbstrakteKlassenB1.Konstruktor AbstrakteKlassenB2.Konstruktor AbstrakteKlassenB2.methode AbstrakteKlassenB1.Konstruktor(int) AbstrakteKlassenB2.Konstruktor(int) AbstrakteKlassenB2.methode 02 - Klassen

12. Anwendung von abstrakten Klassen • Mit Hilfe abstrakter Klassen können gemeinsame Eigenschaften unterschiedlicher Klassen gemeinsam definiert werden. • Diese können bei Bedarf in abgeleiteten Klassen modifiziert werden. • Abstrakte Methoden garantieren, dass in ableiteten realen Klassen diese Methoden implementiert werden. 02 - Klassen

13. Interface • Interface sind abstrakte Klassen, die neben bestimmten Attributen ausschließlich abstrakte Methoden enthalten. • Interface definieren die Schnittstellen zu den Methoden. Nicht die Implementierungen. • Interface beantworten also ausschließlich die Frage:„Wie benutzt man die im Interface definierten Methoden?“ und nicht die Fragen „Was tun diese Methoden?“ und „Wie erfüllen sie Ihre Funktion?“ • Interface bieten die Möglichkeit der Mehrfachvererbung. 02 - Klassen

14. Beispiel: geometrische Objekte • Es sollen Klassen entwickelt werden, die verschiedene geometrische Objekte beschreiben: • Point • Rectangle • Circle • Oval • .... • Für jedes derartige Objekt soll es möglich sein, die Fläche sowie ein umschreibendes Rechteck zu berechnen. Interface GeometricalObject 02 - Klassen

15. Interface GeometricalObject interface GeometricalObject { Rectangle umschreibendesRechteck(); double flaeche(); } • Das Interface benötigt „Rectangle“. Rectangle soll aber erst als Implementierung von GeometricalObject entwickelt werden. wir definieren uns ein Dummy-Klasse Rectangle public class Rectangle { } 02 - Klassen

16. Die Klasse Point • Ein Punkt wird durch seine beiden Koordinaten beschrieben. • Diese Koordinaten liefern alle notwendigen Informationen. • Wir können also Point direkt von GeometricalObject ableiten. 02 - Klassen

17. Klasse Point public class Point implements GeometricalObject { double x, y; public Point (double x, double y) { this.x=x; this.y=y; } public Point () { this(0.0, 0.0); } public double flaeche() { return 0.0; } public double getX() { return x; } public double getY() { return y; } public Rectangle umschreibendesRechteck() { return new Rectangle( this ); } } 02 - Klassen

18. Wir benötigen einen Konstruktor von Rectangle, der ein Point-Objekt erwartet. Wir erweitern unser Dummy-Rectangle public class Rectangle { public Rectangle ( Point p) {}; } • Die Objekte Rectangle, Circle und Oval haben die gemeinsame Eigenschaft eindeutig durch das umschreibende Rechteck definiert zu sein. Es bietet sich an dieses umschreibende Rechteck als Basis der Definition zu nehmen. Die Objekte unterscheiden sich aber z.B. bei der Flächenberechnung und bei der „üblichen“ Nutzung. Wir definieren eine abstrakte Klasse RectangularObject. 02 - Klassen

19. Abstrakte Klasse:RectangularObject public abstract class RectangularObject implements GeometricalObject { Point lo, ru; public RectangularObject (Point lo, Point ru) { this.lo=lo; this.ru=ru; } public RectangularObject (Point p) { this.lo=p; this.ru=p; } public RectangularObject () { this(new Point(), new Point(1.0, 1.0)); } public Point getLo() { return lo; } public Point getRu() { return ru; } public Rectangle umschreibendesRechteck() { return new Rectangle( lo, ru ); } } 02 - Klassen

20. Die Klasse ist immer noch abstrakt, da die Methode flaeche nicht implementiert ist. • Wir benötigen einen Konstruktor von Rectangle, der zwei Point-Objekte als Parameter erwartet. Wir erweitern unser Dummey-Rectangle public class Rectangle { public Rectangle ( Point p) {}; public Rectangle ( Point p1, Point p2) {}; } 02 - Klassen

21. Die Klasse Rectangle • Von der Klasse RectangularObject können wir nun die Klasse Rectangle ableiten. • Es sind die Konstruktoren, zu schreiben und die Methode flaeche zu implementieren. • Dabei berücksichtigen wir die Erfordernisse, die wir in dem Dummy-Rectangle realisiert haben. public class Rectangle extends RectangularObject { public Rectangle(Point lo, Point ru) { super(lo, ru); } public Rectangle(Point p) { super(p); } public Rectangle() { } public double flaeche() { return (ru.x-lo.x)*(ru.y-lo.y); } } 02 - Klassen

22. Die Klasse Oval public class Oval extends RectangularObject { Point mp; double a, b; public Oval(Point mp, double a, double b) { super(new Point(mp.x-a, mp.y-b), new Point(mp.x+a, mp.y+b)); this.mp=mp; this.a=a; this.b=b; } public Oval(Point lo, Point ru) { super(lo, ru); this.mp=new Point((lo.x+ru.x)*0.5, (lo.y+ru.y)*0.5); this.a=(ru.x-lo.x)*0.5; this.b=(ru.y-lo.y)*0.5; } public Oval() { this(new Point(), 1.0, 1.0); } public double flaeche() { return Math.PI*a*b; } } 02 - Klassen

23. Die Klasse Circle • Ein Kreis ist ein Oval, das zwei gleiche Halbachsen hat. Die Klasse Circle kann einfach von Oval abgeleitet werden. public class Circle extends Oval { public Circle(Point mp, double r) { super(mp, r, r); } public Circle() { } } 02 - Klassen

24. Struktur des Beispiels GeometricalObject Point RectangularObject Rectangle Oval Circle 02 - Klassen

25. Vorteile der Konstruktion • Das Interface GeometricalObject garantiert, dass für alle geometrischen Objekte die Methoden flaeche und umschreibendesRechteck definiert sind. • Die abstrakte Klasse RectangularObject ermöglicht es bestimmte Attribute (lo, ru), Methoden (umschreibendesRechteck) und Konstruktoren für alle abgeleiteten Klassen zu definieren. • Das vereinfacht und vereinheitlicht die abgeleiteten Klassen. • Prinzip: Der Programmcode soll nur einmal vorkommen. einfachere Entwicklung und Pflege • Problem: Die Gesamtkonstruktion ist etwas unübersichtlich, da die Methoden einer Klasse ggf. in Elternklassen definiert sind. 02 - Klassen

26. Interne Klassen • Interne Klassen sind Klassen, die innerhalb einer anderen Klasse definiert sind. class Klasse { ... class InterneKlasse { ... } ... } • Interne Klasse können public sein, also von außen sichtbar. • Der vollständige Name der Klasse lautet : Klasse.InterneKlasse . • Interne Klassen haben vollen Zugriff auf die Daten der Klasse auch wenn diese z.B. als private definiert sind. • Nur statische interne Klassen können direkt instanziiert werden. 02 - Klassen

27. Beispiel für InterneKlassen public class InterneKlasseB1 { private int i; public InterneKlasseB1(int i) { this.i=i; } public int getI() { return i; } public InterneKlasse test() { return new InterneKlasse(); } public class InterneKlasse { public void modi() { i=12345; } } } class InterneKlasseB2 { public static void main(String[] args) { InterneKlasseB1 a = new InterneKlasseB1(1); System.out.println("i = "+a.getI()); InterneKlasseB1.InterneKlasse b = a.test(); System.out.println("i = "+a.getI()); b.modi(); System.out.println("i = "+a.getI()); } } 02 - Klassen

28. Anwendung interner Klassen • Interne Klassen sind ein gutes Mittel zur Strukturierung, da interne Strukturen erzeugt werden können, die vollen Zugriff auf alle Daten der Klasse haben. • Interne Klassen helfen dabei die Datenkapselung aufrecht zu erhalten. • Mit Hilfe interner Klassen können Interface implementiert werden, die auf interne Daten Zugriff haben müssen, ohne dass die Kapselung aufgegeben werden muss. 02 - Klassen

29. Anonyme Klasse • Anonyme Klassen erlauben es Objekte zu erzeugen und dabei die Elternklasse gleichzeitig zu modifizieren. • Z.B.: MouseListener ml = new MouseAdapter() { public void mouseClicked(MouseEvent e) { ... } }; • Es wird an der selben Stelle des Programms die Klasse modifiziert und ein Objekt der modifizierten Klasse erzeugt. • Auf die modifizierte Klasse kann nicht wieder zugegriffen werden. D.h. es kann nur ein Objekt dieser Klasse erzeugt werden. • Für die anonyme Klasse kann kein Konstruktor definiert werden, d.h. es wird immer der Konstruktor der Elternklasse verwendet. Statt dessen können Objektinitialisierungsblöcke verwendet werden. 02 - Klassen

30. Anonyme Klassen sind spezielle interne Klassen. • Anonyme Klassen werden auch in Aufrufen von Methoden verwendet. • Z.B.: JButton b = new JButton(); b.addActionListener( new ActionListener(){ public void actionPerformed(ActionEvent e) { ... } }); 02 - Klassen

31. Anwendung von anonymen Klassen • Wenn eine schon definierte Klasse nur wenig modifiziert werden soll. • Wenn von der abgeleiteten Klasse nur ein Objekt erzeugt werden soll. • Wenn die Übersichtlichkeit des Programms nur wenig leidet. 02 - Klassen