Universität Hamburg - Fachbereiche - Fachbereich Mathematik

Inhaltsverzeichnis

• Objektorientiertes Programmieren (OOP)

  • Klassen(class Polynom{...})
  • Objekte(Polynom p;)
  • Daten(p.Grad)
  • Methoden(p.getWert(1.1))
  • Konstruktor(Polynom p=new Polynom(3,a);)
  • Überladen von Methoden
  • Zugriffsrechte, Sichtbarkeit(public, private, protected)
  • Klassen- und Instanzvariable, Klassenmethoden(static)
  • Referenzvariable
  
  

• Unterklassen, Vererbung, Polymorphie

• Unterklassen(class Polynom extends Funktion{...})
• Vererbung
• Polymorphie
• Listing der Klassen Funktion, Polynom
• Eine Applikation
• Pakete

---

Objektorientierte Programmierung (OOP)

Ich werde mich im folgenden an der (abstrakten) Klasse Funktion (Datei: Funktion.java) sowie ihrer Unterklasse Polynom (Datei: Polynom.java) orientieren. Diese Klassen können von irgendeiner Applikation (eine Klasse mit Methode main) aufgerufen werden.
Statt der Unterklasse Polynom hätte ich auch in enger Anlehnung an den vorherigen Abschnitt eine Unterklasse NewtonPolynom wählen können.

Klasse

ist der Grundbegriff des OOP. Jedes "lauffähige Javaprogramm" (eine Applikation ) besteht aus einer Klasse und mindestens einer Methode (meistens main). Der Programmierer wird daher, allerdings nur in sehr schwacher Weise (s. die Beispiele Lösung eines linearen Gleichungssystems und Berechnung eines Newtonschen Interpolationspolynoms) zur OOP gezwungen. Schaut man sich diese Beispiele oder die allereinfachste Anwendung in Form des Hello-World-Programms an, kann man keinen Nutzen von OOP erkennen, eher nur Mystik. Das liegt u.a. daran, daß die hier definierten Klassen in dem Sinne abstrakt sind, als daß kein Exemplar (auch Instanz genannt) von ihr gebildet wird.
I.a. will man (verschiedene) Objekte von Klassen bilden. Die Klassen legen durch ihre Daten und Methoden die Struktur ihrer Objekte fest, ein konkretes Objekt wird durch einen Konstruktor erzeugt.

Listing der Klassen Funktion, Polynom

Objekt

ist eine Zusammenfassung (Kapselung) von Daten (Attribute, Zustände, Mitgliedsvariablen, Status) und von Methoden (Verhalten). Ein Objekt hat eine Klasse als Datentyp. Alle Objekte der gleichen Klasse haben die gleiche Struktur: sie verfügen über die gleichen Methoden und die gleichen Mitgliedsvariablen in dem Sinne, daß ihre Bezeichner und Typen gleich sind, aber ihre Werte durchaus verschieden sein können, es sei denn es handelt sich um sogenannte Klassenvariablen. Auch die gleichnamigen Methoden verschiedener Objekte der gleichen Klasse bewirken i.a. etwas verschiedenes, es sei denn, es handelt sich um Klassenmethoden. Nur die Variablen vom Grunddatentyp (auch primitive Datentypen genannt) wie int oder double sind keine eigentlichen Objekte, alle Variablen von einem anderen als einem Grunddatentyp sind stets Objekte.

Beispiel: Mittels Polynom p; wird ein Objekt mit Bezeichner p der Klasse Polynom deklariert. Unter Verwendung des new-Operators und einem Konstruktor gleichen Namens wie die Klasse wird das Objekt sodann allokiert, d.h. ihm Speicherplatz (dynamisch) reserviert:
Durch double[] aa={1,2,3,4}; p=new Polynom(3,aa) wird das Polynom p(x)=1+2x+3x^2+4x^3 (mit dem Koeffizientenvektor aa) initialisiert.

Auf die Daten (Mitgliedsvariable) und Methoden eines Objekts wird mit der Punkt-Notation zugegriffen.

Listing der Klassen Funktion, Polynom

Daten

von Klassen werden auch Mitgliedsvariable genannt, wenn sie von Objekt zu Objekt variieren. Ansonsten werden sie Klassenvariable genannt, welche durch den Zusatz static kenntlich gemacht werden.

Beispiel: Ein Objekt namens p der Klasse Polynom hat als Mitgliedsvariable int Grad und den Koeffizientenvektor double[] a. Mittels p.Grad, p.a könnte von außen auf die Daten von p zugegriffen werden, wenn diese nicht als private deklariert worden wären (s.u. unter Zugriffsrechte).

