Versionsvergleich

Aus ProgrammingWiki

Vergleich: 2013-03-09T18:58:07+00:00 → 2014-04-25T20:34:42+00:00

<language>Java</language>
−
<code id="513b863f0aaff">
+
== 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="515828a7a30a8">
public class Bruch {
−
 Bruch(int z, int n) {
+
 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 this.z;
+
  return z;
 }
 public int Nenner() {
−
  return this.n;
+
  return n;
 }
+
+
 public double Dezimal() {
+
  return (double)z / n;
+
 }
+
+
 public void Ausgabe() {
+
  System.out.println(z + "/" + n);
+
 }
+
 
+
 public void Addition(Bruch Summand) {
+
  z = z * Summand.Nenner() + n * Summand.Zaehler();
+
  n = n * Summand.Nenner();
+
 }
+
+
 public void Subtraktion(Bruch Subtrahend) {
+
  z = z * Subtrahend.Nenner() - n * Subtrahend.Zaehler();
+
  n = n * Subtrahend.Nenner();
+
 }
+
 
+
 public void Multiplikation(Bruch Faktor) {
+
  z = z * Faktor.Zaehler();
+
  n = n * Faktor.Nenner();
+
 }
+
+
 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>
−
<run id="513b863f0ab62">
+
=== 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);
−
System.out.println("Zaehler: " + Bruch1.Zaehler());
+
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 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="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="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="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''.