B.Schiller am 13. Juli 2016 um 06:45 Uhr

2016-07-13T06:45:05Z

B.Schiller am 11. Juli 2016 um 07:06 Uhr

2016-07-11T07:06:35Z

B.Schiller am 4. Juli 2016 um 07:06 Uhr

2016-07-04T07:06:44Z

B.Schiller am 4. Juli 2016 um 07:03 Uhr

2016-07-04T07:03:07Z

B.Schiller: Die Seite wurde neu angelegt: „Die Vererbung ist eines der grundlegenden Konzepte der Objektorientierung. Sie dient dazu, aufbauend auf bereits existierenden Klassen neue zu schaffen, wobei …“

2016-05-24T08:39:20Z

Die Seite wurde neu angelegt: „Die Vererbung ist eines der grundlegenden Konzepte der Objektorientierung. Sie dient dazu, aufbauend auf bereits existierenden Klassen neue zu schaffen, wobei …“

Neue Seite

Die Vererbung ist eines der grundlegenden Konzepte der Objektorientierung. Sie dient dazu, aufbauend auf bereits existierenden Klassen neue zu schaffen, wobei die Beziehung zwischen ursprünglicher und neuer Klasse - anders als bei einer Assoziation - dauerhaft ist. Eine neue Klasse kann dabei eine Erweiterung oder eine Einschränkung der ursprünglichen Klasse sein.<br/> Die vererbende Klasse wird meist '''Oberklasse''' (oder auch Superklasse) genannt, die erbende '''Unterklasse'''.

'''Problemstellung'''

Ein Autohändler, der sowohl mit Neu- als auch mit Gebrauchtwagen handelt, will die Fahrzeuge in einer Datenbank erfassen, wobei er die beiden Typen möglichst effizient und unabhängig voneinander abspeichern möchte. Eine Modellierung könnte zuerst einmal folgendermaßen aussehen:

[[Datei:vererbung1.JPG]]

Was hier sehr schnell auffallen dürfte, ist die Tatsache, dass die Darstellungen weitgehend übereinstimmen und der Gebrauchtwagen nur weitere Attribute enthält, die beim Neuwagen von geringem Interesse sind. Das Konzept der Vererbung ermöglicht es nun, die Klasse ''Gebrauchtwagen'' als Unterklasse der Klasse ''Auto'' zu modellieren. Dies bedeutet, dass ein Objekt alle Attribute und Methoden der Oberklasse erbt und noch weitere Attribute und Methoden erhält. In der Unified Modeling Language (UML) wird eine Vererbungsbeziehung durch einen Pfeil mit einer dreieckigen Spitze dargestellt, der von der Unterklasse zur Oberklasse zeigt. Geerbte Attribute und Methoden werden in der Darstellung der Unterklasse nicht wiederholt.

[[Datei:vererbung2.JPG]]

'''Spezialisierung und Generalisierung'''

Spezialisierung und Generalisierung sind zwei Sichtweisen des Vererbungskonzepts. Bilden wir eine neue Klasse, deren Instanzen eine Teilmenge der Instanzen der Oberklasse darstellen, sprechen wir bei der Bildung der Unterklasse von einer '''Spezialisierung''' (Konkretisierung). Fassen wir dagegen Attribute und Methoden mehrerer ähnlicher Klassen zu einer neuen Klasse zusammen, sprechen wir von einer '''Generalisierung''' (Abstraktion).

<div style="margin-left:100px; margin-top:30px; margin-bottom:30px">
[[Datei:vererbung3.JPG]]
</div>

'''Klassenhierarchien'''

In einer Klassenhierarchie werden statische Beziehungen zwischen den Klassen dargestellt. Die Darstellung ähnelt einem Stammbaum, wie wir ihn in der 6.Klasse kennengelernt haben. Die höher liegenden Klassen vererben bei Bedarf an die darunterliegenden Klassen welche wieder an Klassen unter ihnen vererben.

<u>'''Beispiel:'''</u>

