Versionsvergleich
Aus ProgrammingWiki
Vergleich: 2013-03-31T08:02:43+00:00 → 2014-04-25T20:34:42+00:00
<language>Java</language> | |
== Einführung in die Objektorientierte Programmierung == | |
=== Technische Voraussetzungen === | |
Zur Objektorientierten Programmierung in Java ist die Policy-Datei | |
* <tt>JavaPolicy.class</tt> | |
erforderlich. Entsprechende Installationshinweise findet man unter: [[JavaPolicy]] | |
=== Definition einer Klasse === | |
Wir definieren die (Objekt-)Klasse ''Bruch'': | |
| − | <code id="5143a93514328"> |
| + | <code id="515828a7a30a8"> |
public class Bruch { | |
protected int z; | |
protected int n; | |
public Bruch(int z, int n) { | |
if (n < 0) { | |
z = -z; n = Math.abs(n); | |
} | |
this.z = z; | |
this.n = n; | |
} | |
public int Zaehler() { | |
return z; | |
} | |
public int Nenner() { | |
return n; | |
} | |
public double Dezimal() { | |
return (double)z / n; | |
} | |
public void Ausgabe() { | |
System.out.println(z + "/" + n); | |
} | |
| − | public void Addition(Object Summand) { |
| + | public void Addition(Bruch Summand) { |
z = z * Summand.Nenner() + n * Summand.Zaehler(); | |
n = n * Summand.Nenner(); | |
} | |
| − | public void Subtraktion(Object Subtrahend) { |
| + | public void Subtraktion(Bruch Subtrahend) { |
z = z * Subtrahend.Nenner() - n * Subtrahend.Zaehler(); | |
n = n * Subtrahend.Nenner(); | |
} | |
| − | public void Multiplikation(Object Faktor) { |
| + | public void Multiplikation(Bruch Faktor) { |
z = z * Faktor.Zaehler(); | |
n = n * Faktor.Nenner(); | |
} | |
| − | public void Division(Object Divisor) { |
| + | public void Division(Bruch Divisor) { |
z = z * Divisor.Nenner(); | |
n = n * Divisor.Zaehler(); | |
if (n < 0) { | |
z = -z; n = Math.abs(n); | |
} | |
} | |
public void Reziprok() { | |
int h = z; z = n; n = h; | |
if (n < 0) { | |
z = -z; n = Math.abs(n); | |
} | |
} | |
} | |
</code> | |
=== Instanzen einer Klasse === | |
Zunächst erzeugen wir die Instanzen ''Bruch1'' und ''Bruch2'' der Klasse ''Bruch'' und geben sie mit der Methode ''Ausgabe'' aus: | |
<code id="5145df66303a4"> | |
Bruch Bruch1 = new Bruch(1, 2); | |
Bruch Bruch2 = new Bruch(3, 4); | |
</code> | |
<run id="5145df6630672"> | |
System.out.print("Bruch1: "); Bruch1.Ausgabe(); | |
System.out.print("Bruch2: "); Bruch2.Ausgabe(); | |
</run> | |
=== Kapselung, Eigenschaften und Methoden einer Klasse === | |
| − | Eine dritte Instanz ''Bruch3'' soll die Zähler-Eigenschaft <tt>'''z'''</tt> und die Nenner-Eigenschaften <tt>'''n'''</tt> der ersten Instanz ''Bruch1'' erhalten. Diese Eigenschaften sind streng ''gekapselt'', d.h. ein direkekter Zugriff ist nicht möglich. Wir müssen deshalb die Methoden ''Zaehler'' und ''Nenner'' benutzen.<br /> Anschließend wird die Methode ''Addition'' mit der Instanz ''Bruch2'' ausgeführt: |
| + | Eine dritte Instanz ''Bruch3'' soll die Zähler-Eigenschaft <tt>'''z'''</tt> und die Nenner-Eigenschaften <tt>'''n'''</tt> der ersten Instanz ''Bruch1'' erhalten. Diese Eigenschaften sind streng ''gekapselt'', d.h. ein direkter Zugriff ist nicht möglich. Wir müssen deshalb die Methoden ''Zaehler'' und ''Nenner'' benutzen.<br /> |
| + | Anschließend wird die Methode ''Addition'' mit der Instanz ''Bruch2'' ausgeführt: |
<code id="5145df6630450"> | |
Bruch Bruch3 = new Bruch(Bruch1.Zaehler(), Bruch1.Nenner()); | |
Bruch3.Addition(Bruch2); | |
</code> | |
<run id="513c5b7b521d4"> | |
System.out.print("Bruch3: "); Bruch3.Ausgabe(); | |
System.out.println("Bruch3 als Dezimalbruch: " + Bruch3.Dezimal()); | |
</run> | |
=== Vererbung === | |
Es fällt auf, dass eine Methode zum vollständigen Kürzen von Brüchen in der Klasse ''Bruch'' fehlt.<br /> | |
Wir leiten aus ihr die Unterklasse ''GekuerztBruch'' ab, die zunächst alle Eigenschaften und Methoden der Oberklasse ''erbt''. Schließlich wird sie durch die Methode ''Kuerzen'' ergänzt: | |
<code id="513cdb3bdd2fa"> | |
public class GekuerztBruch extends Bruch { | |
public GekuerztBruch(int z, int n) { | |
super(z, n); | |
} | |
private int ggT(int m, int n) { | |
if (n == 0) | |
return m; | |
else | |
return ggT(n, m % n); | |
} | |
public void Kuerzen() { | |
int teiler = Math.abs(ggT(z, n)); | |
z = z / teiler; | |
n = n / teiler; | |
} | |
} | |
</code> | |
<code id="5145df66304f4"> | |
Bruch Bruch4 = new GekuerztBruch(Bruch3.Zaehler(), Bruch3.Nenner()); | |
Bruch4.Kuerzen(); | |
</code> | |
<run id="5145df66306fa"> | |
System.out.print("Bruch4: "); Bruch4.Ausgabe(); | |
</run> | |
=== Polymorphie === | |
Wir leiten von der Unterklasse ''GekuerztBruch'' erneut eine Unterklasse ab und nennen sie ''GemischtBruch'': | |
| − | <code id="5143a935144f6"> |
| + | <code id="515828a7a313b"> |
public class GemischtBruch extends GekuerztBruch { | |
public GemischtBruch(int z, int n) { | |
super(z, n); | |
} | |
public void Ausgabe() { | |
int g; int z0; int n0; | |
double quotient = z / n; | |
if (quotient < 0) | |
g = (int)Math.ceil(quotient); | |
else | |
g = (int)Math.floor(quotient); | |
if (g == 0) | |
System.out.println(z + "/" + n); | |
else { | |
z0 = Math.abs(z % n); | |
n0 = n; | |
System.out.println(g + "_" + z0 + "/" + n0); | |
} | |
} | |
} | |
</code> | |
Weiterhin implementieren wir eine universelle Ausgabeprozedur sowie zwei weitere Instanzen: | |
| − | <code id="5157eda2a82c7"> |
| − | public void BruchAusgabe(Object MyBruch) { |
| + | |
| + | <code id="515828a7a31c3"> |
| + | public void BruchAusgabe(Bruch MyBruch) { |
System.out.print(MyBruch.Zaehler() + "/" + MyBruch.Nenner() + " = "); | |
MyBruch.Kuerzen(); | |
MyBruch.Ausgabe(); | |
} | |
Bruch Bruch5 = new GekuerztBruch(24, 16); | |
Bruch Bruch6 = new GemischtBruch(24, 16); | |
</code> | |
| − | <run id="5157eda2a836e"> |
| + | <run id="515828a7a327c"> |
BruchAusgabe(Bruch5); | |
BruchAusgabe(Bruch6); | |
</run> | |
Wir stellen fest: Innerhalb einer Klassenhierarchie können gleichnamige Methoden bei gleicher Signatur verschiedene Wirkungen hervorrufen.<br /> | |
Diese Vielschichtigkeit heißt ''Polymorphie''. |