Frage zur Vererbung.

[zoid]

Hallo zusammen,

hätte 'ne kurze Frage zu Vererbung, stehe da irgendwie auf dem Schlauch.
Mache gerade die beliebte Übungsaufgabe rationale Zahlen und normierte rationale Zahlen zu implementieren.
Dabei erbt NormRational von Rational, so habe ich in der Rational-Klasse Methoden zur Addition geschrieben:

public class Rational {
	
    long numerator; // Zähler
    long denominator; // Nenner
     ...

    public Rational(long numerator, long denominator) {
		this.numerator = numerator;
		this.denominator = denominator;
    }

    ...
    public void add(Rational r){
		Rational q = Rational.add(this,r);
		this.numerator = q.numerator;
		this.denominator = q.denominator;	
    }
	
    public static Rational add(Rational r, Rational q){
		return new Rational(r.numerator * q.denominator + q.numerator * r.denominator, 
	   r.denominator * q.denominator);		
    }
}

... wenn ich jetzt damit rechne liefert mir die Methode natürlich eine Rational zurück, auch wenn ich sie bei einer NormRational verwendet wird.
In NormRational wollte ich eigentlich nur die zwei Funktionen zum normieren/kürzen neu schreiben, und den Rest erben, dachte wäre Sinn der Sache. Allerdings bekomme ich so immer nen type mismatch, jedes mal casten ist auch nicht das gewünschte.
Jetzt habe ich die ".add" Methode überschrieben:

  public void add(NormRational r){
		Rational s = NormRational.add(this, r);
		this.numerator = s.numerator;
		this.denominator = s.denominator;
		this.normalize();
	}
	
	public static NormRational add(NormRational r, NormRational q){
		Rational s = Rational.add(r, q);
		return new NormRational(s.numerator,s.denominator);
	}

Macht man das so? Oder kann man das auch anders, einfacher oder mehr dem Java Konzept folgend haben?

Danke im voraus,
zoid

 

[Rydl]

ja wenn du in deiner rational-klasse explizit ein rational objekt zurückgibst, ist das kein wunder. außerdem kommt dir die static-geschichte noch in die quere, wenn ich mich nicht täusche.
versuch doch mal sowas:

public class Rational {
public <T extends Rational> T add(T r, T q) { ... }
}

 

[Guest]

Hi,
nein, ein Wunder ist das nicht, warum das so ist, ist mir klar, die Frage ist, kann man das besser machen?
Wie genau sollen denn die static Methoden in die Quere kommen?
Deinen code muss ich erstmal nachlesen, was das bedeutet.

Danke,
zoid

 

[Rydl]

man kann static methoden nicht überschreiben.
besser macht man das ganze mit generischen rückgabewerten.
in meinem beispiel ist der rückgabewert vom typ T, welcher von deiner oberklasse abgeleitet ist. die parameter sind ebenfalls vom typ T.
T kann nun Rational sein oder NormRational oder jeder typ der von Rational erbt.

such einfach mal nach generics: http://www.google.com/search?client=safari&rls=de-de&q=generics+java&ie=UTF-8&oe=UTF-8

 

[Guest]

hmm, kann man überhaupt von Überschreiben reden, bei einer anderen Signatur, also anderen Parametern? (ich weiss, hab ich gesagt)
Funktionieren tut's ja.
Werd mir das mal anschauen mit den generischen Rückgabewerten, scheint mir sinnvoller zu sein.

 

[hansz]

Hallo zoid,

bei Vererbung im Zusammenhang mit Instanzmethoden und Klassenmethoden (statische Methoden) kommen schnell die Begriffe "Overriding" und "Hiding" ins Spiel.

Vielleicht hilft Dir der Link

www.javaseiten.de/ch01s07.html

weiter (auf Unterpunkt "1.7.5. Overriding und Hiding" gehen).

Ist ein bisschen eine "verzwickte Sache" :shock:, aber formal eindeutig geklärt.

 

[zoid]

ja wenn du in deiner rational-klasse explizit ein rational objekt zurückgibst, ist das kein wunder. außerdem kommt dir die static-geschichte noch in die quere, wenn ich mich nicht täusche.
versuch doch mal sowas:

public class Rational {
public <T extends Rational> T add(T r, T q) { ... }
}

Hi, Danke für die vielen Antworten.
Ich habe jetzt einiges gelesen, allerdings ist mir immer noch nicht klar, wie ich jetzt den generischen Typ zurückgebe.
Ich erstelle ja eine neue Instanz die zurückgegeben wird...?

Danke.

 

[xdavidx]

Hey,

welchen Fehler bekommst du? (can not convert from void to normalrat)?

und wo?

Deine add Methode sollte lieber ein neues Objekt zurueck geben und static sein (Keine Objectmethode)!

	public static CRational add(CRational r1, CRational r2)
	{
		return new CRational(r1.mZaehler*r2.mNenner 
				             + r1.mNenner*r2.mZaehler,
				             r1.mNenner*r2.mNenner);
	}

Und dann geht das mit dem erben auch!

Vlg

 

[Marco13]

Das ist glaubich nicht das, was ursprünglich gemeint war. FALLS ich das richtig verstanden habe: Es gibt Klassen

class Rational
{
    void add(Rational other) { ... }
    ...
}

class NormRational extends Rational
{
    ...
}

Und nun soll es eine statische Methode geben, die zwei Objekte addiert - entweder, es werden Rational-Objekte übergeben und man bekommt eine Rational-Objekt zurück, oder es werden NormRational-Objekte übergeben, und man bekommt ein NormRational-Objekt zurück. Die unterschiedlichen Rückgabetypen könnte man mit der Methode erschlagen, die schon vorgeschlagen wurde

class Rational
{
    public static <T extends Rational> T add(T r, T q) { ... } 
}

Damit funktionieren beide Fälle:

        Rational a = new Rational();
        Rational b = new Rational();
        Rational c = Rational.add(a,b);

        NormRational na = new NormRational();
        NormRational nb = new NormRational();
        NormRational nc = Rational.add(na,nb);

Das Problem ist jetzt, dass man dort kein Objekt zurückgeben kann. Man müßte ja ein neues Objekt vom Typ "T" erstellen - der aber zur Laufzeit nicht bekannt ist.

Die einzige Abhilfe wäre irgendwas, was "äquivalent zu einer Factory" ist. Also, es muss dieser Methode ein Objekt übergeben werden, das ein neues Objekt vom Typ T erstellen kann. Ob diese statische hilfs-add-Funktion dann noch Sinn macht, ist fraglich. Dann wäre es einfacher, ein neues Objekt (vom geünschten Typ) per Hand zu erstellen, und zweimal add aufzurufen (zumal man ja vielleicht auch sowas wie normRational.add(rationalNotNorm); aufrufen können will....)

 

[xdavidx]

Ein NormRational ist doch ein Rational Objekt und deswegen brauch er die add Methode in der Klasse NormRational nicht neu zu implementieren!

		CRational a = new CRational(1,4);
		CRational2 b = new CRational2(1,4);
		
		System.out.println(CRational.add(a,b)); //static KlassenMethode aus CR
		
		b.addWith(a); //b ruft ObjectMethode aus CRational auf!
		
		System.out.println(b);

 

[Guest]

Hallo,
dann möchte ich nochmal etwas Licht in´s Dunkel bringen.

1. Es gibt eine Rational Klasse, mit einer statischen und einer Object - "add" Methode, siehe erster Post.
Der Sinn der Sache liegt auf der Hand, man hat eine statische Methode um 2 Rationals zu addieren und da man eine Methode nicht 2 mal schreibt, greift die Object Methode auf die statische zurück.
(So soll es jedenfalls bei uns sein, kann sein, dass das gar nicht (immer) so sinnvoll ist!?)

2. Es gibt eine Klasse NormRational, die eigentlich - so habe ich mir das gedacht - nur noch eine weiter Methode zum normieren enthält und alles andere von Rational erbt.

3. Wenn ich jetzt mit NormRational.add(NormRational,NormRational) rechne, bekomme ich trotzdem ein Rational Object zurück, ich gebe ja in der statischen Methode in Rational, die die Addition letztendlich umsetzt, explizit eine Rational zurück.

