Polymorphie und Dynamisches Binden richtig nutzen

[Java4win]

Hey ich habe einmal eine Frage bezüglich dieses Codes:

public class EineAufgabe{
    public static void main(String[] args) {
        Euro euro = new Euro(2);
        euro.print(); // Ausgabe: 2.0 Euro
        DM dm = new DM(4);
        dm.print(); // Ausgabe: 4.0 DM
        Lire lire = new Lire(600);
        lire.print(); // Ausgabe: 600.0 Lire
        euro.addiere(dm); // 2.0 Euro + 4.0 DM
        euro.print(); // Ausgabe: 4.045168 Euro
        lire.addiere(euro); // 6.0 Ellen + 3.216 Euro
        lire.print(); // Ausgabe: 8439.472868217055 Lire
    }
}

Mir ist klar das ich eine Oberklasse "Muenze" erstellen müsste und dort dann die Methode print() und addiere() rein schreibe, welche and die Unterklassen Euro, DM und Lire weiter gegeben werden.

Nur wie bekommt man es mittels Vererbung hin, dass die Werte umgerechnet werden, dies ist die Prämisse:
"Dabei gilt: 1 DM = 0.511292 Euro und 1 (italienische) Lire = 0.000516 Euro"

 

[Javinner]

@Java4win
In dem du in der Kindsklasse den jeweiligen Verrechnungswert der Kindsklasse an den Elternkonstruktor zurückgibst.

 

[Java4win]

@Javinner
Ich denke ich weiß was du meinst. Dann könnte ich über den Übergebenen Parameter den Wert umrechnen.
Jedoch habe ich bei diesem Gedankengang das Problem das, wenn ich z.B. bei
euro.addiere(lire);
und bei
dm.addiere(lire);
den selben Parameter zur Umrechnung benutzen würde und dementsprechend etwas falsche raus kommen würde...

 

[Xyz1]

1 DM = 0.511292 Euro

Das war ein guter Witz eigentlich müsste da stehen = 2.511292 Euro.... 😀
Denn vor einiger Zeit war für 100 DM der Einkaufswagen voll, heute ist er für 50 Euro halb(leer)voll. 😀

 

[Java4win]

Das war ein guter Witz eigentlich müsste da stehen = 0.2 Euro.... 😀

Ja die Aufgabenstellung sei mal dahingestellt😀

Aber ich glaube ich habe eine Idee:
Immer wenn ich eine neue Klasse übergebe, übergebe ich der Klasse zwei Werte einmal die Umrechnung nach Euro und einmal die Umrechnung von Euro zum eigenen Wert.
So hätte ich das auf Euro genormt und kann dementsprechend mit dem eigenen Wert weiter rechnen.

 

[Javinner]

@Java4win
Du ich irrte mich im ersten Beitrag, ist keine gute Lösung.
Besser wäre es, wenn die jeweilige Klasse, außer Euro, den der gilt hier als der Verrechnungswert, den Verrechnungswert implementiert und beim Aufruf von X in der getValue()-Methode verrechnet.
Nur als kleines Beispiel, muss gleich weg:

public class TestAplication
{

    public static void main(String[] args)
    {
        Dollar firstDollar = new Dollar(100);
        Dollar secondDollar = new Dollar(100);
        Euro euro = new Euro(firstDollar.getValue() + secondDollar.getValue());
        System.out.println(euro);
        Dollar thirdDollar = new Dollar(10);
        double mEuroValue = euro.getValue();
        euro = new Euro(mEuroValue + thirdDollar.getValue());
        System.out.println(euro);

    }

}
/** Output */
Value: 190.0
Value: 199.5

public abstract class Currency
{

    public abstract double getValue();

}
public class Euro extends Currency
{
    private final double value;
    public Euro(double value)
    {
        this.value = value;
    }
    @Override
    public double getValue()
    {
        return this.value;
    }
   
    @Override
    public String toString()
    {
        return "Value: " + this.value;
    }
}
public class Dollar extends Currency
{
    private final double change_tax = 0.95;
    private final double value;
    public Dollar(double value)
    {
        this.value = value;
    }
    @Override
    public double getValue()
    {
        return this.value * this.change_tax;
    }
    @Override
    public String toString()
    {
        return "Value: " + this.value;
    }
}

 

