imported>RolandIllig: /* Geometrie */ typo

2023-01-28T21:15:32Z

Geometrie: typo

Neue Seite

Eine '''abstrakte Klasse''' bezeichnet in der [[Objektorientierte Programmierung|objektorientierten Programmierung]] eine spezielle [[Klasse (Programmierung)|Klasse]], welche sich per Definition nicht instanziieren lässt, d. h., es lassen sich keine [[Objekt (Programmierung)|Objekte]] von ihr erzeugen, und dient somit lediglich als Strukturelement innerhalb einer Klassenhierarchie. Innerhalb von abstrakten Klassen besteht die Möglichkeit, abstrakte Methoden, also [[Methode (Programmierung)|Methoden]] ohne Implementierung nur mit der [[Signatur (Programmierung)|Signatur]], zu deklarieren.

[[Schnittstelle (Programmierung)|Schnittstellen]] sind rein abstrakte [[Klasse (Objektorientierung)|Klassen]], die nur Methodensignaturen deklarieren. Eine Klasse gilt dagegen bereits als abstrakt, sobald eine Methode vorhanden ist, die durch eine [[Vererbung (Programmierung)|erbende]] Klasse implementiert werden muss. In einer abstrakten Klasse können auch [[Variable (Programmierung)|Variablen]] definiert und [[Methode (Programmierung)|Methoden]] implementiert werden.

Als [[Basisklasse|Basisklassen]] in einer Klassenhierarchie können abstrakte Klassen grundlegende Eigenschaften ihrer [[Abgeleitete Klasse|abgeleiteten Klassen]] festlegen, ohne diese bereits konkret zu implementieren. Leitet eine [[Klasse (Objektorientierung)|Klasse]] von einer abstrakten Klasse ab, müssen alle [[Vererbung (Programmierung)|vererbten]] abstrakten [[Methode (Programmierung)|Methoden]] überschrieben und implementiert werden, damit die erbende Klasse selbst nicht abstrakt ist.

Abstrakte Klassen können nicht selbst instanziiert werden, nur Spezialisierungen von diesen. Dennoch können Teile des [[Quelltext]]es allgemein gehalten und nur unter Verwendung der Eigenschaften des abstrakten Basistyps implementiert werden. Durch [[Polymorphie (Programmierung)|Polymorphie]] kommen dabei die speziellen Implementierungen der nicht abstrakten [[Abgeleitete Klasse|abgeleiteten Klassen]] zur Ausführung.

== Beispiele ==
=== Geometrie ===
Zweidimensionale [[Figur (Geometrie)|geometrische Figuren]] haben gemeinsam, dass sie über einen [[Flächeninhalt]] verfügen. Je nach Figur wird dieser Flächeninhalt aber unterschiedlich berechnet.

Wird eine abstrakte [[Basisklasse]] namens <code>Geometrisch</code> angelegt, kann mit einem Methodenrumpf für eine Funktion <code>berechneFlaecheninhalt</code> festgelegt werden, dass alle [[Abgeleitete Klasse|abgeleiteten Klassen]] eine entsprechende [[Methode (Programmierung)|Methode]] implementieren müssen. Zum Beispiel wird eine [[Klasse (Objektorientierung)|Klasse]] <code>Rechteck</code> die Länge mit der Breite multiplizieren, in einer Klasse <code>RechtwinkligesDreieck</code> wird die Länge mit der Höhe multipliziert und das Produkt halbiert.

Durch die Klassenhierarchie mit einer abstrakten [[Basisklasse]] hat man sich die Möglichkeit eröffnet, andernorts Funktionen zu erstellen, die ein Objekt vom Typ <code>Geometrisch</code> entgegennehmen und auf ihm die Funktion <code>berechneFlaecheninhalt</code> aufrufen, völlig unabhängig davon, ob es sich um [[Dreieck|Dreiecke]], [[Rechteck|Rechtecke]] oder [[Kreis|Kreise]] handelt. Die Funktionen sind somit für sämtliche [[Geometrische Figur|geometrischen Figuren]] nutzbar und weisen einen hohen Grad an Flexibilität und Wiederverwendbarkeit auf.

==== Programmbeispiel ====
Die folgenden Beispiele sind in der [[Programmiersprache]] [[Java (Programmiersprache)|Java]] geschrieben. Als [[Datentyp]] wird eine [[Gleitkommazahl]] ''double'' verwendet.

'''A.''' Die Definition der [[Schnittstelle (Objektorientierung)|Schnittstelle]]:
<syntaxhighlight lang="java">
public interface Geometrisch
{
public abstract double berechneFlaecheninhalt();
}
</syntaxhighlight>

'''B.''' Erstellen einer [[Basisklasse]] für Höhen- und Längenangabe:
<syntaxhighlight lang="java">
public abstract class BasisFigur implements Geometrisch
{
double laenge;
double hoehe;

// Konstruktor
public BasisFigur(final double LAENGE, final double HOEHE)
{
laenge = LAENGE;
hoehe = HOEHE;
}

public double getLaenge()
{
return laenge;
}

public void setLaenge(final double LAENGE)
{
laenge = LAENGE;
}

public double getHoehe()
{
return hoehe;
}

public void setHoehe(final double HOEHE)
{
hoehe = HOEHE;
}
}
</syntaxhighlight>