Ich hätte jetzt gedacht, ich könnte auch, wenn ich NormRational "reingebe" auch wieder NormRational rausbekommen, ohne die .add Methode in NormRational noch mal neu implementieren zu müssen (siehe erster Post 2. Codeblock). Denn sie macht eigentlich nichts..
Genauso soll von NormRational noch eine Klasse, die "comparable" implementiert, abgeleitet werden, dass hiesse ich müsste alles 3 mal implentieren... allein wegen des anderen Rückgabetyps. Dafür suche ich eine Lösung.

Vielleicht stelle ich mir das aber auch falsch vor.

class Rational
{
    public static <T extends Rational> T add(T r, T q) { ... }
}

reicht dazu leider nicht aus, das ändert ja nicht den Rückgabetyp.

Gruß & Dank
zoid

 

[xdavidx]

Ich hätte jetzt gedacht, ich könnte auch, wenn ich NormRational "reingebe" auch wieder NormRational rausbekommen, ohne die .add Methode in NormRational noch mal neu implementieren zu müssen (siehe erster Post 2. Codeblock). Denn sie macht eigentlich nichts..

Das bekommst du doch.

Ein NormRational Objekt ist ein Rational Objekt!

Außerdem du hast eh einen Logikfehler in deiner Klasse...

Schreib lieber in deiner Rational Klasse eine Methode normalisieren();

Vlg

 

[Marco13]

Ein NormRational Objekt ist ein Rational Objekt!

Aber...ein Rational Objekt ist nicht notwendigerweise ein NormRational Objekt!

Ganz pragmatisch: Er will eine Methode, die
Rational+Rational rechnet, und Rational zurückgibt
oder (wahlweise, mit derselben statischen Methode)
NormRational+NormRational rechnet, und dann auch NormRational zurückgibt.

Nochmal die Preisfrage: Was muss anstelle des "?" stehen, damit das Programm
Rational 3
NormRational 3
ausgibt?

class RationalTest
{
    public static void main(String args[])
    {
        Rational r = Rational.add(new Rational(1),new Rational(2));
        NormRational nr = Rational.add(new NormRational(1),new NormRational(2));

        System.out.println(r);
        System.out.println(nr);
    }
}

class Rational
{
    int value;

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

    void add(Rational other)
    {
        value += other.value;
    }

    public String toString()
    {
        return "Rational "+value;
    }

    public static <T extends Rational> T add(T r, T q)
    {
        //---------------------------------------------------------------------
        ?
        //---------------------------------------------------------------------
    }
}

class NormRational extends Rational
{
    public NormRational(int value)
    {
        super(value);
    }

    public String toString()
    {
        return "NormRational "+value;
    }
}

 

[zoid]

Ich hätte jetzt gedacht, ich könnte auch, wenn ich NormRational "reingebe" auch wieder NormRational rausbekommen, ohne die .add Methode in NormRational noch mal neu implementieren zu müssen (siehe erster Post 2. Codeblock). Denn sie macht eigentlich nichts..

Das bekommst du doch.

Ein NormRational Objekt ist ein Rational Objekt!

Naja, das dachte ich ja eben auch. Geht aber nicht bei:

NormRational a = new NormRational(3);
		NormRational b = new NormRational(3);
		NormRational c = NormRational.add(a, b);

bekomme ich schon beim kompilieren den Fehler, incompatible types.

Außerdem du hast eh einen Logikfehler in deiner Klasse...

...eh, verrätst Du mir auch, wo der sein soll?

Schreib lieber in deiner Rational Klasse eine Methode normalisieren();

Vlg

.. dagegen Sprechen 3 Gründe.
1.) Ich würde gerne wissen, wie man's richtig macht.
2.) Stünde ich bei der nächsten geerbten Klasse wieder beim selben Problem.
3.) Das Leben ist kein Wunschkonzert.

Gruß
zoid

 

[zoid]

Ein NormRational Objekt ist ein Rational Objekt!

Aber...ein Rational Objekt ist nicht notwendigerweise ein NormRational Objekt!

Ganz pragmatisch: Er will eine Methode, die
Rational+Rational rechnet, und Rational zurückgibt
oder (wahlweise, mit derselben statischen Methode)
NormRational+NormRational rechnet, und dann auch NormRational zurückgibt.