Die Schulfamilie hat verschiedene Mitglieder. Es gibt Schüler, Lehrer und Eltern, die alle nicht nur Mitglieder der Schulfamilie (MdS) sind, sondern sie alle sind Personen. Alle Mitglieder der Schulfamilie erben von der Klasse ''Person'' die Attribute ''name'' und ''geburtsdatum''. Lehrer und Schüler haben dagegen weitere recht unterschiedliche Attribute. Mitglieder der Schulleitung sind zwar auch Lehrer, haben aber noch weitere Attribute, was eine Spezialisierung der Klasse Lehrer nahelegt.

<div style="margin-left:100px; margin-top:30px; margin-bottom:30px">
[[Datei:vererbung4.JPG]]
</div>

<div style="background-color:#BEE599; padding:10px; margin-bottom:30px;">

'''Aufgabe 1'''

Folgende Begriffe sollen in Form eines Klassendiagramms in eine Klassenhierarchie umgesetzt werden: <span style="color:green"> Rechteck - Kreis - Polygon - Figur - Viereck - Raute - Parallelogramm - Ellipse - Quadrat - Dreieck </span>.<br/>Wähle zu diesem Zweck geeignete Attribute für die einzelnen Klassen. Beachte dabei, welche Attribute von der bzw. den Oberklasse(n) geerbt werden.

'''Aufgabe 2'''

Das Generalisierungsbeispiel (Kraftfahrzeuge) soll erweitert werden, so dass möglichst viele Fortbewegungsmittel in der Klassenhierarchie erfasst werden. Ergänze die Klassendiagramme durch geeignete Attribute und berücksichtige dabei die Vererbungshierarchie.
</div>

'''Umsetzung in Java'''

In Java können Klassenhierarchien nur durch Spezialisierung gebildet werden: Unterklasse erweitert (''extends'') Oberklasse. Dies spiegelt sich in der Syntax wieder - die Klassendefinition der Unterklasse weist auf ihren Status als Erweiterung der Oberklasse hin:

<pre>
public class <Name der Unterklasse> extends <Name der Oberklasse>
</pre>

<u>Hinweise:</u>

* Vererbung bedeutet, dass die Unterklasse alle Attribute und Methoden von der Oberklasse übernimmt.
* Es werden keine Konstruktoren vererbt!
* Unter- und Oberklasse bieten Konstruktoren an.
* Die Unterklasse kümmert sich in ihrem Konstruktor nur um die Attribute, die in der Unterklasse deﬁniert sind.
* Damit auch die Datenfelder der Oberklasse korrekt initialisiert werden,rufen wir den Konstruktor der Oberklasse auf.
* Der Aufruf des Konstruktors der Oberklasse erfolgt mit dem Schlüsselwort '''super'''.
* Dieser Aufruf muss stets die erste Anweisung in einem Konstruktor der Unterklasse sein! Ansonsten fügt der Compiler den Aufruf eines parameterlosen Konstruktors für die Oberklasse ein.

Als Beispiel soll nun die (teilweise) Implementierung der Klassenhierarchie aus dem Schulfamilie-Beispiel dienen:

<syntaxhighlight lang="java">

public class Person {
//Attribute
private String name;
private String geburtsdatum

//Konstruktor
public person(String name, String geburtsdatum){
this.name=name;
this.geburtsdatum = geburtsdatum;
}

//Getter- und Setter-Methoden
public String getName(){
return name;
}

public String getGeburtsdatum(){
return geburtsdatum;
}

public void setName(String n){
name=n;
}

public void setGeburtsdatum(String g){
geburtsdatum = g;
}
}
</syntaxhighlight>

<syntaxhighlight lang="java">
public class MdS extends Person{
//weitere Attribute für Mitglieder der Schulfamilie
public String telefonnummer;

//Konstruktor
public MdS(String name, String geburtsdatum, String telefonnummer){
//Aufruf des Konstruktors der Oberklasse
super(name, geburtsdatum);
//Initialisierung der weiteren Variablen
this.telefonnummer=telefonnummer;
}

//weitere Getter- und Setter-Methoden
public String getTelefonnummer(){
return telefonnummer;
}

public void setTelefonnummer(String t){
telefonnummer=t;
}
}
</syntaxhighlight>

