austauschbarer Code

[usrr]

Hallo,

ich hoffe das hier ist eine Anfängerfrage und ich bin im richtigen Forum. Wenn nicht, bitte einfach verschieben.

Ich möchte verschieden mathematische Berechnungen durchführen. Um flexible zu bleiben möchte ich dazu ein eine Eigene Zahlenklasse verwenden, die später leicht austauschbar sind. Dazu habe ich eine abstrakte Klasse definiert. In dem Beispiel beschränke ich mich darauf, dass die Zahlen addierbar sind. Als Schnittstelle soll die Zahl durch einen String gesetzt oder gelesen werden können. Ich verwende den Namen Number, obwohl es schon eine sogenannte Klasse gibt.

Number.java

package Number;

public abstract class Number {
    
    @Override
    abstract public String toString();
    abstract public void fromString(String value);
    abstract public void add(Number number);
    
}

Jetzt entsteht aber ein Problem beim ableiten einer neuen Klasse. ZB:

public class NumberDouble extends Number {
    ...
    
    @Override
    public NumberDouble add(NumberDouble number) {
        ...
    }

}

Das Problem ist, dass die add-Methode eigentlich so lauten muss:

public NumberDouble add(Number number)

Aber die add-Methode der abgeleiteten Klasse soll ja mit NumberDouble arbeiten und nicht mit Number!

Wie kann ich hier anders ansetzen um das zu lösen?

Danke schonmal für die Antworten.

 

[diggaa1984]

public class NumberDouble extends Number {
    
    @Override
    public Number add(Number number) {
        if (! (number instanceof NumberDouble))
            throw new IllegalArgumentException();
    }

}

so wäre das eine Möglichkeit, weiss aber gerade nicht, wie da der Standard aussieht

EDIT: da aber IllegalArgumentException ebenfalls unter die RuntimeExceptions fällt, könntest auch gleich einfach in NumberDouble casten und erhältst eine ClassCastException, welche ebenfalls eine RuntimeException darstellt ^^

 

[usrr]

Ok, das Zahlenobjekt prüft also, ob dass was es als Parameter übergeben bekommt, etwas ist mit dem es Rechnen kann. Ich probiere das mal.

Müsste der Rückgabewert nicht jetzt NumberDouble sein?

...
@Override
public NumberDouble add(Number number)
...

 

[diggaa1984]

nein die Signatur der Methode wird ja durch die abstrakte Klasse bestimmt

public abstract Number add(Number n);

Diese muss auch auch in den Subklassen übernommen werden.
Alles was du mit den Zahlen machen kannst wird ja dann durch die abstrakte Klasse beschrieben, da hast du ja keine Einschnitte. Du arbeitest logisch gesehen auf der Klasse Number, welche Implementierung dahinter liegt, ist ja unerheblich.

 

[Michael...]

Aber die add-Methode der abgeleiteten Klasse soll ja mit NumberDouble arbeiten und nicht mit Number!

Das ist mit Generics möglich:

	abstract class AbstractNumber<T extends AbstractNumber>{
		abstract public T add(T num);
	}
	
	class DoubleNumber extends AbstractNumber<DoubleNumber> {
		public DoubleNumber add(DoubleNumber num) {
			return null;
		}
	}

Eventuell kann man das auch schöner lösen, bin mir da gerade nicht sicher.

 

[tfa]

@usrr
Warum wandelst du das Number-Objekt, das der add()-Methode wird, nicht in eine DoubleNumber um? Man kann (mathematisch) sehr wohl Integer, Fließkommazahlen, BigInts, etc. addieren.
Wenn das nicht gehen sollte, was hätte dann add() in der abstrakten Oberklasse zu suchen?
Ein Exception oder sogar ClassCastException zu werfen, würde das ganze Design sinnlos machen. Lieber nicht.

 

[usrr]

Ok, ich entwickele das Beispiel weiter:

Ich möchte Zahlen natürlich elegant per Konstruktor initialisieren können:

z.B:

...
Number = NumberDouble("1");
Number = NumberDouble(); // entspricht NumberDouble("0")
...

Dazu habe ich die Klassen entsprechend erweitert:

Number.java

package Number;

public abstract class Number {

    Number( ) {
        super();
        fromString("0");
    }

    Number( String value ) {
        super();
        fromString(value);
    }

    @Override
    abstract public String toString();
    abstract public void fromString(String value);
    abstract public Number add(Number number);

}

NumberDouble.java

package Number;

public class NumberDouble extends Number {

    private double value;

    public NumberDouble() {
    }

    public NumberDouble(String value) {
        super(value);
    }

    @Override
    public String toString() {
        return String.valueOf(this.value);
    }

    @Override
    public void fromString(String value) {
        this.value = Double.valueOf(value);
    }

    @Override
    public Number add(Number number) {
        if (!(number instanceof NumberDouble))
            throw new IllegalArgumentException();
        NumberDouble result = new NumberDouble();
        result.fromString(String.valueOf(this.value + Double.valueOf(number.toString())));
        return result;
    }

}

