Borrado de Java con sobrecarga genérica (no anula)

Question

Tengo FinanceRequests and CommisionTransactions en mi dominio. Si tengo una lista de FinanceRequests, cada FinanceRequest podría contener múltiples CommisionTransactions que deben recuperarse. No te preocupes cómo exactamente se hace eso.

La clase de abajo (muy abajo) me hace sentir todo borroso y cálido desde su suceso y reutiliza el código existente muy bien. Un problema Tipo de borrado.

public void clawBack(Collection<FinanceRequest> financeRequestList) 
public void clawBack(Collection<CommissionTrns> commissionTrnsList) 

Los dos tienen la misma firma después de borrado, es decir:

Collection<FinanceRequest> --> Collection<Object> 
Collection<CommissionTrns> --> Collection<Object> 

Así eclipsar complainst que:
Clawback Método (Colección) tiene el mismo Clawback borrado (Colección) como otro método en el tipo de CommissionFacade

¿Alguna sugerencia para reestructurar esto para que siga siendo una solución elegante que hace una buena reutilización del código?

---

public class CommissionFacade 
{ 
    /********FINANCE REQUESTS****************/ 
    public void clawBack(FinanceRequest financeRequest) 
    { 
     Collection<CommissionTrns> commTrnsList = financeRequest.getCommissionTrnsList();   
     this.clawBack(commTrnsList); 
    } 

    public void clawBack(Collection<FinanceRequest> financeRequestList) 
    { 
     for(FinanceRequest finReq : financeRequestList) 
     { 
      this.clawBack(finReq); 
     }   
    } 

    /********COMMISSION TRANSACTIOS****************/ 
    public void clawBack(CommissionTrns commissionTrns) 
    { 
     //Do clawback for single CommissionTrns   
    } 

    public void clawBack(Collection<CommissionTrns> commissionTrnsList) 
    { 
     for(CommissionTrns commTrn : commissionTrnsList) 
     { 
      this.clawBack(commTrn); 
     } 
    } 

} 

Answer 1

Cambie el nombre de los métodos o utilice el polimorfismo: use una interfaz y luego coloque el código de recuperación en los objetos o use el envío doble (según el paradigma y el gusto de diseño).

Con código en objetos que serían:

public interface Clawbackable{ 
    void clawBack() 
} 


public class CommissionFacade 
{ 

    public <T extends Clawbackable> void clawBack(Collection<T> 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 
    } 

} 

prefiero este enfoque, ya que soy de la creencia de su dominio debe contener su lógica; pero no estoy al tanto de tus deseos exactos, así que te lo dejo a ti.

Con un envío doble, pasará el "ClawbackHandler" al método de recuperación, y en el controlador, llame al método apropiado según el tipo.

Answer 2

creo que su mejor opción es simplemente el nombre del método diferente.

public void clawBackFinReqs(Collection<FinanceRequest> financeRequestList) { 

} 

public void clawBackComTrans(Collection<CommissionTrns> commissionTrnsList) { 

} 

De hecho, no es tan malo, ya que no se consigue nada extra de que tienen el mismo nombre en ellos.

tener en cuenta, que la JVM no decidir qué método llamar en tiempo de ejecución. A diferencia de los métodos/métodos virtuales anulando, la resolución de los métodos sobrecargados se realiza en tiempo de compilación. Los Tutoriales de Java en method overloading incluso señalan que "Los métodos sobrecargados deben usarse con moderación ...".