Eliminação de Java com sobrecarga genérica (não substituindo)

Eu tenho FinanceRequests e CommisionTransactions no meu domínio. Se eu tiver uma lista de FinanceRequests, cada FinanceRequest poderá conter várias CommisionTransactions que precisam ser recuperadas. Não se preocupe como exatamente isso é feito.

A class abaixo (muito abaixo) faz com que eu me sinta todo confuso e quente desde a sua sucinta e reutilize código existente bem. Um problema Digite o apagamento.

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

Ambos têm a mesma assinatura após o apagamento, ou seja:

 Collection --> Collection Collection --> Collection 

Então eclipse reclamar que:
O método clawBack (Collection) possui o mesmo clawBack (Collection) de eliminação que outro método no tipo CommissionFacade

Alguma sugestão para reestruturar isso para que ainda seja uma solução elegante que faça uma boa reutilização de código?


 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); } } } 

Renomeie os methods ou use polymorphism: use uma interface e, em seguida, coloque o código clawback nos próprios objects ou use o despacho duplo (dependendo do paradigma e do sabor do design).

Com código em objects que seriam:

 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 } } 

Eu prefiro essa abordagem, já que acredito que seu domínio deve conter sua lógica; mas eu não estou totalmente ciente de seus desejos exatos, então eu vou deixar isso para você.

Com um despacho duplo, você passaria o “ClawbackHandler” para o método clawback e, no manipulador, chamaria o método apropriado, dependendo do tipo.

Eu acho que sua melhor opção é simplesmente nomear o método de forma diferente.

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

Na verdade, não é tão ruim, já que você não recebe nada extra com o mesmo nome.

Lembre-se de que a JVM não decidirá qual método chamar em tempo de execução. Ao contrário dos methods virtuais / methods, a resolução de sobrecarga dos methods sobrecarregados é feita em tempo de compilation. Os Tutoriais de Java sobre sobrecarga de método apontam que “Métodos sobrecarregados devem ser usados ​​com moderação …” .