Test.java

package Number;

public class Test {

    public static void main(String[] args) {

        NumberDouble n1 = new NumberDouble("1");
        NumberDouble n2 = new NumberDouble("2");

        System.out.println( n1 );
        System.out.println( n2 );

    }
}

So, hier erstmal dieser Zwischenschritt. Ich arbeite weiter an dem Beispiel, bis ich zum eigentlichen Fehler bzw. Problem komme.

 

[usrr]

@usrr
Warum wandelst du das Number-Objekt, das der add()-Methode wird, nicht in eine DoubleNumber um? Man kann (mathematisch) sehr wohl Integer, Fließkommazahlen, BigInts, etc. addieren.
Wenn das nicht gehen sollte, was hätte dann add() in der abstrakten Oberklasse zu suchen?
Ein Exception oder sogar ClassCastException zu werfen, würde das ganze Design sinnlos machen. Lieber nicht.

Es geht darum, dass ich die Kontrolle behalten will und ich die Zahlen mit denen gerechnet werden soll, später leicht austauschen kann. Ich will das aber nicht an hunderten von Stellen im Code machen, sondern einfach nur das zu verwendende Objekt tauschen.

Möglicherweise hast du recht und ich sehe es einfach jetzt noch nicht. Ich versuche mal das Beispiel weiter in Richtung meiner momentanen Lösung zu erweitern und dann sehen wir weiter.

 

[diggaa1984]

@usrr
Warum wandelst du das Number-Objekt, das der add()-Methode wird, nicht in eine DoubleNumber um?
Wenn das nicht gehen sollte, was hätte dann add() in der abstrakten Oberklasse zu suchen?
Ein Exception oder sogar ClassCastException zu werfen, würde das ganze Design sinnlos machen.

Würd die ClassCastException nicht eh fliegen, wenn er blind das Objekt castet und es zufällig nich von DoubleNumber sein sollte!?

Also die kann er in dem Fall ja nicht ausblenden. Die Idee mit instanceof ist in Anbetracht des Casts eigentlich unnötig, hatte ich ja oben schon korrigiert.

public Number add(Number number) {
    if (!(number instanceof NumberDouble))
            throw new IllegalArgumentException();

    NumberDouble result = new NumberDouble();
    result.fromString(String.valueOf(this.value + Double.valueOf(number.toString())));
    return result;
}

Wäre es nich viel intuitiver auf den values der Objekte zu arbeiten, statt immer in String und zurück zu wandeln?

public Number add(Number number) {
    NumberDouble n = (NumberDouble) number; //wirft ClassCastException
   
    return (new NumberDouble(n.value + this.value));
}

EDIT:

Die Konstruktoren müssten auch noch angepasst werden. Wo landet denn der Superaufruf in der abstrakten Klasse? Und der Standardkonstruktor aus NumberDouble kann doch auf den Standardkonstruktor der abstrakten Klasse verweisen.

public abstract class Number {
    
    public Number() {
        this("0");
    }

    public Number(String value) {
        fromString(value);
    }
}

public class DoubleNumber extends Number {
    
    public Number() {
        super();
    }

    public Number(String value) {
        super(value);
    }
}

 

[usrr]

Wäre es nich viel intuitiver auf den values der Objekte zu arbeiten, statt immer in String und zurück zu wandeln?

Klar wäre es das. Aber ich bin bisher nicht an die values drangekommen und habe deswegen den Umweg über die Strings genommen.

 

[diggaa1984]

ach stimmt, seh grad, die abstrakte Klasse hat ja gar keine Klassenvariable .. oeh dann geht das natürlich nich wie ich das geschrieben hab ^^

 

[usrr]

Doch es funktioniert, wenn ich den Konstruktor der NumberDouble zufüge:

    public NumberDouble(double value) {
        super();
        this.value = value;
    }

 

[diggaa1984]

hast recht, ich bin grad ein wenig verwirrt

 

[usrr]

So einen Schritt weiter:

Das ist das momentane Hauptprogramm:

package Number;

public class Test {

    public static void main(String[] args) {
        NumberDouble n = new NumberDouble("2");
        System.out.println( new NumberDouble(1).add(n) );
    }

}

Da ist ja später noch andere NumberObjekte geben wird, möchte ich keine speziellen Klassen im Hauptcode stehen haben.

Ich möchte, dass über einen Platzhalter lösen (weil ich es nicht besser weiß):

UseThisNumber.java

package Number;

class UseThisNumber extends NumberDouble {

    UseThisNumber() {
        super();
    }

    UseThisNumber(String value) {
        super(value);
    }

}

Komischerweise funktioniert jetzt das Hauptprogramm. Natürlich muss überall wieder auf den Konstructor über Text umgestellt werde.

package Number;

public class Test {