<syntaxhighlight lang="java">
public class Lehrer extends MdS{
//weitere Attribute
private String pkz;
...

//Konstruktor
public Lehrer(String name, String geburtsdatum, String telefonnummer, String pkz){
//Aufruf des Konstruktors der Oberklasse
super(name, geburtsdatum, telefonnummer);
//Initialisierung der weiteren Variablen
this.pkz = pkz;
}

//Getter-, Setter- und andere Methoden
...

public void pruefen (Schueler s){ ... }

public void verweisErteilen /Schueler s) { ... }

...
}
</syntaxhighlight>

<syntaxhighlight lang="java">
public class Schueler extends MdS {
//weitere Attribute
private String schueler-ID;

//Konstruktor
public Schueler((String name, String geburtsdatum, String telefonnummer, String schueler-ID){
//Aufruf des Konstruktors der Oberklasse
super(name, geburtsdatum, telefonnummer);
//Initialisierung der weiteren Variablen
this.schueler-ID = schueler-ID;
}

//Getter-, Setter- und andere Methoden
...

public void hausaufgabeMachen(){ ... }

public void rechenschaftsablage(){ ... }

}

</syntaxhighlight>

<u>Zur Vertiefung: </u>

<div style="margin-left:100px; margin-top:30px; margin-bottom:30px">
{{#ev:youtube|Zf-aL6gCPxQ}}
</div>

<div style="background-color:#BEE599; padding:10px; margin-bottom:30px;">
'''Aufgabe 3'''

Für eine Mitarbeiterverwaltung soll eine Klasse ''Mitarbeiter'' mit den Attributen ''Name'', ''Vorname'' und ''Gehalt'' und entsprechenden Getter-Methoden und eine Setter-Methode für das Gehalt erstellt werden. Zusätzlich werden zwei Unterklassen ''Filialleiter'' und ''Auszubildender'' angelegt. Der Filialleiter hat als zusätzliches Attribut die ''bueronummer'' und die Auszubildenden ''ausbildungsrichtung'' und ''ausbildungsbeginn''. Auch hier sind wieder geeignete Getter-Methoden bereitzustellen. Die Klasse Filialleiter erhält nun zwei zusätzliche Methoden: Die Methode ''gehaltAendern(int gehaltNeu)'' ändert das Gehalt eines Mitarbeiters und gibt anschließend folgenden (Beispiel-)Text auf der Konsole aus:
<pre>
Das Gehalt von Max Mustermann beträgt nun 3100 Euro.
</pre>
Die zweite Methode ''azubiInfo(Auszubildender a)'' soll folgenden Text auf der Konsole ausgeben:
<pre>
Der/Die Auszubildende Erna Musterfrau ist seit 01.04.2014 in der Ausbildungsrichtung Raketenpflege in unserem Betrieb beschäftigt.
</pre>

Erzeuge nun jeweils eine Instanz von Mitarbeiter, Filialleiter und Auszubildender und teste die beiden obigen Methoden in der Klasse Filialleiter. Verändere dabei zuerst das Gehalt des Mitarbeiters und dann das des Auszubildenden. Was fällt auf? Achte auch darauf, wo beim Auszubildenden die jeweils genutzten Getter-Methoden implementiert sind.

<popup name="Lösungsvorschlag">
<syntaxhighlight lang="java">

public class Mitarbeiter{
//Attribute
private String name;
private String vorname;
private int gehalt;

//Konstruktoren
public Mitarbeiter(String name, String vorname, int gehalt){
this.name=name;
this.vorname=vorname;
this.gehalt=gehalt;
}

public Mitarbeiter(String name, String vorname){
this.name=name;
this.vorname=vorname;
}

//Getter- und Setter-Methoden
public String getName(){
return name;
}

public String getVorname(){
return vorname;
}

public int getGehalt(){
return gehalt;
}

public void setGehalt(int gehaltNeu){
gehalt=gehaltNeu;
}
}
</syntaxhighlight>

<syntaxhighlight lang="java">
public class Auszubildender extends Mitarbeiter{
//weitere Attribute
private String ausbildungsrichtung;
private String ausbildungsbeginn;

//Konstruktor
public Auszubildender(String name, String vorname, int gehalt, String ausbildungsrichtung, String ausbildungsbeginn){
super(name, vorname, gehalt);
this.ausbildungsrichtung=ausbildungsrichtung;
this.ausbildungsbeginn=ausbildungsbeginn;
}

//Getter-Methoden
public String getAusbildungsrichtung(){
return ausbildungsrichtung;
}

public String getAusbildungsbeginn(){
return ausbildungsbeginn;
}
}
</syntaxhighlight>

<syntaxhighlight lang="java">
public class Filialleiter extends Mitarbeiter{
//zusätzliche Attribute
private String bueronr;

//Konstruktor
public Filialleiter(String name, String vorname, int gehalt, String bueronr){
super(name, vorname, gehalt);
this.bueronr=bueronr;
}

//Getter- und Setter-Methoden
public String getBueronr(){
return bueronr;}

public void setBueronr(String bueronrNeu){
bueronr=bueronrNeu;
}

//weitere Methoden
public void gehaltAendern(Mitarbeiter m, int gehaltNeu){
m.setGehalt(gehaltNeu);
System.out.println("Das Gehalt von "+m.getVorname()+" "+m.getName()+" beträgt nun "+m.getGehalt()+" Euro.");
}

public void azubiInfo(Auszubildender a){
System.out.println("Der/Die Auszubildende "+a.getVorname()+" "+a.getName()+" arbeitet seit "+a.getAusbildungsbeginn()+" in der Ausbildungsrichtung "+a.getAusbildungsrichtung()+" im Betrieb.");
}
}

</syntaxhighlight>
</popup>

</div>

'''Polymorphie'''

In der Lösung von Aufgabe 3 sind wir auf das Phänomen gestoßen, dass der ''Filialleiter'' das Gehalt eines ''Auszubildenden'' erhöhen konnte, obwohl die entsprechende Methode einen Parameterwert vom Typ ''Mitarbeiter'' verlangt hat. Dies ist dem Konzept der Polymorphie (griech. Vielgestaltigkeit) geschuldet. Dies bedeutet vereinfacht: '''Alles, was den deklarierten Typ der Referenzvariable ''erweitert'', kann der Referenzvariable ''zugewiesen'' werden.'''

<syntaxhighlight lang="java">
public class Kfz {

public KfZ() { ... }

public void info(){
System.out.println("Ich bin ein Kraftfahrzeug.");
}
}
</syntaxhighlight>

<syntaxhighlight lang="java">
public class Lkw extends Kfz {

public Lkw() { ... }

public void info(){
System.out.println("Ich bin ein Lastkraftwagen.");
}
}
</syntaxhighlight>

<syntaxhighlight lang="java">
public class Pkw extends Kfz {

public Pkw() { ... }

public void info(){
System.out.println("Ich bin ein Personenkraftwagen.");
}
}
</syntaxhighlight>

<syntaxhighlight lang="java">
public class Test(){

public Test() {
Kfz k = new Kfz();
Kfz l = new Lkw();
Kfz p = new Pkw();

Lkw l2 = new Lkw();
Pkw p2 = new Pkw();

k.info();
l.info();
p.info();

l2.info();
p2.info()
}
}
</syntaxhighlight>

Die Ausgabe sieht nun folgendermaßen aus:

<pre>
Ich bin ein Kraftfahrzeug.
Ich bin ein Lastkraftwagen.
Ich bin ein Personenkraftwagen.
Ich bin ein Lastkraftwagen.
Ich bin ein Personenkraftwagen.
</pre>

Auch wenn im zweiten und dritten Fall der Variable vom Typ ''Kfz'' eine Instanz einer Unterklasse zugeordnet wird, greift das Programm auf die entsprechende Methode ''info()'' der Unterklassen zu.

<u>Zur Vertiefung: </u>

<div style="margin-left:100px; margin-top:30px; margin-bottom:30px">
{{#ev:youtube|w4U-MkcLunU}}
</div>

'''Überschreiben von Methoden'''

Eine Unterklasse kann durch Vererbung die sichtbaren Eigenschaften ihrer Oberklasse erben. Sie kann nun wiederum Methoden hinzufügen. Besitzt eine Unterklasse eine Methode mit dem gleichen Methodennamen und der exakten Parameterliste (also der gleichen ''Signatur'') wie schon die Oberklasse, so überschreibt die Unterklasse die Methode der Oberklasse. Implementiert die Unterklasse die Methode neu, so sagt sie auf diese Weise: ''"Ich will es aber anders machen!."'' (siehe Methode ''info()'' im obigen Beispiel) Die überschreibende Methode der Unterklasse kann demnach den Programmcode spezialisieren und Eigenschaften nutzen, die in der Oberklasse nicht bekannt sind. Die überschriebene Methode der Oberklasse ist dann erst einmal aus dem Rennen, und ein Methodenaufruf auf einem Objekt der Unterklasse würde die überschreibende Methode aufrufen.

<u>Zur Vertiefung: </u>

<div style="margin-left:100px; margin-top:30px; margin-bottom:30px">
{{#ev:youtube|n-3rn0xXBgY}}
</div>

<div style="background-color:#BEE599; padding:10px; margin-bottom:30px;">
'''Aufgabe 4'''

Es sollen drei Klassen erstellt werden: '''Viereck''', '''Rechteck''' als Unterklasse von ''Viereck'' und '''Quadrat''' als Unterklasse von ''Rechteck''. Jede der Klassen erhält eine Methode ''umfang()'', die die effizienteste Methode der Berechnung des Umfangs für die einzelne Figur nutzt. Achte insbesondere darauf, welche Konstruktoren in der jeweiligen Oberklasse implementiert werden müssen (Die Fehlermeldung in BlueJ ist dabei hilfreich). Teste in einer vierten Klasse die Umsetzung mit folgendem Code (Ausgabe in der Form ''"Ich bin ein Rechteck. Umfang: 45"''):

<syntaxhighlight lang="java">
public class Test{

public Test(){
Viereck v = new Viereck(2,3,4,5);
Viereck r = new Rechteck(2,3);
Viereck q = new Quadrat (3);

Rechteck r2 = new Rechteck(2,3);
Quadrat q2 = new Quadrat(3);

v.umfang();
r.umfang();
q.umfang();
q.flaeche();
r2.umfang();
q2.umfang();
q2.flaeche();

}
}
</syntaxhighlight>

Warum führt der Aufruf ''q.flaeche()'' zu einer Fehlermeldung?

<popup name="Lösungsvorschlag">
<syntaxhighlight lang="java">
public class Viereck {
//Attribute - public um direkten Zugriff durch die Unterklasse zu ermöglichen
public int a;
public int b;
public int c;
public int d;

public Viereck(int a, int b, int c, int d){
this.a=a;
this.b=b;
this.c=c;
this.d=d;
}

public Viereck(int a, int b){
this.a=a;
this.b=b;
c=a;
d=b;
}

public Viereck(int a){
this.a=a;
b=a;
c=a;
d=a;
}

public void umfang(){
int u=a+b+c+d;
System.out.println("Ich bin ein Viereck. Umfang = "+u);
}

}
</syntaxhighlight>

<syntaxhighlight lang="java">
public class Rechteck extends Viereck {

public Rechteck(int a, int b){
super(a,b);
}

public Rechteck(int a){
super(a);
}

public void umfang(){
int u=2*a + 2*b;
System.out.println("Ich bin ein Rechteck. Umfang = "+u);
}

}
</syntaxhighlight>

<syntaxhighlight lang="java">
public class Quadrat extends Rechteck {

public Quadrat(int a){
super(a);
}

public void umfang(){
int u=2*a + 2*b;
System.out.println("Ich bin ein Quadrat. Umfang = "+u);
}

public void flaeche (){
int f=a*a;
System.out.println("Ich bin ein Quadrat. Flaeche = "+f);
}
}
</syntaxhighlight>

q ist vom Datentyp ''Viereck''. Die Methode ''flaeche()'' ist aber im Gegensatz zur Methode ''umfang()'' in der Klasse ''Viereck'' nicht implementiert, weshalb das Programm auch nicht danach sucht, ob die Methode nicht vielleicht in der Unterklasse überschrieben wurde.
</popup>

</div>

'''Die Sichtbarkeit ''protected'''''

Eine Unterklasse erbt alle sichtbaren Eigenschaften, d.h. alle Eigenschaften deren Zugriffsrecht ''public'' ist. Die Vererbung kann durch ''private'' eingeschränkt werden, dann sieht keine andere Klasse die Eigenschaften, weder fremde noch Unterklassen. Daneben kommt nun noch eine weitere Sichtbarkeit hinzu: '''''protected'''''. '''''protected'''''-Eigenschaften werden an alle Unterklassen vererbt.

'''Abstrakte Klassen'''

In Java ist es möglich, abstrakte Methoden zu definieren. Klassen, die solche abstrakten Methoden enthalten, sind selbst abstrakt. Im Gegensatz zu konkreten Methoden enthalten abstrakte Methoden nur die Deklaration des Methodenkopfes, aber keine Implementierung des Methodenrumpfes. Syntaktisch unterscheiden sich abstrakte Methoden dadurch, dass anstelle der geschweiften Klammern mit den auszuführenden Anweisungen lediglich ein Semikolon steht. Zusätzlich wird die Definition mit dem Attribut '''''abstract''''' versehen. Abstrakte Methoden können nicht aufgerufen werden. Sie definieren nur eine Schnittstelle, die durch Überschreiben in einer abgeleiteten Klasse implementiert werden kann. Es ist sozusagen eine Aufforderung an jede abgeleitete Klasse, diese abstrakten Methoden zu implementieren und damit konkret zu machen. Tut sie dies nicht, wird sie selbst als abstrakt angesehen und muss ebenfalls mit dem Schlüsselwort '''''abstract''''' versehen werden. Von abstrakten Klassen können keine Instanzen gebildet werden, da sie Methoden enthalten, die nicht implementiert wurden. Statt dessen werden abstrakte Klassen abgeleitet, und in der abgeleiteten Klasse werden eine oder mehrere der abstrakten Methoden implementiert. Eine abstrakte Klasse wird konkret, wenn alle ihre Methoden implementiert sind. Die Konkretisierung kann dabei auch schrittweise über mehrere Vererbungsstufen erfolgen.

Auch wenn von einer abstrakten Klasse keine Instanzen gebildet werden, kann sie dennoch Konstruktoren enthalten, auf die Unterklassen mittels des Schlüsselworts ''super'' zurückgreifen können.

<u>Beispiel:</u> Wir wollen nun die Aufgabe 9.3.1 durch eine abstrakte Klasse ''Figur'' erweitern, die nur eine abstrakte Methode ''umfang'' enthält. (Die Probleme, die durch die nicht kompatiblen Konstruktoren entstehen, wollen wir hier vernachlässigen.)

<syntaxhighlight lang="java">
public abstract class Figur{

//Attribut
private int linienbreite;

//Konstruktor, der nur von den Unterklassen genutzt werden soll
protected Figur(int linienbreite){
this.linienbreite=linienbreite;
}

//konkrete Methoden, die an die Unterklassen vererbt werden und nur dort sichtbar sein sollen
protected int getLinienbreite(){
return linienbreite;
}

protected void setLinienbreite(int linienbreiteNeu){
linienbreite=linienbreiteNeu;
}

//abstrakte Methode, die von allen Unterklassen zu implementieren ist
public abstract void umfang();
}

</syntaxhighlight>

Die abstrakte Klasse ''Figur'' verlangt nun von ihren Unterklassen, eine Methode umfang() zu implementieren. Geschieht dies nicht, erhält man folgende Fehlermeldung:

'''Viereck is not abstract and does not override method umfang() in Figur'''

Das bedeutet, dass wir die Klasse Viereck ebenfalls ''abtract'' setzen müssen und die Methode dann in deren Unterklassen implementieren (oder auch diese ''abstract'' setzen) müssen.

<u>Zur Vertiefung: </u>

<div style="margin-left:100px; margin-top:30px; margin-bottom:30px">
{{#ev:youtube|F2dsyn68N9o}}
</div>

@@ Zeile 398: / Zeile 398: @@
 '''Aufgabe 4'''
-Es sollen drei Klassen erstellt werden: '''Viereck''', '''Rechteck''' als Unterklasse von ''Viereck'' und '''Quadrat''' als Unterklasse von ''Rechteck''. Jede der Klassen erhält eine Methode ''umfang()'', die die effizienteste Methode der Berechnung des Umfangs für die einzelne Figur nutzt. Achte insbesondere darauf, welche Konstruktoren in der jeweiligen Oberklasse implementiert werden müssen (Die Fehlermeldung in BlueJ ist dabei hilfreich). Teste in einer vierten Klasse die Umsetzung mit folgendem Code (Ausgabe in der Form ''"Ich bin ein Rechteck. Umfang: 45"''):
+Es sollen drei Klassen erstellt werden: '''Viereck''', '''Rechteck''' als Unterklasse von ''Viereck'' und '''Quadrat''' als Unterklasse von ''Rechteck''. Jede der Klassen erhält eine Methode ''umfang()'', die die effizienteste Methode der Berechnung des Umfangs für die einzelne Figur nutzt. Die Klasse Quadrat erhält zudem eine Methode ''flaeche()'' zur Berechnung des Flächeninhalts. Achte insbesondere darauf, welche Konstruktoren in der jeweiligen Oberklasse implementiert werden müssen (Die Fehlermeldung in BlueJ ist dabei hilfreich). Teste in einer vierten Klasse die Umsetzung mit folgendem Code (Ausgabe in der Form ''"Ich bin ein Rechteck. Umfang: 45"''):
 <syntaxhighlight lang="java">

@@ Zeile 496: / Zeile 496: @@
      public void umfang(){
-         int u=2*a + 2*b;
+         int u=4*a;
          System.out.println("Ich bin ein Quadrat. Umfang = "+u);
+     }

@@ Zeile 72: / Zeile 72: @@
 //Attribute
 private String name;
-private String geburtsdatum
+private String geburtsdatum;
 //Konstruktor

@@ Zeile 144: / Zeile 144: @@
 public void pruefen (Schueler s){ ... }
-public void verweisErteilen /Schueler s) { ... }
+public void verweisErteilen (Schueler s) { ... }
 ...
@@ Zeile 157: / Zeile 157: @@
 //Konstruktor
-public Schueler((String name, String geburtsdatum, String telefonnummer, String schueler-ID){
+public Schueler(String name, String geburtsdatum, String telefonnummer, String schueler-ID){
 //Aufruf des Konstruktors der Oberklasse
 super(name, geburtsdatum, telefonnummer);

Vererbung - Versionsgeschichte

B.Schiller am 13. Juli 2016 um 06:45 Uhr

B.Schiller am 11. Juli 2016 um 07:06 Uhr

B.Schiller am 4. Juli 2016 um 07:06 Uhr

B.Schiller am 4. Juli 2016 um 07:03 Uhr

B.Schiller: Die Seite wurde neu angelegt: „Die Vererbung ist eines der grundlegenden Konzepte der Objektorientierung. Sie dient dazu, aufbauend auf bereits existierenden Klassen neue zu schaffen, wobei …“