Listing der Klassen Funktion, Polynom

Methoden

sind neben Daten das zweite Zubehör von Klassen und ihren Objekten. Sie entsprechen den Pascal-Funktionen (wenn sie Werte haben) und den Pascal-Prozeduren (wenn sie keine Werte haben, was durch void festgelegt wird). Methoden können in runden Klammern eingeschlossene Parameter (Argumente), auch in Form von Parameterlisten, enthalten. Die runden Klammern müssen immer dem Bezeichner einer Methode angefügt werden - auch wenn es keinen Parameter gibt.
Beispiel: An Methoden verfügt die Klasse Polynom (und auch ihr Objekt p) u.a. über

private double[] HornerKoeffizienten(double x)
public double getWert(double x)
public double getAbleitung(double x)

von denen HornerKoeffizienten() als Wert einen Vektor (double[]) zurückgibt, während die anderen Methoden als Wert double haben. Ferner haben sie alle eine vorgegebene Zahl x als Parameter. Zu den Zugriffsrechten später.
Mittels double y=p.getWet(3); kann die Methode getWert durchgeführt, hier der Wert des Polynoms an der Stelle 3 berechnet werden. Man sagt auch, daß eine Klasse, in der p deklariert wird, sich der (öffentlichen!) Methode getWert() des Objektes p bedient.
Diese Methoden werden folgendermaßen implementiert:

class Polynom extends Funktion{
...
...
 private double[] HornerKoeffizienten(double x){
   double[] b = new double[this.Grad];
   b[Grad-1]=a[Grad];
   for(int j=Grad-2;j>=0;j--)  b[j]=a[j+1]+x*b[j+1];
   return b;
 }//ende HornerKoeffizienten
 public double getWert(double x){
   if (Grad==0) return a[0];
   else{
    double[] b=HornerKoeffizienten(x);
    return b[0]*x+a[0];
   }//else
 }//Ende getWert
 public double getAbleitung(double x){
   Polynom q=this.Horner(x);
   return q.getWert(x);
 }//Ende getAbleitung
 ...
 ...
}//Ende class Polynom

Die Werte von Methoden werden mit Hilfe des return Operators übergeben. Die Methode getAbleitung benutzt eine weitere Methode Horner der Klasse Polynom, die insofern etwas aus der Rolle fällt, weil sie als Wert ein Objekt just derselben Klasse Polynom hat! Es ist das Polynom, das durch die Koeffizienten b[i] des Horner-Schemas gebildet wird:

class Polynom extends Funktion{
...
...
public Polynom Horner(double xi){
   double[] b=HornerKoeffizienten(xi);
   Polynom p=new Polynom(this.Grad-1,b); //rekursiv!
   return p; //p_n(x)=p_{n-1}(x)*(x-xi)+p_n(xi), p=p_{n-1}
 }//ende Horner
  ...
 ...
}//Ende class Polynom

Theoretisch ist eine Anweisung p.Horner(1).Horner(2).getWert(3); möglich.
Hier und oben wird der Zeiger this verwendet. Er zeigt auf das aktuelle Objekt.
In der dritten Zeile der Methode Horner wird ein Konstruktor verwendet.

Listing der Klassen Funktion, Polynom

Konstruktor

dient zur Allokierung von Objekten mittels des Operators new. Konstruktoren sind ganz spezielle Methoden, sie haben denselben Namen wie die Klasse. Eine Klasse muß nicht zwingend einen Konstruktor vorsehen. Dann kann man immer noch mit einem voreingestellten "minimalen" Default-Konstruktor ein Objekt allokieren. Der Konstruktor liefert keine Werte, dennoch steht er ohne den Zusatz void.
Der Konstruktor Polynom ist folgendermaßen vereinbart:

class Polynom extends Funktion{
...
...
 //Konstruktor:
 public Polynom(int Grad, double[] a){
  this.Grad=Grad;
  this.a=a;
 }
 ...
 ...
}//Ende class Polynom

Das Polynom wird "konstruiert", wenn sein Grad und der Koeffizientenvektor übergeben werden. Hier ist die Verwendung des Zeigers this nur dann nicht notwendig, wenn man als Parameter-Bezeichner des Konstruktors nicht dieselben wie die für die Mitgliedsvariablen verwendet hätte, z.B.

 //Konstruktor:
 public Polynom(int n, double[] b){
  Grad=n;
  a=b;
 }

