Klassen 02 - Klassen

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

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

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

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"); 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

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

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

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

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

public class AbstrakteKlassenB2 extends AbstrakteKlassenB1 { 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

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

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

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

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

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

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

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

public class Rectangle { public Rectangle ( Point p) {}; } 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

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

public class Rectangle { public Rectangle ( Point p) {}; 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

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

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

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

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

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

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

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(); b.modi(); 02 - Klassen

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

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

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

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