Nochmal die Preisfrage: Was muss anstelle des "?" stehen, damit das Programm
Rational 3
NormRational 3
ausgibt?

...
    public static <T extends Rational> T add(T r, T q)
    {
        //---------------------------------------------------------------------
        ?
        //---------------------------------------------------------------------
    }
}

...

Hi marco13,
schön, dass Du mein Problem erkannt hast. \o/
Genau das möchte ich wissen, hab's aber noch nicht kapiert. (irgendwas mehr oder weniger vom "Typ" T, aber wie schreib ich das?)
Ist das denn jetzt so eine ungewöhnliche Vorgehensweise?

Danke
zoid

 

[Marco13]

Zumindest weißt du jetzt, was du im ersten Beitrag hättest schreiben müssen, um gleich eine Antwort zu bekommen :bae: Und die Antwort ist: Das geht nicht. Der Typ T ist nur während des Compilierens bekannt. Wenn das Programm erstmal läuft, wird das T einfach durch ein "Rational" ersetzt. Man kann kein Objekt von einem Typ anlegen, den man nicht kennt *.

Man könnte aber diese "einzige, kleine Operation", die man nur schwer generisch machen kann (nämlich das erstellen des Objektes) dem Benutzer zu überlassen. Oben hatte ich schonmal erwähnt, dass der Sinn dieser statischen add-Methode dadurch irgendwie verloren geht. Man könnte sie einfach weglassen ... oder ggf. in die Rational-Klasse eine Methode add(Rational a, Rational b) aufnehmen (die dann auch für NormRationals funktionieren würde).

class RationalTest
{
    public static void main(String args[])
    {
        Rational r = new Rational(0);
        r.add(new Rational(1),new Rational(2));
        NormRational nr = new NormRational(0);
        nr.add(new NormRational(1),new NormRational(2));

        System.out.println(r);
        System.out.println(nr);
    }
}

class Rational
{
    int value;

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

    void add(Rational a, Rational b)
    {
        value = a.value + b.value;
    }

    public String toString()
    {
        return "Rational "+value;
    }

}

class NormRational extends Rational
{
    public NormRational(int value)
    {
        super(value);
    }

    public String toString()
    {
        return "NormRational "+value;
    }
}

Eine andere Alternative wäre, das Objekt das "gefüllt" werden soll, mitzugeben

class Rational
{
    public static <T extends Rational> T add(T r, T q, T result)
    {
        result.add(r);
        result.add(q);
        return result;
    }

aber... in diesem Fall wäre die Methode IMHO ziemlich unnötig... :?





Zu *: Natürlich kann man dort ein neues Objekt vom passenden Typ erstellen - man hat ja schon Objekte dieses Type, und kann sich von denen die Klasse holen. Allerdings sollte man für sowas banales wie das Addieren zweier Zahlen nicht mit Relfection, newInstance usw. rumfuhrwerken....

class RationalTest2
{
    public static void main(String args[])
    {
        Rational r = Rational.add(new Rational(1),new Rational(2));
        NormRational nr = Rational.add(new NormRational(1),new NormRational(2));

        System.out.println(r);
        System.out.println(nr);
    }
}

class Rational
{
    int value;

    public Rational()
    {
    }

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

    void add(Rational other)
    {
        value += other.value;
    }

    public String toString()
    {
        return "Rational "+value;
    }

    public static <T extends Rational> T add(T r, T q)
    {
        try
        {
            Rational result = (Rational)r.getClass().newInstance();
            result.add(r);
            result.add(q);
            return (T)result;
        }
        catch (InstantiationException e)
        {
            e.printStackTrace();
        }
        catch (IllegalAccessException e)
        {
            e.printStackTrace();
        }
        return null;
    }
}

class NormRational extends Rational
{
    public NormRational()
    {
    }

    public NormRational(int value)
    {
        super(value);
    }

    public String toString()
    {
        return "NormRational "+value;
    }
}

 

[Zoid.]

Hi.
wollte mich noch für die ausführliche Antwort samt bewerteten Alternativen beantworten. Hat mir sehr geholfen.

Gruß
Zoid