[Java] Downcastin Problem

Computer: Software & Programmierung Programmierung allgemein
#1

Dies ist eine schöne (eigentlich interressant) an der ich mir jetzt schon ziemlich die Zähne
ausgebissen habe.

Ich suche eine Möglichkeit eine Objekt vom Type Objekt zurück in seine Ursprungsklasse
zurück zu casten. Das Problem ist daß ich von einer Funktion ein Objekt zurückbekomme jedoch die
Entscheidung welche Funktion aufgerufen wird anhand des Typen machen muß. Bei meinem Problem
sind es jedoch weitaus mehr Type, so daß das Ergebnis weitaus Chaotischer aussieht.

meine Lösung,mit der ich nicht zufrieden bin, ist bis jetzt:

public void tuWas(Typ1 typ){System.out.println(„Typ1“);}
public void tuWas(Typ2 typ){System.out.println(„Typ2“);}

public void tuWas(Objekt objec){
Class cc=(Class)(objec).getName();
String classType=cc.getName();
if (classType==„Typ1“){
tuWas((Typ1)objec);
return;
}
if (classType==„Typ2“){
tuWas((Typ2)objec);
return;
}
}


Ich suche jedoch eine Möglichkeit wie ich direkt zu dem Typen hincasten kann ohne zur Compilezeit
zu wissen welchen Typ ich den brauche.

Falls jemand eine Lösung weiß wäre ich ihm wahnsinnig Dankbar
iSt

#2

Wenn ich Dein Problem richtig verstanden habe, gibt es zwei Loesungsmoeglichkeiten, die sehr aehnlich sind und deren Angemessenheit von der jeweiligen Situation abhaengt:

a)
Beide Typen erben von einer Basisklasse, in dieser ist die Methode „tuWas“ abstract, implementiert wird sie dann (wohl jeweils verschieden) in Typ1 u. Typ2. Du machst dann einfach einen cast auf die Basisklasse und rufst an ihr tuWas auf, das Objekt führt dann automatisch (abhaengig von seiner Klasse zur Laufzeit) die richtige Methode tuWas aus:

abstract class BasisKlasse
{
public abstract void tuWas();
}

class Typ1 extends BasisKlasse
{
public void tuWas()
{
// Implemetation
}
}

class Typ2 extends BasisKlasse
{
public void tuWas()
{
// Implemetation
}
}

Downcast geht so:

Object obj = getIt();
((BasisKlasse) (obj)).tuWas();

b) ziemlich genauso, nur nimmst Du diesmal ein Interface

Interface TuWasKlasse
{
void tuWas();
}

class Typ1 implements TuWasKlasse
{
public void tuWas()
{
// Implemetation
}
}

class Typ2 implements TuWasKlasse
{
public void tuWas()
{
// Implemetation
}
}

Downcast geht genauso:

Object obj = getIt();
((TuWasKlasse) (obj)).tuWas();

Hoffe, geholfen zu haben.

Bernd

#3

Moin,

Ich suche eine Möglichkeit eine Objekt vom Type Objekt zurück
in seine Ursprungsklasse zurück zu casten.

Ich verstehe nicht ganz, was Du mit

Class cc=(Class)(objec).getName();
String classType=cc.getName();

erreichen willst. Ich weiß nicht, ob das
((Class)(objec)).getName()
oder
(Class)((objec).getName())
ausgewertet wird (darum würde ich auch klammern), beides wäre falsch. Benutze o.getClass();

Das Problem ist daß ich von einer Funktion
ein Objekt zurückbekomme jedoch die
Entscheidung welche Funktion aufgerufen wird anhand des Typen
machen muß. Bei meinem Problem
sind es jedoch weitaus mehr Type, so daß das Ergebnis weitaus
Chaotischer aussieht.

Klingt nach Interface.


Was’n das?

Thorsten

#4

Danke erstmal für eure Hilfe aber ich habe jetzt eine Lösung gefunden (Double-Dispatch oder Visitor Pattern ich bin mir nicht sicher was es genau ist):

interface I_Test{
public void TuWas();
}
abstract class Test implements I_Test{
public void TuWas(){};
public void LassLassTuen(){}
}

class konkret1 extends Test implements I_Test{
public void TuWas(){System.out.println(„Konkret1.tuwas“);}
public void LassLassTuen(){TestMain.LassTuen(this);}
}

class konkret2 extends Test implements I_Test{
public void TuWas(){System.out.println(„Konkret2.tuwas“);}
public void LassLassTuen(){TestMain.LassTuen(this);}
}


public class TestMain {
public static void LassTuen(konkret1 t){t.TuWas();}
public static void LassTuen(konkret2 t){t.TuWas();}
public static Test getClass(int i){
if(i==1){ return new konkret1();}
else{ return new konkret2();}
}
static void main(String argv[]){
Test kon=getClass(1);
kon.LassLassTuen();
kon=getClass(2);
kon.LassLassTuen();
}
}

#5

Moin,

Irgendwie muß Deine Fragestellung unvollständig gewesen sein. Sowohl getClass() als auch Vererbung oder Interface wären einfacher gewesen.

Thorsten