02 - Klassen Klassen. 02 - Klassen2 Arten von Klassen in JAVA Reale Klassen (Klassen) Abstrakte...

Click here to load reader

  • date post

    05-Apr-2015
  • Category

    Documents

  • view

    115
  • download

    3

Embed Size (px)

Transcript of 02 - Klassen Klassen. 02 - Klassen2 Arten von Klassen in JAVA Reale Klassen (Klassen) Abstrakte...

  • Folie 1
  • 02 - Klassen Klassen
  • Folie 2
  • 02 - Klassen2 Arten von Klassen in JAVA Reale Klassen (Klassen) Abstrakte Klassen Interface Interne Klassen Anonyme Klassen
  • Folie 3
  • 02 - Klassen3 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 Initialisierungsblcke Objektinitialisierungsblcke Konstruktoren Methoden interne Klassen
  • Folie 4
  • 02 - Klassen4 Objektinitialisierunsblock Syntax: Im Klassenrumpf enthaltener Programmblock { } Alle Objektinitialisierungsblcke werden in der gegebenen Reihenfolge bei der Initialisierung eines Objektes (new ) vor dem Konstruktor abgearbeitet.
  • Folie 5
  • 02 - Klassen5 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(); } }
  • Folie 6
  • 02 - Klassen6 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
  • Folie 7
  • 02 - Klassen7 Anwendung von Klassen Klassen sind die Basis fr alle Objekte. Nur von Klassen und internen Klassen knnen mehrere Objekte erzeugt werden. Klassen sind die Basis fr die Kapselung der Daten.
  • Folie 8
  • 02 - Klassen8 Abstrakte Klassen Abstrakte Klasse werden durch das Schlsselwort abstract gekennzeichnet. Abstrakte Klassen knnen abstrakte Methoden enthalten. Diese werden ebenfalls durch das Schlsselwort abstract gekennzeichnet und haben statt des Krpers ({...}) ein Zeichen ;. Von abstrakten Klassen knnen keine Objekte erzeugt werden! Es muss zunchst eine konkrete Klasse abgeleitet werden von der dann Objekte erzeugt werden knnen. Abstrakte Klassen knnen Konstruktoren enthalten, dies knnen bei den Konstruktoren der abgeleiteten Klassen verwendet werden. Die Konstruktoren selbst drfen nicht abstrakt sein!
  • Folie 9
  • 02 - Klassen9 Beispiel: AbstrakteKlassenB1 abstract public class AbstrakteKlassenB1 { AbstrakteKlassenB1() { System.out.println("AbstrakteKlassenB1.Konstruktor"); } AbstrakteKlassenB1(int i) { System.out.println("AbstrakteKlassenB1.Konstruktor(int)"); } abstract void methode(); }
  • Folie 10
  • 02 - Klassen10 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(); } }
  • Folie 11
  • 02 - Klassen11 Ausgabe von AbstrakteKlassenB2 main AbstrakteKlassenB1.Konstruktor AbstrakteKlassenB2.Konstruktor AbstrakteKlassenB2.methode AbstrakteKlassenB1.Konstruktor(int) AbstrakteKlassenB2.Konstruktor(int) AbstrakteKlassenB2.methode
  • Folie 12
  • 02 - Klassen12 Anwendung von abstrakten Klassen Mit Hilfe abstrakter Klassen knnen gemeinsame Eigenschaften unterschiedlicher Klassen gemeinsam definiert werden. Diese knnen bei Bedarf in abgeleiteten Klassen modifiziert werden. Abstrakte Methoden garantieren, dass in ableiteten realen Klassen diese Methoden implementiert werden.
  • Folie 13
  • 02 - Klassen13 Interface Interface sind abstrakte Klassen, die neben bestimmten Attributen ausschlielich abstrakte Methoden enthalten. Interface definieren die Schnittstellen zu den Methoden. Nicht die Implementierungen. Interface beantworten also ausschlielich die Frage: Wie benutzt man die im Interface definierten Methoden? und nicht die Fragen Was tun diese Methoden? und Wie erfllen sie Ihre Funktion? Interface bieten die Mglichkeit der Mehrfachvererbung.
  • Folie 14
  • 02 - Klassen14 Beispiel: geometrische Objekte Es sollen Klassen entwickelt werden, die verschiedene geometrische Objekte beschreiben: Point Rectangle Circle Oval.... Fr jedes derartige Objekt soll es mglich sein, die Flche sowie ein umschreibendes Rechteck zu berechnen. Interface GeometricalObject
  • Folie 15
  • 02 - Klassen15 Interface GeometricalObject interface GeometricalObject { Rectangle umschreibendesRechteck(); double flaeche(); } Das Interface bentigt Rectangle. Rectangle soll aber erst als Implementierung von GeometricalObject entwickelt werden. wir definieren uns ein Dummy-Klasse Rectangle public class Rectangle { }
  • Folie 16
  • 02 - Klassen16 Die Klasse Point Ein Punkt wird durch seine beiden Koordinaten beschrieben. Diese Koordinaten liefern alle notwendigen Informationen. Wir knnen also Point direkt von GeometricalObject ableiten.
  • Folie 17
  • 02 - Klassen17 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 ); } }
  • Folie 18
  • 02 - Klassen18 Wir bentigen 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 Flchenberechnung und bei der blichen Nutzung. Wir definieren eine abstrakte Klasse RectangularObject.
  • Folie 19
  • 02 - Klassen19 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 ); } }
  • Folie 20
  • 02 - Klassen20 Die Klasse ist immer noch abstrakt, da die Methode flaeche nicht implementiert ist. Wir bentigen 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) {}; }
  • Folie 21
  • 02 - Klassen21 Die Klasse Rectangle Von der Klasse RectangularObject knnen wir nun die Klasse Rectangle ableiten. Es sind die Konstruktoren, zu schreiben und die Methode flaeche zu implementieren. Dabei bercksichtigen 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); } }
  • Folie 22
  • 02 - Klassen22 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; } }
  • Folie 23
  • 02 - Klassen23 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() { } }
  • Folie 24
  • 02 - Klassen24 Struktur des Beispiels GeometricalObject PointRectangularObject RectangleOval Circle
  • Folie 25
  • 02 - Klassen25 Vorteile der Konstruktion Das Interface GeometricalObject garantiert, dass fr alle geometrischen Objekte die Methoden flaeche und umschreibendesRechteck definiert sind. Die abstrakte Klasse RectangularObject ermglicht es bestimmte Attribute (lo, ru), Methoden (umschreibendesRechteck) und Konstruktoren fr 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 unbersichtlich, da die Methoden einer Klasse ggf. in Elternklassen definiert sind.
  • Folie 26