[Xyz1]

Ja die Aufgabenstellung sei mal dahingestellt😀

....habt auch gerade die Umrechnung verbessert, aus 0 mache 2 (deklariere es aber für 0.5) 😀 (Sorry wenn ich damit nerve).

 

[Java4win]

@Javinner
Okey, nur du hast jetzt lediglich zwei Klassen. Würdest du noch eine Dritte Währung mit rein nehmen,
könntest du nicht mehr so einfach sagen firstDollar.getValue();
dort würde ja dann der entsprechende Wert für Euro raus kommen... Dementsprechend müsstest du eine neue Methode in Dollar schreiben, die dann die Umrechnung in die neue Währung besitzt.
Weißt du was ich meine ?

 

[Javinner]

@Java4win
Die abstrakte Currency dient hier als die Elternklasse für alle Währungen. Es hat den Vorteil, dass diese a) ein Satz gleichnamiger Methoden für alle Kinder der Klasse anbietet und b) später eventuell als Adapter fundieren kann und c) du hier kreuz und quer alle möglichen Währungen zu der jeweiligen Währung addieren kannst. Natürlich musst du die Methode noch implementieren. Als Gedanke: nicht nur Geld hat einen Geldwert, auch Wertgegenstände usw. Daher würde ich die entsprechende Methode in ein Interface auslagern. Denn im späteren Verlauf, wenn du dein ganzes Hab und Gut zählen willst, wirst du es um so einfacher haben 😉 Ich will dir aber die Freude am Entdecken nicht nehmen.

Wenn du jetzt eine andere Währung erstellen solltest, dann sollte diese natürlich den Umrechnungswert zu Euro implementieren, siehe Dollar/change_tax. Aber es funktioniert weiterhin, kannst du mir folgen?

 

[Javinner]

....habt auch gerade die Umrechnung verbessert, aus 0 mache 2 (deklariere es aber für 0.5) 😀 (Sorry wenn ich damit nerve).

Implementiere lieber den Verrechnungswert von '91 in die heutige Währung, damit wäre mir sehr geholfen 😀

 

[Robat]

Also wenn du festlegst, dass alle Währungen zu Euro umgerechnet werden um mit denen zu rechnen könnte eine mögliche Implementierung so aussehen.
Würde aber nicht meine Hand dafür ins Feuer legen, dass es die Beste Lösung ist. 😉

Sowohl die Berechnung, als auch die Ausgabe bleibt in der Currency Klasse welche beide Werte erst in ihren Euro-Betrag umrechnet, diese addiert und zum Schluss wieder in die gewünschte Währung des Objektes umrechnet.

public abstract class Currency {
    private double value;

    public Currency(int value) {
        this.value = value;
    }

    public void print() {
        System.out.println(String.format("%f %s", getValue(), getUnit()));
    }

    public void add( Currency c ) {
        double firstEuroValue = value * getCurrencyRate();
        double secondEuroValue= c.getValue() * c.getCurrencyRate();

        value = (firstEuroValue+ secondEuroValue) / getCurrencyRate();
    }

    public double getValue() {
        return value;
    }

    public abstract double getConcurrencyRate();
    public abstract String getUnit();
}

public class Lire extends Currency {
    public Lire(int value) {
        super(value);
    }

    @Override
    public double getCurrencyRate() {
        return 0.000516; // das für andere Währungen anpassen. Wert ist bezogen auf 1 EUR
    }

    @Override
    public String getUnit() {
        return "Lire"; // das für andere Währungen anpassen
    }
}

public class Euro extends Currency{
    public Euro(int value) {
        super(value);
    }

    @Override
    public double getCurrencyRate() {
        return 1d;
    }

    @Override
    public String getUnit() {
        return "Euro";
    }
}

Edit: Sollte natürlich Currency und nicht Concurrency heißen 😛

 

[Javinner]

@Robat
Maschine! 😉