Die Verwendung von this hat den Vorteil, daß man sich in das Gedächtnis zurückruft, daß Grad, a Mitgliedsvariable eines Polynom-Objektes sind.

Listing der Klassen Funktion, Polynom

Überladen von Methoden

Der obige Konstruktor public Polynom(int Grad, double[] a) hätte durch

public Polynom(double[] a){
this(a.length-1,a);//length ist ein Attribut eines Feldes
}

überladen werden können, indem der erste Konstruktor mit Hilfe des Zeigers this aufgerufen wird (Konstruktoren können sich gegenseitig mit Hilfe von this aufrufen). Danach können beide Konstruktoren Verwendung finden.
Generell können beliebig verschiedene Versionen einer Methode definiert werden. Sie unterscheiden sich dann in dem Typ von Parameterlisten, nicht jedoch in dem Typ ihrer Werte.
Das Überladen von Methoden sollte nicht mit Überlagern verwechselt werden.

Listing der Klassen Funktion, Polynom

Zugriffsrechte, Sichtbarkeit

gibt es für Daten und für Methoden einer Klasse. Die dienen der Übersichtlichkeit, aber auch der Fehlervermeidung. Sie werden bei der Deklaration durch einen Zusatz festgelegt, der z.B. public (öffentliches Zugriffsrecht, Sichtbarkeit) oder private lautet. Ersteres erlaubt jeder Klasse, bzw. jedem Objekt auf sie zuzugreifen (und die öffentlichen Daten zu verändern), letzteres gewährt dieses Recht nur innerhalb der eigenen Klasse. Für Methoden wird hierdurch die Dienstbarkeit für andere Klassen festgelegt, in der Regel bieten Objekte ihre Dienste anderen Objekten an.
Das Zugriffsrecht protected erlaubt das Zugreifen auch für Ober- und Unterklassen (s.u.), also für das gesamte Paket (package).
Fehlt das Zugriffsrecht, gilt die Voreinstellung public.
Beispiel: private int Grad; Hätten wir die Variable Grad der Klasse Polynom nicht als private deklariert, könnte eine andere Klasse z.B. durch p.Grad=123; einen "falschen" Grad erzeugen. Will man jedoch Unterklassen (s.u.) definieren, k"onnen diese private Attribute und Methoden nicht erben. Diese müssen wenigstens protected sein. Grundsätzlich sind private Daten und Methoden für andere Klassen nicht sichtbar. Die Methode HornerKoeffizienten ist private, da sie außerhalb dieser Klasse nicht benutzt werden soll.
Es wird generell empfohlen, Daten einer Klasse nicht öffentlich zu deklarieren, sondern sie mit öffentlichen Methoden wie setDaten(), getDaten() zu setzen und zu lesen.

Listing der Klassen Funktion, Polynom

Klassen- und Instanzvariable, Klassenmethoden

Spezielle Variable und Methoden einer Klasse können den Zusatz static tragen, der sie als Klassenvariable und Klassenmethoden kennzeichnet. Das sind solche Variable und Methoden, die nicht von Objekt zu Objekt variieren. Typischerweise operieren Klassenmethoden nur mit statischen Daten.
Es gibt Klassen, von denen man gar keine Instanz bilden will. Ein Beispiel ist die Klasse Math. Hier sind naturgemäß alle Variablen und Methoden statisch (static). Man ruft sie über den Bezeichner der Klasse auf, z.B. Math.sin.
Variable einer Klasse, die nicht Klassenvariable sind, heißen Mitgliedsvariable und zuweilen auch Instanzvariable.

Referenzvariable

treten stets in Verbindung mit Objekten einer Klasse auf. Die Deklaration Polynom p; ergibt eine (Referenz-) Variable mit Bezeichner p vom Typ Polynom. Erst durch Initialisierung in Verbindung mit new wird ein konkretes Objekt erzeugt. Man sagt, es wird eine Instanz der Klasse als Vorlage gebildet: Durch

p=new Polynom(3,aa);

wird im Heap Platz gemacht für die Daten von p, man sagt p ist initialisiert oder allokiert. p ist wie jede Objektvariable einschließlich Arrays und Strings eine Referenzvariable im Gegensatz zu int i; char b; double x;, den Grunddatentypen. Dieser Unterschied kommt bei der Anweisung q=p; für zwei Objekte p, q zum Tragen: hierdurch werden die Referenzen gleich, d.h. in Folge weisen beide auf denselben Heap, es wird keine Kopie angelegt! Ebenfalls sehr wichtig ist dies, wenn man Referenzvariable als Parameter von Methoden übergibt ("Call by Reference").

