Come richiamare un metodo java basato su un tipo di sottoclasse?

Question

Sto provando a inviare oggetti per separare il metodo in base alla loro sottoclasse.

Ad esempio, consideriamo quei 2 oggetti

class A extends I {} 
class B extends I {} 

e il metodo

void dispatch(I i) {} 

in dispatch(), vorrei richiamare un metodo in base al tipo di i. Quindi se i è effettivamente di tipo A, verrà chiamato il metodo handlerA(A a). Se è di tipo B, verrà chiamato handlerB(B b) e così via ... Ho provato con l'overloading del metodo, ma suppongo che non funzioni in questo modo

qual è il modo migliore per raggiungere questo obiettivo? Vorrei evitare di usare if/else ...

Grazie in anticipo,

edit: non riesco a modificare alcuna di queste classi.

Answer 1

Così I si dichiara il metodo handler(), ed attuare in modo appropriato (cioè diverso) sia A e B.

Si tratta di polimorfismo :)

Answer 2

Utilizzare il Visitor Pattern.

In breve, hanno I dichiarare un metodo accept(Visitor<T> ...), e hanno Visitor esporre onA(A ...), onB(B ...), ecc metodi. Le implementazioni dell'interfaccia I chiameranno il metodo appropriato sul passato in Visitor<T>.

Probabilmente non ne vale la pena (a causa del boilerplate) se si hanno solo 2 classi concrete, ma da qualche parte attorno ai 3 o 4 inizia a valerne la pena - se non altro per evitare duplicati if-else.

Answer 3

Dal momento della modifica, presumo che non sia possibile modificare A, B e I; questo porta a una brutta notizia:

È possibile ereditare da A dicono C in questa classe (C) si può chiamare super.dispatch() modo da poter raggiungere la classe di base A.dispatch().

• Ma grazie al design (eredità sconsiderata) non è possibile raggiungere I. Sarebbe come chiamare super.super che non è consentito

• In Java, non è possibile chiamare super(). Super() .. I bambini hanno accesso ai loro genitori, ma non ai loro nonni.

Quindi sei vittima di un cattivo design. MODIFICA: risolto errore di battitura

Answer 4

Sembra che l'unico modo per farlo sia utilizzare il controllo del tipo. Capisco che questo non dovrebbe essere incoraggiato, ma ...

void dispatch(I i) 
{ 
    if(i instanceof A) 
    { 
     handlerA(); 
    } 
    else 
    { 
     handlerB(); 
    } 
} 

Ma seriamente, se puoi evitarlo del tutto, non scrivere codice come questo. Se non riesci a modificarli, potresti per caso estendere A e B, aggiungere un altro metodo handler() per entrambi e usare queste nuove sottoclassi invece di A e B?

Answer 5

Penso che in questo caso lo Adapter Pattern sia più applicabile del Pattern visitatore.

Answer 6

Se si potesse utilizzare Scala, è possibile scrivere

i match { 
    case a: A => handlerA(a) 
    case b: B => handlerB(b) 
    case _ => throw new Exception("Unknown i: " + i.toString) 
}