# Überladen des Rückgabedatentypen einer Funktion



## sep (22. Mrz 2006)

Hello everyody out there using Java ;-)
ich habe da folgendes Problemchen:

ich habe ien Klasse [term] mit einem [terms] Vector-Objekt geschaffen, dieser Vector soll mehrere Elemente auch verschiedener Klassen aufnehmen, auf die ich dann zugreifen kann, z.B. mit der Get(Index) Methode.

Der Zugriff soll dann folgerndermaßen funzen:


```
term t = new term;

t.add(objekttyp1);
t.add(objekttyp2);
t.Item(0).[Eigenschaften und Elemente von Objekttyp1]
t.Item(1).[Eigenschaften und Elemente von Objekttyp2]
```

Wie überlade ich nun die zugehörende Item-Funktion der Klasse term: (dieser Code funktioniert nicht...)

```
public objekttyp1 Item(int Index) {
    return terms.Get(Index);
}

public objekttyp2 Item(int Index) {
    return terms.Get(Index)
}
```

Die Klassen term und objekttyp1,2 sind nicht voneinander vererbt worden. Benutze ich die Oberklasse Object, dann habe ich keinen Zugriff auf die speziellen Methoden und Eigenschaften der Klassen objekttyp1,2, da diese darin nicht existieren.

hope this war verständlich??


HaPe


----------



## Roar (22. Mrz 2006)

der rückgabetyp einer methode gehört nicht zur signatur. darum ist es auch nicht möglich 2 methoden mit gleichem namen und gleichem parameter zu erstellen.

warum hast du überhaupt objekte von 2 verschiedenen klassen, die nix miteinander zu tun haben, in einer liste?


----------



## sep (23. Mrz 2006)

Ich möchte ein kleines Computer Algebra System basteln
ich habe ein term Objekt (die klasse mit dem Vector), das andere Objekte aufnehmen kann, z.B. Objekte der Klasse number, operator, function, parameter (von mir selbst mit spezifischen eigenschaften und methoden erstellte Klassen) und term (also sich selbst auch, das Objekt function z.B. implementiert wiederum ein term Objekt um den Parameter der Funktion aufzunehmen, z.B. "sin([term])" ). Dies soll einen Baum ergeben, mit dem ich dann auch rechnen, umformen und umstellen (z.b. nach einer Variablen) kann. 

Habe vor einiger Zeit einen mathematischen Ausdrucks parser (Funktionsplotter) in visual basic 6 geschrieben (ohne Objekte).

Also werden Methoden anhand von Signaturen (Hashkey??) unterschieden (bin in Java noch ein bisserl newbee)??

Danke

HaPe


----------



## Leroy42 (23. Mrz 2006)

Das ist ein klassisches Problem, daß geradezu nach einer Klassenhierarchie schreit   

Hier mal ein (minimaler) Ansatz bzw. mehr eine Idee für einen Ansatz.


```
abstract class Value {
  abstract double getVal();
}

class Number extends Value {
    private double value;
    public Number(double value) {this.value = value;}
    double getVal() {return value;}
}

class Summe extends Value {
    Value op1, op2;
    public Summe(Value op1, Value op2) {this.op1 = op1; this.op2 = op2;}
    double getVal() {return op1.getVal() + op2.getVal();}
}
class Produkt extends Value {
    Value op1, op2;
    public Produkt(Value op1, Value op2) {this.op1 = op1; this.op2 = op2;}
    double getVal() {return op1.getVal() * op2.getVal();}
}
```

Die genauen mathematischen Definitionen von _Term, Faktor, ..._ habe ich jetzt allerdings
nicht im Kopf


----------



## sep (24. Mrz 2006)

also erstelle ich eine "Superklasse" von der ich alle anderen Klassen "aberbe". Muss dann diese Superklasse alle Funktionen Setter und Getter Methoden enthalten (also nur die Funktionsrümpfe - glaube dis nennt sich abstract, mit dem spezifischem Code in den Kindklassen).

Also ich denke der vererbungsbaum sollte dann so aussehen:


```
super
    |--term
    |--function
    |--operator
    |--number
    |--parameter
```

aber irgendwie fühle ich mich da nicht wohl dabei. des schaut net sauber aus?!

Kann ich die in den Kindklassen jeweils nicht benutzbaren Methoden und Funktionen per private ausblenden?

die mathematischen Operationen (Ableiten, lösen, umstellen, ...) sollen von speziellen Funktionen auf diesen Baum ausgeführt werden, d.h. ich übergebe den Baum als Referenz oder Kopie an eine Funktion (das oberste term Objekt) und die macht dann alerlei lustige Sachen damit...


----------



## Leroy42 (24. Mrz 2006)

_Muss dann diese Superklasse alle Funktionen Setter und Getter Methoden enthalten_

Ja: Sie sollte *genau die* setter und getter enthalten die es auch in *allen* abgeleiteten
Klassen geben wird. Klassen die _zusätzlich_ gemeinsame getter haben wird dann wieder
eine gemeinsame Oberklasse zugeordnet.

Beispiel: Konstanten und Variablen haben genau ein Wert und brauchen deshalb genau eine
getter-Methode (eventuell auch setter). Diesen beiden Klassen könntest du z.B. eine gemeinsame
Oberklasse (gleichzeitig Unterklasse von deiner obersten Klasse) verpassen und beispielsweise
*class Atomar* nennen.

Auf der anderen Seite könntest du dyadische operatoren eine gemeinsame Oberklasse spendieren,
die zwei getter-Methoden besitzt: getOp1(), getOp2() wobei diese nicht abstrakt sein müssen,
da du ja die Operanden selbst (Auch vom Typ deine obersten Klasse) in dieser Klasse speichern kannst.


----------



## sep (24. Mrz 2006)

für die Operatoren wie für die Funktionen hab ich mir überlegt, dass ich jeweils nur eine Klasse erstelle, dass ein Attribut vom Datentyp enum (so kenn ich es von VB) bestitzt, das den Typ "einstellt" (+ - * / \ ^ ; sin log abs sqr exp ...) Die Operatoren erhalten noch eine Getter Funktion, die die Vorrangwertigkeit des eingestellten Operators zurückgibt und die Funktionen ein term Objekt für den Parameter-Ausdruck.

Wichtig ist mir, dass ich einfach und rekursiv (per Referenzen) auf die Elemente der term-Vector Objekte und auf dessen Eigenschaften zugreifen kann.

Wie entscheide ich, ob ein Objekt als Referenz oder als Kopie an eine Funktion übergeben wird?


auf jeden fall hab ich gemerkt, wie verkleinweichlicht man in VB programmiert ;-)


----------



## Beni (24. Mrz 2006)

Wieso enums? Pro Operation eine Klasse fände ich besser - immerhin haben die Operationen verschiedene Eigenschaften. Dann kannst du auch sehr einfach weitere Operationen implementieren.

Ein Objekt wird *immer* als Referenz übergeben in Java :wink:
(und primitive Datentypen "int", "double", ... immer als Kopien).


----------