Unterklassen, Vererbung, Polymorphie

kennzeichnen den wesentlichsten Vorteil von OOP. Definiert man eine Unterklasse einer Klasse, so erbt diese zunächst alle Datenstrukturen und Methoden ihrer Superklasse, kann selbst aber neue hinzufügen oder aber auch einige geerbte Methoden individuell gestalten (ergänzen oder abändern).

Unterklasse

Die Klasse Polynom ist eine Unterklasse der (abstrakten) Klasse Funktion. Dieses erkennt man an der ersten Zeile in Polynom.java:

class Polynom extends Funktion{
...
...
}

Mit dem Zusatz extends Funktion definiert sich die Klasse Polynom als Unterklasse der Klasse Funktion. Der Vorteil dieses Konzepts wird durch Vererbung und Polymorphie charakterisiert.
Natürlich sind viel einfachere Unterklassen von Funktion denkbar. Eine lautet so:

public class HutFunktion extends Funktion{
  public  double getWert(double x){
   double y=0;
   if ((x>-1) & (x<=0)) y=x+1;
   if ((x>0) &  (x<=1)) y=1-x;
   return y;
  }
}

Listing der Klassen Funktion, Polynom

Vererbung

Hierzu schauen wir uns die Methoden der Klasse Funktion genauer an: es sind die drei Methoden getWert, getAbleitung, getWertetabelle. Die ersten beiden Methoden wurden von der Unterklasse Polynom überlagert, sie wurden "optimal" auf eine Polynomfunktion zugeschnitten. Die abstrakte Klasse Funktion erwartet von jeder ihrer Unterklasse eine Überlagerung (oder Redefinierung) zumindestens der Methode getWert. Wird getAbleitung nicht überlagert, so wird der "Notnagel" der Klasse Funktion (numerische Differentiation) benutzt. Anders ist es mit der Methode getWertetabelle von Funktion: auf diese kann und sollte von jedem Objekt jeder Unterklasse zugegriffen werden:

class Funktion{
...
...
 public  double[][] getWertetabelle(double a, double b, int Aufloesung){
  double dx=(b-a)/Aufloesung;
  double[] x=new double[Aufloesung+1];
  double[] y=new double[Aufloesung+1];
  double[][] z=new double[2][Aufloesung+1];
  for(int i=0;i<=Aufloesung;i++){
   x[i]=a+i*dx; y[i]=getWert(x[i]);}
  z[0]=x; z[1]=y;
  return z;
  }
 ...
 ...
}//Ende class Funktion

Wichtig ist, daß hier als Methode getWert nicht etwa die "Stellvertreter-Methode" in Funktion verwendet wird, sondern die jeweils überlagerte Methode der Unterklasse.
Als weitere Methoden könnten ein Newtonverfahren und eine numerische Quadratur in der Klasse Funktion eingeführt werden, auf die jedes Objekt einer Unterklasse zugreifen kann.
Eine besondere Rolle bei der Vererbung spielt der Konstruktor. Will man an den der Oberklasse anknüpfen, so verwendet man das Schlüsselwort super. Es ist denkbar, daß der Konstruktor einer Unterklasse zusätzliche Parameter besitzt.
Man achte auf den Unterschied zwischen Überlagerung und Überladung von Methoden.

Listing der Klassen Funktion, Polynom

Polymorphie

bedeutet sinngemäß, das ein Objekt einer Unterklasse auch "in das Kleid einer Superklasse schlüpfen" kann. Wenn also irgendwo eine Methode irgendeiner Klasse definiert wird, die als Parameter ein Objekt der Klasse Funktion enthält, könnte dort unbedenklich (jedenfalls syntaktisch) ein Objekt der Unterklasse Polynom eingesetzt werden. Als Beispiel sei die Klassenmethode Tools.Zeichne genannt, die den Grafen einer Funktion zeichnet. Weitere Methoden wie Numerische Integration oder Nullstellenbestimmung sind denkbar.

Listing der Klassen Funktion, Polynom

