Java通用重载擦除（而不是覆盖） [英] Java erasure with generic overloading (not overriding)

问题描述

我在我的网域中有FinanceRequests和CommisionTransactions。
如果我有一个FinanceRequest列表，每个FinanceRequest可以包含多个需要回收的CommisionTransaction。

下面这个类（非常底）让我感到所有的模糊和温暖，因为它很好地恢复和重用了现有的代码。

  public void clawBack（Collection< FinanceRequest> financeRequestList）
 public void clawBack（Collection< CommissionTrns> ; commissionTrnsList）
  

删除后它们都具有相同的签名，即：

 集合< FinanceRequest> - >收集和LT;对象> 
收集< CommissionTrns> - >收集和LT;对象> 
  

所以eclipse抱怨：

方法clawBack（Collection）具有相同的擦除clawBack（Collection）作为CommissionFacade类型中的另一种方法

任何有关重构此方法的建议，以便它仍然是一个优雅的解决方案，可以重用代码？

---

  public class CommissionFacade 
 {
 / ******** FINANCE请求**************** / 
 public void clawBack（FinanceRequest financeRequest）
 {
 Collection< CommissionTrns> commTrnsList = financeRequest.getCommissionTrnsList（）; 
 this.clawBack（commTrnsList）; 
 
 $ b $ public void clawBack（Collection< FinanceRequest> financeRequestList）
 {
 for（FinanceRequest finReq：financeRequestList）
 {
 this。回拨（finReq）; 
} 
} 
 
 / ********委员会交易**************** / 
 public void clawBack（CommissionTrns commissionTrns）
 {
 //为单个CommissionTrns返回
} 
 
 public void clawBack（Collection< CommissionTrns> commissionTrnsList）
 （CommissionTrns commTrn：commissionTrnsList）
 {
 this.clawBack（commTrn）; 
 
 
 
 $ b  

解决方法

要么重命名方法，要么使用多态：使用接口，然后将回拨代码放入对象本身，或者使用双分派（取决于您的设计范例和品味）。 p>

使用对象中的代码将会是：

  public interface Clawbackable {
 void clawBack（）
} 
 
 
 public class CommissionFacade 
 {
 
 public< T extends Clawbackable>无效clawBack（Collection< T>对象）
 {
 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 
} 
 
} 
  

我更喜欢这种方法，因为我相信你的域名应该包含你的逻辑;但我没有完全意识到你的确切愿望，所以我会留给你。

通过双重调度，您可以将ClawbackHandler传递给clawback方法和处理程序根据类型调用适当的方法。

I have FinanceRequests and CommisionTransactions in my domain. If I have a list of FinanceRequests each FinanceRequest could contain multiple CommisionTransactions that need to be clawed back. Dont worry how exactly that is done.

The class below (very bottom) makes me feel all fuzzy and warm since its succint and reuses existing code nicely. One problem Type erasure.

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

They both have the same signature after erasure, ie:

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

So eclipse complainst that:
Method clawBack(Collection) has the same erasure clawBack(Collection) as another method in type CommissionFacade

Any suggestions to restructure this so that it still an elegant solution that makes good code reuse?

---

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

}

解决方案

Either rename the methods, or use polymorphism: use an interface, and then either put the clawback code in the objects themselves, or use double-dispatch (depending on your design paradigm and taste).

With code in objects that would be:

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
    }

}

I prefer this approach, since I'm of the belief your domain should contain your logic; but I'm not fully aware of your exact wishes, so I'll leave it up to you.

With a double dispatch, you would pass the "ClawbackHandler" to the clawback method, and on the handler call the appropriate method depending on the type.

这篇关于Java通用重载擦除（而不是覆盖）的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！