Vererbung und Funktionsaufruf

[Corcovado]

Hallo,
s sollte ein ziemliches Standardproblem sein mit Vererbung. Ich habe folgende drei Klassen.
derived erbt von base. Dann hab ich eine dritte Klasse in der eine Variable der Basisklasse definiert wird (x):

//base.java
public class base{
    public base(){}

    public void basefunction(){
	System.out.println("base function");
    }
}

// derived.java
class derived extends base{
    public derived(){}

    public void derivedfunction(){
	System.out.println("derived function");
    }
}

// control.java
class control{
    public control(){}

    public static void main(String[] argv){
	base b = new base();
	b.basefunction();

	derived a = new derived();
	a.derivedfunction();
	a.basefunction();

	//////////// Problem:
	base x = a;
	x.basefunction();
	x.derivedfunction(); // findet die Funktion nicht, warum ??? Gibts Wege das in Java hinzubekommen?
    }
}

Meine Frage:
Ist es moeglich eine Objekt des Typs der Basisklasse zu deklarieren und dann mit dem Konstruktor der abgeleiteten Klasse zu definieren, so dass ich Funktionen, von Basis und von abgeleiteter Klasse aufrufen kann?
Wieso geht is bei mir nicht und wie macht man sowas normalerweise (bitte mit Codezeile)?
Danke

 

[Roar]

du hast ein objekt x vom typ base. in base gibt es keine methode derivedfunction() darum kriegst du logischer weise einen fehler. java kann doch nicht wissen was in x steckt. für ihn ist es genauso möglich dass da ein objekt vom typ base dri nis und nicht von einer unterklasse. du musst dein x casten:
((derived)x).derivedfuction();

 

[Corcovado]

nja, dass java das nicht erraten kann, wenn ich ihm nen Object vom Typ "base x" hinschmeisse is mir klar - aber ich dachte, wenn ich das dann schon mit dem Konstruktor von derived() definiere, dann muesste es doch auch zusaetzliche Funktionalitaet von derived dazubekommen?!

Was ist denn dann bitte der Unterschied zwischen:

base b = new base();
// und 
base b = new derived();

ist das dasselbe, mein Compiler macht jedenfalls beides anstandslos? Ist casten wirklich der einzige Weg das zu machen, sollte man casten nicht eher vermeiden, wie ist das in java (ich habe da so schlechte Erinnerungen an downcasts in C++)?

 

[Roar]

für java ist 'b' einfach nur ein objekt vom typ "base". ob da nun base oder ferived oder kartoffelsalat dri nist weiß es nicht...

 

[meez]

Es gibt keinen Unterschied. Ist beides base

 

[Corcovado]

...ich hab grad selber festgestellt, das man

base x = new derived();
x.basefunction();
((derived)x).derivedfunction(); // geht mit cast

base y = new base();	
((derived)y).derivedfunction(); // wirft classCastException

...es ist also nicht dasselbe, aber trotzdem gut geraten danke
Ich will aber nun nicht jedes mal wenn ich eine Funktion der abgeleiteten Klasse hernehmen will, explizit casten,
kann ich x nicht dauerhaft zu einem Objekt der derived Klasse machen?

Wenn ich es so versuche:

	x = ((derived)x);
	x.derivedfunction(); // geht nicht: Fehlermeldung !!!

In meinem eigentlchen Problem handelt es sich darum, dass ich nen Vektor hab (Vector a) und ich habe eine Klasse von Vector abgeleitet (myVector b), in den andern Klassen deklariere ich eben zunaechst klassenweit Vector-Objekte, die ich dann konkret in den wiederum davon abgeleiteten Klassen immer als myVector benoetige, also gerne im konkreten Konstruktor auf myVector dauerhaft casten will? (das Bsp sollte nur zur Erlaeuterung dienen, wenns unverstaendlich is isses auch egal, die Antworten auf die obige Situation sind dieselben.)

 

[Illuvatar]

Du könntest

derived dx = (derived)x;

schreiben.
Wenn du testen willst,, ob ein Objekt von einem Typ ist, nimmst du übrigens den instanceof-Operator:

base b = //methode um objekt zu kriegen
b.basefunction();
if (b instanceof derived){
 ((derived)b).derivedfunction();
}

Und noch eine Anmerkung: Laut einer Konvention sollte man Klassennamen immer groß schreiben. Also Base, Derived und Control.

 

[Corcovado]

Hallo
Klassen immer gross und "instanceof" zum Typ pruefen !!! OK, danke, ich werds mir merken und glaube ich muss noch einiges lernen

Das obige ist schon irgendwie klar aber ich habe trotzdem noch folgende Frage :

...
	Base x = new Derived();
	x.basefunction();
	((Derived)x).derivedfunction();  // funzt
	x.derivedfunction(); // funzt nicht, da nicht permanent gecastet - Problem !!
	
	// ... also wie schaffe ich es, dass x nun permanent den Typ von Derived annimmt und nicht mehr Base ist ???

	x = (Derived)x; // Methode 0: funzt nicht ??!!!! - hab ich etwas falsch gemacht ?

	Derived w = (Derived) x; // Methode 1: dann heisst aber das Objekt w und eben nicht mehr x (wie ich es gerne haette)
	w.derivedfunction(); // geht jetzt (mit w halt)

	// todo: Methode 2: ???
        //was ich ausgeben will ist das hier :
	x.derivedfunction();   // aber es geht nicht
...

in Worten:
Wie schaffe ich es einen Typ eines (eigenen) Objektes dauerhaft umzucasten ?

Ich glaube in C++ war das Typumcasten ein Fall von reinterpret_cast<> und das Downcasten ein Fall von dynamic_cast<>
Vielleicht hat ja jemand schon mal das Problem gehabt in JAVA...

 

[Beni]

Du musst eine neue Variable anlegen:

Base x = new Derived();
Derived y = (Derived)x; // x sollte ein Derived sein, sonst krachts :-)
y.derivedfunction();

Alles andere geht nicht. Denn während das Progi läuft, wird der Typ der Variable angeschaut (der unveränderbar ist), nicht der Typ des Objektes, welches dahintersteht.

 

[Bleiglanz]

man sollte lernen, zwischen dem Typ einer Variablen (zur Compilezeit, für javac) und dem Class-Objekt, das jeder Objektinstanz zugeordnet ist (zur Laufzeit) zu unterscheiden

Wenn irgendwo steht

Ober x = new Unter();

dann wird zur Laufzeit ein Objekt erzeugt (mit class = Unter); dieses kann NICHT "umgecastet" werden, es behält IMMER seine "Klassigkeit", bis es irgendwann entsorgt wird

dass die Variable x den Typ "Ober" hat, lässt sich ebenfalls NICHT mehr ändern, x kann aber Objektreferenzen auf Objekte enthalten, die zum Typ "Ober" passen...

mit Unter y = (Unter) x kann man runtercasten, aber dazu braucht man eine neue Variable....

Casts dienen also nur dazu, zur Laufzeit "Objektinstanz-Referenzen" in die richtigen "Variablen" reinzulegen, weder am Typ von Variablen noch an der "Class" von Objektinstanzen ändert sich jemals etwas

 

[Corcovado]

Super - geile Antwort, danke !!!!

(endlich Klarheit ...)