Cancellazione di Java con sovraccarico generico (non sovrascrivibile)

Ho FinanceRequests e CommisionTransactions nel mio dominio. Se ho un elenco di FinanceRequests ogni FinanceRequest potrebbe contenere più CommisionTransactions che devono essere recuperati. Non preoccuparti di come esattamente ciò è fatto.

La class di seguito (molto in basso) mi fa sentire tutto sfocato e caldo sin dalla sua succinta e riutilizza il codice esistente in modo piacevole. Un problema Digitare la cancellazione.

public void clawBack(Collection financeRequestList) public void clawBack(Collection commissionTrnsList) 

Entrambi hanno la stessa firma dopo la cancellazione, cioè:

 Collection --> Collection Collection --> Collection 

Quindi eclipse si lamenta che:
Il metodo clawBack (Collection) ha la stessa cancellazione clawBack (Collection) come un altro metodo nel tipo CommissionFacade

Qualche suggerimento per ristrutturare questo in modo che sia ancora una soluzione elegante che renda un buon riutilizzo del codice?


     public class CommissionFacade { /********FINANCE REQUESTS****************/ public void clawBack(FinanceRequest financeRequest) { Collection commTrnsList = financeRequest.getCommissionTrnsList(); this.clawBack(commTrnsList); } public void clawBack(Collection financeRequestList) { for(FinanceRequest finReq : financeRequestList) { this.clawBack(finReq); } } /********COMMISSION TRANSACTIOS****************/ public void clawBack(CommissionTrns commissionTrns) { //Do clawback for single CommissionTrns } public void clawBack(Collection commissionTrnsList) { for(CommissionTrns commTrn : commissionTrnsList) { this.clawBack(commTrn); } } } 

    Rinominare i metodi o utilizzare il polimorfismo: utilizzare un’interfaccia e quindi inserire il codice di clawback negli oggetti stessi oppure utilizzare la doppia distribuzione (a seconda del paradigma e del gusto del progetto).

    Con il codice negli oggetti che sarebbero:

     public interface Clawbackable{ void clawBack() } public class CommissionFacade { public  void clawBack(Collection objects) { for(T object: objects) { object.clawBack(); } } } public class CommissionTrns implements Clawbackable { public void clawback(){ // do clawback for commissions } } public class FinanceRequest implements Clawbackable { public void clawBack(){ // do clwaback for FinanceRequest } } 

    Preferisco questo approccio, dal momento che sono convinto che il tuo dominio dovrebbe contenere la tua logica; ma non sono pienamente consapevole dei tuoi esatti desideri, quindi lascerò tutto a te.

    Con una doppia spedizione, si passa il “ClawbackHandler” al metodo clawback e sul gestore si chiama il metodo appropriato a seconda del tipo.

    Penso che la tua migliore opzione sia semplicemente nominare il metodo in modo diverso.

     public void clawBackFinReqs(Collection financeRequestList) { } public void clawBackComTrans(Collection commissionTrnsList) { } 

    In realtà, non è troppo male, dal momento che non si ottiene nulla in più di avere lo stesso nome su di loro.

    Tenere presente che la JVM non deciderà quale metodo chiamare in fase di runtime. Al contrario dei metodi virtuali / la risoluzione del metodo prevalente dei metodi sovraccaricati viene eseguita in fase di compilazione. I tutorial Java sull’overloading dei metodi sottolineano anche che “i metodi con overload devono essere usati con parsimonia …” .