public  abstract class Funktion{
 public String Name;
 public  abstract double getWert(double x); //muss in jeder Unterklasse
                                            //ueberlagert werden
 public double getAbleitung(double x){
   return (getWert(x+0.001)-getWert(x-0.001))/0.002;
 }//Ende getAbleitung
 public  double[][] getWertetabelle(double a, double b, int Aufloesung){
   double dx=(b-a)/Aufloesung;
   double[] x=new double[Aufloesung+1];
   double[] y=new double[Aufloesung+1];
   double[][] z=new double[2][Aufloesung+1];
   for(int i=0;i<=Aufloesung;i++)
     {x[i]=a+i*dx; y[i]=getWert(x[i]);}
   z[0]=x; z[1]=y;
   return z;
 }//Ende getWertetabelle
}//Ende class Funktion


class Polynom extends Funktion{
//Attribute, Datenelemente, Mitgliedsvariable:
  private int Grad;
  private double a[];  //Koeffizienten (p=a0+a1*x+....+an*x^n)

  //Konstruktor:
  public Polynom(int Grad, double[] a){
    this.Grad=Grad;
    this.a=a;
  }//Ende 1. Konstruktor
  public Polynom(double[] a){
    this(a.length-1,a);
  }//Ende 2. Konstruktor
  //Methoden:
  private double[] HornerKoeffizienten(double xi){
    double[] b = new double[this.Grad];
    b[Grad-1]=a[Grad];
    for(int j=Grad-2;j>=0;j--)  b[j]=a[j+1]+xi*b[j+1];
    return b;
  }//ende HornerKoeffizienten

  //Eine Methode, die wieder ein Polynom erzeugt:
  public Polynom Horner(double xi){
    double[] b=HornerKoeffizienten(xi);
    Polynom p=new Polynom(this.Grad-1,b); //Bemerkenswert: Rekursiv
    return p; //p_n(x)=p_{n-1}(x)*(x-xi)+p_n(xi), p=p_{n-1}
  }//ende Horner

  public double getWert(double x){
    if (Grad==0) return a[0];
    else{
      double[] b=HornerKoeffizienten(x);
      return b[0]*x+a[0];
    }//Ende else
   }//Ende getWert
   public double getAbleitung(double x){
     Polynom q=this.Horner(x);
     return q.getWert(x);
   }//Ende getAbleitung
}//ende class Polynom

Eine Applikation

Wir schließen dieses Kapitel mit einem Beispiel für eine Applikation, die die Klassen Funktion, Polynom, HutFunktion nutzt:

public class Test1{
public static void main(String[] args){

  //Wertetabelle der Hautfunktion:
  double[][] z=new double[2][10];
  double a=-2; double b=2; int Aufloesung=10;
  HutFunktion f=new HutFunktion();
  z=f.getWertetabelle(a,b, Aufloesung);
  for(int i=0;i<=10;i++) System.out.println(z[0][i]+"   "+z[1][i]);

  //Berechnung von Funktionswert und Ableitung eines Polynoms an einer Stelle xi:
  double[] aa={1,2,3,4};
  Polynom p=new Polynom(3, aa); //oder  ...Polynom(aa);
  Polynom q=new Polynom(aa);
  double xi=1;
  int j=1;
  for(int i=0;i<=3;i++){//die ersten drei Ableitungen an der Stelle xi
   System.out.println("p^"+i+"("+xi+")="+j*q.getWert(xi));
   if (i<3) q=q.Horner(xi);
   j*=(i+1); //(i+1)!
  }//Ende for
}//Ende main
}//Ende Test1

Die letzten Zeilen verdienen eine Bemerkung: Hier werden von dem Polynom p alle Ableitungen an der Stelle xi berechnet. Dies geschieht durch mehrmaliges Anwenden des Horner Schemas, genauer der Methode Horner, die ja gerade das Polynom liefert, das von den Koeffizienten des Horner Schemas bestimmt wird. Der Befehl q=q.Horner(xi) ist also rekursiv.

packages

umfassen alle mittels Unterklassen gebildeten Klassen. Es gibt eine Klassenhierarchie, ein Paket hat Baumstruktur. Die oberste Klasse (die Wurzel) ist häufig abstrakt, von ihr werden keine Instanzen gebildet (wie unsere Klasse Funktion).
Das Paket, das automatisch geladen wird, heißt java.lang, andere wie java.applet oder java.awt (siehe Applets) müssen importiert werden.

---

Numerische Mathematik mit Java

OOP mit der Klasse Matrix und der Unterklasse TridiagonalMatrix

---



http://www.math.uni-hamburg.de/math/home/werner/java/OOP1.htm
last modified: 1999-06-24, Bodo Werner
werner@math.uni-hamburg.de