Un metodo java con tipo di ritorno variabile e argomenti di input variabili

Question

Ho una classe Java astratta "BaseOperation". Questa classe ha un solo metodo astratto:

public abstract T execute() 
{ 
    ... 

    return T; 
} 

sottoclassi di BaseOperation deve implementare questo metodo:

public class GetUsersOperation extends BaseOperation<GetUsersResponse> 
{ 
    ... 

    @Override 
    public GetUsersResponse execute() 
    { 

     ... 

     return GetUsersResponse; 
    } 

} 

Questo è un ottimo modo per mettere tutti comuni logica "operazione" nella classe BaseOperation, ma avere ancora il metodo execute() della sottoclasse in calcestruzzo con un tipo di restituzione diverso.

Ora ho bisogno di cambiare questa struttura per consentire ai metodi execute() di avere una quantità variabile di argomenti. Per esempio, una sottoclasse concreta richiederebbe:

execute(String, int) 

e un altro avrebbe bisogno:

execute(Date, Date, String) 

Questo è difficile, perché il metodo execute viene dichiarato nella classe base. Semplicemente sovraccaricare i metodi di esecuzione nella base non è l'ideale. In primo luogo, la quantità di sovraccarichi sarebbe enorme. In secondo luogo, ogni sottoclasse utilizzerà sempre solo uno dei metodi di esecuzione, qual è il punto di tutti gli altri?

L'(a mio parere) soluzione più semplice sarebbe quella di dichiarare il metodo execute con varargs:

execute(Object... arguments) 

E poi downcast tutti gli argomenti nelle sottoclassi:

execute(Object... arguments) 
{ 
    String s = (String) arguments[0]; 
    ... 
} 

Ovviamente questo ha 2 principali Svantaggi:

• Prestazioni ridotte a causa di tutte le operazioni downcasting
• La chiamata dei metodi execute() non è più strettamente immessa perché è possibile passare qualsiasi quantità di oggetti senza avvisi del compilatore.

Esistono modelli o altre soluzioni che potrebbero non avere questi svantaggi?

Answer 1

Come già detto, l'approccio comune per risolvere il problema è l'utilizzo di parametri di mantenimento dei bean.Ma qui è un'altra soluzione, basata su un approccio costruttore:

public interface BaseOperation<T> { 
    public T execute(); 
} 

public class AddOperation implements BaseOperation<Integer> { 
    private int a, b; 

    public void setA(int arg){ 
    a = arg ; 
    return this; 
    } 

    public void setB(int arg){ 
    b = arg; 
    return this; 
    } 

    @Override 
    public Integer execute() { 
    return a+b ; 
    } 
} 

E poi usare in questo modo:

new AddOperation().setA(1).setB(2).execute(); 

È possibile miscelazione desiderata e parametri opzionali in questo modo:

public class MultipleAddOperation implements BaseOperation<Integer> { 
    private int sum ; 

    public MultipleAddOperation(int requiredInt){ 
    sum = requiredInt; 
    } 

    public void add(int optionalInt){ 
    sum += optionalInt ; 
    return this; 
    } 

    @Override 
    public Integer execute(){ 
    return sum; 
    } 
} 

E così:

new MultipleAddOperation(5).add(1).add(2).execute(); 

Answer 2

si potrebbe usare un fagiolo tenendo i parametri:

public interface BaseOperation<T, U> { 
    T execute(U input); 
} 

public class GetUsersOperation implements BaseOperation<GetUsersResponse, UserInput> { 

    @Override 
    public GetUsersResponse execute(UserInput input) { 
     Date date = input.getDate(); 
     return new GetUsersResponse(date); 
    } 

} 

tua classe astratta ha solo un unico metodo astratto: meglio usare un'interfaccia. È possibile implementare diverse interfacce mentre è possibile estendere solo una classe.