OOP Generik, aber wie?

[DarkManX]

Hiho Leute,

versuche mir gerade zum Übung Matrizenoperationen in einer Klasse zu definieren, klappt soweit alles gut, nur habe ich jetzt ein Problem die richtige Organisation dafür zu finden.

Habe zuerst die Klasse MatrixDouble erstellt und dort alle Operationen für Doubles definiert. Danach fand ich diese Gleitkommazahlen nicht gerade vorteilhaft für die Anschauung. Also müssen Brüche her. Promt habe ich die Klasse Bruch geschrieben, die die Brüche darstellt und auch Operationen dafür definiert. Danach die Klasse MatrixBruch erstellt und das selbe analog für Doubles gemacht.

Nun habe ich 2 Klassen MatrixDouble und MatrixBruch, diese könnte man doch zu einer vereinigen um Redundanz zu vermeiden, nur habe ich nicht den Clou wie. Kann mir einer vlt paar Tips dafür geben?

Danke!

 

[Antoras]

Du definierst eine generische Klasse über einen Typparameter: [c]class Matrix<T> {}[/c]

Jetzt musst du nur überall dort wo in deiner Klasse ein Double oder ein Bruch steht den Typparameter T verwenden, z.B. [c]public Matrix<T> add(Matrix<T> m) {}[/c].

Eine sehr gute Übersicht über Java-Generics findest du hier.

 

[DarkManX]

Was Generik ist und wie man das macht ist mir eig. recht klar. Das Problem wäre bei der Implementierung, ich bei Bruch sowas wie bruch1.add(bruch2) oder Bruch.add(bruch1,buch2) verwende. Wie soll es denn mit Doubles funktionieren? Muss ich dann noch diese Methoden für Doubles definieren? Weil bei Doubles habe ich ja ja einfach z1+z2.

PS: Kann man eig für einen Datentyp irgendwie die Operation "+" oder "*" definieren? Dass bruch1*bruch2 = Bruch.mult(bruch1,bruch2) ist?

 

[Landei]

Das erste Problem bei der Sache ist, dass die Wrapper-Objekte wie Double keine mathematischen Methoden definieren. Also braucht man in diesem Fall auch ein Objekte, die für die verschiedenen Zahlentypen "rechnen" können, Werte für die Null und die Eins u.s.w. Das zweite Problem ist, dass du die Daten der Matrix sicher in einem Array abspeichern willst, nur lässt sich ein Array leider nicht für einen generischen Typ erzeugen (Stichwort "type erasure"). In unserem Fall können wir das unsere Rechenklasse gleich mit übernehmen lassen. Das dritte Problem ist die Performance: Gerade bei Matritzen würde man in der Praxis aus Geschwindigkeitsgründen Primitive wie double vorziehen, das andauernde Boxing/Unboxing (Double <=> double) geht mächtig auf die Geschwindigkeit.

Trotzdem mal der Versuch einer Skizze:

public interface Operations<T> {
   public T zero();
   public T one();
   public T add(T a, T b);
   public T mult(T a, T b);
   //und alle anderen Operationen, die du für deinen Zahlentyp benötigst

   public T[][] makeArray(int columns, int rows);
}

//Eine Implementierung für Double (ananlog dann für Bruch)
public class DoubleOps implements Operations<Double> {
   public T zero(){ return 0.0; }
   public T one(){ return 1.0; }
   public Double add(Double a, Double b){ return a+b; }
   public Double mult(Double a, Double b){ return a*b; }

   public Double[][] makeArray(int columns, int rows){ return new Double[columns][rows]; } 
}

public class Matrix<T> {
   final T[][] data;
   final Operations<T> ops;
   final int columns; 
   final int rows; 

   public Matrix(int columns, int rows, Operations<T> ops) {
        this.ops = ops;
        this.columns = columns;
        this.rows = rows;
        data = ops.makeArray(columns,rows); 
        for(int x = 0; x < columsn; x++) {
           for(int y = 0; y < columns; y++) {
               data[x][y] = ops.zero(); 
           }
        }
   }

   //mal ein Beispiel für eine Addition, die eine neue Matrix liefert 
   //(oft gibt es auch eine Version, die stattdessen die lokale Matrix ändert)
  public Matrix T add(Matrix<T> that) {
     assert this.columns == that.columns && this.rows == that.rows;
     Matrix<T> result = new Matrix<T>(columns, rows, ops);
        for(int x = 0; x < columsn; x++) {
           for(int y = 0; y < columns; y++) {
               result.data[x][y] = ops.add(this.data[x][y], that.data[x][y]); 
           }
        }
        return result;
  }
}

Wie du siehst, kann unsere Matrix ganz allgemein verwendet werden, selbst für eigene Datentypen, zumindest solange eine entsprechende Operations-Instanz zur Verfügung steht.

Eine andere Variante wäre, die benötigten Operationen wie add abstrakt in Matrix aufzunehmen, und dann in den Unterklassen zu definieren, etwa [c]public class DoubleMatrix extends matrix<Double>{...[/c]. Der Vorteil eines separaten Operations-Interfaces ist, dass es "wiederverwendbar" ist, z.B. wenn du generische Vektoren, Polynome u.s.w. implementieren willst.

 

[DarkManX]

Hmm, also ich habe bis jetzt immer alle Arrays mit generischen Typen als Arrays vom Typ Object erstellt und diese zu diesem Typen gecastet. Warum soll das nicht gehen?

T[][] matrix = (T[][]) new Object[x][y];

Auf Performance achte ich gerade gar nicht, da ich nur eine Matrix auf Eigenschaften analysieren will (Stufenform, Determenante, inverse Matrix, usw.). Also ursprünglich dachte ich, man kann den generischen Typen von irgendeinem mathematischem Typ ableiten oder so, damit diese Operationen definiert sind. So könnte man machen Matrix<T extends IrgendEineMathKlasseOderSo> und die Bruchklasse würde man dann auch von dieser Klasse ableiten. Geht das irgendwie? Gibt es so eine Klasse?

 

[Marco13]

Leider nicht. Ein Interface wie "FieldElement" wäre natürlich schön. Idealerweise vollkommen transparent auch für primitive Typen "implementiert". DORT würde Operatorenüberladung dann wenigstens Sinn machen Es gibt Ansätze, die in diese Richtung gehen ( org.jscience.mathematics.structure (JScience 5.0-SNAPSHOT API) ) aber leider schieben einem die sprachlichen Beschränlungen bei Java da schnell einen Rigel vor, bzw. machen das ganze sehr schwierig und kaum performant umsetzbar, eben durch die Trennung zwischen primitiven und Referenztypen...

 

[DarkManX]

Ok gut, werde das mal mit abstrakten Klassen versuchen, damit man den Mist, den ich gerade verzapfe auch mal weiterverwenden kann. Hatte vor einen Matrixrechner für mein Handy zu machen, klappt auch ganz gut, wollte es aber besser organisieren.

Wo man gerade dabei ist, hätte ich noch eine Frage:
Gibt es irgendwelche Libs, mit denen man ohne weiteres mathematische Formeln darstellen kann? Sodass mir das Ding ein Bild von der Matrix erzeugt (schön mit Klammern und die Koeffizienten richtig positioniert) und ich es wiedergeben kann. Wenn ich nun eigene Bilder für Klammern importieren würde und die als Flanken der Matrixtabelle anzeigen würde, bräuchte ich für jede beliebige n x m Matrix lange Klammern. Hoffe einer hat guten Rat!

Danke