Java的Comparable接口的一个陷阱-java comparable接口

Java的Comparable接口提供一个对实现了这个接口的对象列表进行排序的办法。原始的排序对于简单的对象来说具有意义，但是当我们面对复杂的面向对象的业务逻辑对象时，事情变得复杂的多。从业务经理的角度来看，一些交易对象的自然顺序可能是按照交易的价值来排序的，但是从系统管理员的角度来看，这个排序的规则可能是交易的速度。所以在大多数情况下，并没有明确的业务领域对象的自然排序规则。

假设我们找到了一个需要排序的类，比如说Campany。我们把公司的offical name作为主关键字，把id作为次要关键字。这个类的实现如下：

public class Company implements Comparable<Company> {  
   
    private final String id;  
    private final String officialName;  
   
    public Company(final String id, final String officialName) {  
        this.id = id;  
        this.officialName = officialName;  
    }  
   
    public String getId() {  
        return id;  
    }  
   
    public String getOfficialName() {  
        return officialName;  
    }  
   
    @Override 
    public int hashCode() {  
        HashCodeBuilder builder = new HashCodeBuilder(17, 29);  
        builder.append(this.getId());  
        builder.append(this.getOfficialName());  
        return builder.toHashCode();  
    }  
   
    @Override 
    public boolean equals(final Object obj) {  
        if (obj == this) {  
            return true;  
        }  
        if (!(obj instanceof Company)) {  
            return false;  
        }  
        Company other = (Company) obj;  
        EqualsBuilder builder = new EqualsBuilder();  
        builder.append(this.getId(), other.getId());  
        builder.append(this.getOfficialName(), other.getOfficialName());  
        return builder.isEquals();  
    }  
   
    @Override 
    public int compareTo(final Company obj) {  
        CompareToBuilder builder = new CompareToBuilder();  
        builder.append(this.getOfficialName(), obj.getOfficialName());  
        builder.append(this.getId(), obj.getId());  
        return builder.toComparison();  
    }  
}

这个实现看起来没问题，假设现在这个类提供的信息不够使用，我们又创建了这个类的一个子类CompanyDetail类用以扩展他。例如我们想以一个表的形式显示公司的信息，我们就可以用这个类。

public class CompanyDetails extends Company {  
   
    private final String marketingName;  
    private final Double marketValue;  
   
    public CompanyDetails(final String id, final String officialName, final String marketingName, final Double marketValue) {  
        super(id, officialName);  
        this.marketingName = marketingName;  
        this.marketValue = marketValue;  
    }  
   
    public String getMarketingName() {  
        return marketingName;  
    }  
   
    public Double getMarketValue() {  
        return marketValue;  
    }  
   
    @Override 
    public int hashCode() {  
        HashCodeBuilder builder = new HashCodeBuilder(19, 31);  
        builder.appendSuper(super.hashCode());  
        builder.append(this.getMarketingName());  
        return builder.toHashCode();  
    }  
   
    @Override 
    public boolean equals(final Object obj) {  
        if (obj == this) {  
            return true;  
        }  
        if (!(obj instanceof CompanyDetails)) {  
            return false;  
        }  
        CompanyDetails other = (CompanyDetails) obj;  
        EqualsBuilder builder = new EqualsBuilder();  
        builder.appendSuper(super.equals(obj));  
        builder.append(this.getMarketingName(), other.getMarketingName());  
        builder.append(this.getMarketValue(), other.getMarketValue());  
        return builder.isEquals();  
    }  
}

这个类的实现看起来还是没什么问题，但是事实上是有问题的，我们可以写一个test指出问题在哪里。当我们没有对父类的所有细节加以注意时，问题就来了。

CompanyDetails c1 = new CompanyDetails("231412", "McDonalds Ltd", "McDonalds food factory", 120000.00);  
CompanyDetails c2 = new CompanyDetails("231412", "McDonalds Ltd", "McDonalds restaurants", 60000.00);  
   
Set<CompanyDetails> set1 = CompaniesFactory.createCompanies1();  
set1.add(c1);  
set1.add(c2);  
   
Set<CompanyDetails> set2 = CompaniesFactory.createCompanies2();  
set2.add(c1);  
set2.add(c2);  
   
Assert.assertEquals(set1.size(), set2.size());

我们构造了两个set，但是结果是assert的结果是不相等。这是为什么？其中一个set是一个HashSet，他依赖对象的hashCode()和equals()方法，但是另一个是TreeSet，他只是依赖Comparable接口，而这个接口在子类中我们并没有实现。在领域对象被扩展的时候这是很常见的一个错误，但是更重要的是这是不好的编码约定造成的。我们使用Apache Commons包中的builder来实现hashCode(),equals().和compareTo()方法。这些builder提供了appendSuper()方法，此方法指示了如何调用这些方法在父类中的实现。如果你看过Joshua Bloch 的Effective Java，你会发现这是错误的。如果我们在子类中添加成员变量，在不违反对称规则的情况下，我们就不能正确的实现equals()方法和compareTo()方法。我们应该使用组合的方式而不是继承。如果我们使用组合的方式构造CompanyDetails，对于Comparable接口来说没有任何问题，因为我们没有自动的实现，而且在默认的情况允许不同的行为。而且我们也能满足正确的equals()和hashCode()的需求。

这篇文章提到的问题非常普遍，但是经常被忽视。Comparable接口的问题实际是由于不好的约定和对使用的接口需求的错误理解造成的。作为一个Java开发人员或架构师，你应该特别注意这样的事情，并遵守良好的编码习惯和做法。越大的项目，这种问题就越显得重要。这里我总结了一个使用Comparable接口的最佳实践，可以避免这个错误。

Java的Comparable接口的设计和使用的最佳实践：

了解你需要创建的领域对象，如果对象没有明确的排序规则，请不要实现Comparable接口。
更多的使用Comparator而不是Comparable，Comparator在更多的业务使用方式时要显得更为实用。
如果你需要创建依赖Comparable接口的接口或者库，如果可能的话你提供自己的Comparator实现，否则就写一个良好的文档指明在你的接口实现类中如何实现。
遵守良好的编码习惯和做法。Effective Java是很好的推荐。

原文链接：http://my.oschina.net/jack230230/blog/56339

【编辑推荐】