    public static void main(String[] args) {

        UseThisNumber n = new UseThisNumber("5");

        System.out.println( new UseThisNumber("7").add(n) );

    }
}

Ich werde, jetzt erstmal meinen Code anpassen und sehen ob ich weiter komme. Evtl. ist mein Problem schon gelöst.

 

[diggaa1984]

wo ist jetzt der Sinn hinter UseThisNumber?

die idee ist ja die abstrakte Klasse zu nutzen:

package Number;
 
public class Test {
 
    public static void main(String[] args) {
        Number n = new NumberDouble("2");
        System.out.println( n.add(new NumberDouble("1")) );
    }
 
}

 

[usrr]

Die Idee bzw. Not dahinter ist, dass ich an vielen Stellen im Algorithmus Zahlen erschaffe ... also ...

....
Number Zahl1 = new NumberDouble("1");
...
Number Zahl2 = new NumberDouble("2");
...

Ich will nicht alle Stellen ersetzen müssen, deswegen benutze ich die Zusatzklasse UseThisNumber.

 

[diggaa1984]

versteh ich ehrlich gesagt nicht ganz, zeig doch mal ein vorher/nachher Beispiel

 

[usrr]

Vorher

....
Number Zahl1 = new NumberDouble("1");
Number Zahl2 = new NumberDouble("2");
...
Number Zahl100 = new NumberDouble("100");
...

Beim Wechsel zwischen NumberDouble und NumberBigDecimal, müsste der Code an 100 Stellen geändert werden:

....
Number Zahl1 = new NumberBigDecimal("1");
Number Zahl2 = new NumberBigDecimal("2");
...
Number Zahl100 = new NumberBigDecimal("100");
...

Wenn ich eine Klasse dazwischen schalte, muss man nur noch an einer Stelle ändern.

 

[diggaa1984]

du möchtest dann Beispielsweise die Angabe hinter extends in der Klasse UseThisNumber ändern und damit die Änderung in den ganzen Zeilen umgehen?

 

[usrr]

du möchtest dann Beispielsweise die Angabe hinter extends in der Klasse UseThisNumber ändern und damit die Änderung in den ganzen Zeilen umgehen?

Genau das ist mein Plan!

Zum eigentlichen Problem. Nach dem Überarbeiten meines Codes läuft es jetzt. Ich denke ich weiß auch was mein Fahler war. Ich habe Number und UseThisNumber durcheinander geworfen.

Ich habe alles so geändert, dass für Rückgabewerte immer die abstrakte Klasse Number genommen wird, aber immer wenn mit new eine Zahl erzeugt wird verwende ich UseThisNumber. Wenn ich es jetzt so schreibe, hört sich das auch logisch an. Keine Ahnung warum ich in diese Erkenntnis knapp einen Tag investieren musste.

Ich markiere das Thema erstmal als gelöst, denke aber, dass noch Probleme auftreten könnte.

Vielen Dank!

Was noch offen ist, wäre auch die alternative Lösung von Michael... mit den Generics. Viel verstnden habe ich davon nicht

Das ist mit Generics möglich:

    abstract class AbstractNumber<T extends AbstractNumber>{
        abstract public T add(T num);
    }
    
    class DoubleNumber extends AbstractNumber<DoubleNumber> {
        public DoubleNumber add(DoubleNumber num) {
            return null;
        }
    }

Eventuell kann man das auch schöner lösen, bin mir da gerade nicht sicher.

 

[diggaa1984]

Ist es später nicht so, dass verschiedene Zahlformate parallel existieren (Ganzzahlen und Kommazahlen und weiss ich was noch alles)

Da müsstest du für jede dieser Typen eine Art "UseThisXNumber"-Klasse schreiben?!

Vielleicht wäre etwas in der Art intuitiver auch in der Verwendung:

public class NumberFactory {

    public static Number getDoubleNumber() {
        return getDoubleNumber(null);
    }

    public static Number getDecimalNumber() {
        return getDecimalNumber(null);
    }

    public static Number getDoubleNumber(String value) {
        if (value == null)
            return new DoubleNumber(); //oder eben eine andere Implementierung

        return new DoubleNumber(value); //oder eben eine andere Implementierung
    }

    public static Number getDecimalNumber(String value) {
        if (value == null)
            return new DecimalNumber(); //oder eben eine andere Implementierung

        return new DecimalNumber(value); //oder eben eine andere Implementierung
    }

das kann man ja beliebig weiterspinnen .. finde ich rein aus OOP-Aspekten sauberer, als eine Klasse zu erstellen die eine andere erweitert nur um eine spezielle Implementierung zu verwenden

 

[usrr]

Aus jetziger Sicht soll nur ein Zahlenformat verwendet werden, was sich aber später ändern könnte.

Wenn ich deinen Vorschlag richtig interpretiere würdest du eine Methode Implementieren, die Zahlen erzeugt, z.B.

Number giveMeNewNumber(){...}

Dann müsste ich immer nur diese Methode ändern. Das wäre allerdings eine Option.