'''C.''' Beispielhafte Implementierung einer ''konkreten'' Figur '''Rechteck''':
<syntaxhighlight lang="java">
public class Rechteck extends BasisFigur
{
// Konstruktor
public Rechteck(final double LAENGE, final double HOEHE)
{
super(LAENGE, HOEHE);
}

@Override
public double berechneFlaecheninhalt()
{
return getLaenge() * getHoehe();
}
}
</syntaxhighlight>

'''D.''' Beispielhafte Implementierung einer weiteren ''konkreten'' Figur '''rechtwinkliges Dreieck''':
<syntaxhighlight lang="java">
public class RechtwinkligesDreieck extends BasisFigur
{
// Konstruktor
public RechtwinkligesDreieck(final double LAENGE, final double HOEHE)
{
super(LAENGE, HOEHE);
}

@Override
public double berechneFlaecheninhalt()
{
return (getLaenge() * getHoehe()) / 2;
}
}
</syntaxhighlight>

'''E.''' Eine Beispielklasse zur erweiterten Verwendung, welche [[Verknüpfung (Mathematik)|Operationen]] auf Basis der [[Schnittstelle (Objektorientierung)|Schnittstelle]] ausführt:
<syntaxhighlight lang="java">
public class GeometrischerRechner
{
public static double berechneGesamtFlaecheninhalt(final Geometrisch[] figuren)
{
double ergebnis = 0;
for (Geometrisch figur : figuren)
{
ergebnis += figur.berechneFlaecheninhalt();
}
return ergebnis;
}
}
</syntaxhighlight>

'''F.''' Beispiel einer Ausführung liefert die folgende [[Klasse (Objektorientierung)|Klasse]]:
<syntaxhighlight lang="java">
public class GeometrischesFigurenBeispiel
{
public static void main(String[] args)
{
// 1.1. Erstellung einzelner Objekte
Geometrisch rechteck = new Rechteck(10, 20);
Geometrisch dreieck = new RechtwinkligesDreieck(10, 20);

// 1.2. Separate Berechnung der Flächeninhalte
System.out.println("Rechtecksfläche: " + rechteck.berechneFlaecheninhalt());
System.out.println("Dreiecksfläche: " + dreieck.berechneFlaecheninhalt());

// 2.1. Parameter für die Übergabe an GeometrischerRechner
Geometrisch[] figuren = new Geometrisch[]{rechteck, dreieck};

// 2.2. Berechnung und Ausgabe der Gesamtfläche
System.out.println("Gesamtfläche: " + GeometrischerRechner.berechneGesamtFlaecheninhalt(figuren));
}
}
</syntaxhighlight>

'''G.''' Wird dieses [[Computerprogramm|Programm]] übersetzt und ausgeführt, so erscheint in der Konsole die folgende Ausgabe:
<syntaxhighlight lang="text">
Rechtecksfläche: 200.0
Dreiecksfläche: 100.0
Gesamtfläche: 300.0
</syntaxhighlight>

=== Beispiel für den Datenbankzugriff ===
Ein klassisches Beispiel für die Anwendung abstrakter Klassen kommt aus dem Bereich der [[Datenbank]]-Anwendung. Sämtliche [[Methode (Programmierung)|Methoden]] für den Zugriff auf die Datenbank werden in einer abstrakten Klasse definiert. Für jeden Datenbank-Typ kann eine konkrete [[Klasse (Objektorientierung)|Klasse]] programmiert werden, die alle [[Vererbung (Programmierung)|geerbten]] Zugriffsmethoden implementiert. In der Anwendung muss an einer einzigen Stelle die konkret implementierte Klasse bekannt sein – dort wird das [[Objekt (Programmierung)|Objekt]] erzeugt. Anschließend wird es im gesamten restlichen [[Programmcode]] als Objekt vom Typ der abstrakten Klasse behandelt.

Die konkrete [[Klasse (Objektorientierung)|Klasse]] kann als Eigenschaft, einer sogenannten ''Property'', in einer [[Datei]] außerhalb des [[Programmcode|Programmcodes]] angegeben werden. So ist kein erneutes Übersetzen nach ausgetauschter [[Datenbank]] nötig und es entsteht eine hohe Wiederverwendbarkeit der Applikation.

== Weblinks ==
* [https://docs.oracle.com/javase/tutorial/java/IandI/abstract.html Abstract Methods and Classes]
* [https://www.w3schools.com/java/java_abstract.asp Java Abstract Classes and Methods]
* [https://www.geeksforgeeks.org/abstract-classes-in-java/ Abstract Classes in Java]

[[Kategorie:Objektorientierte Programmierung]]

[[sv:Klass (programmering)#Abstrakt klass]]

Abstrakte Klasse - Versionsgeschichte

imported>RolandIllig: /* Geometrie */ typo