我首先要回答你提出的问题: 你们的阶级是谁的责任? 请允许我谈谈单一责任原则: 班级只能有改变的理由。 因此,我认为,如果你回答这个问题,你将能够决定如何设计你的申请。 在这种情况下,我既不使用第一种办法,也不使用第二种办法。 我认为,界定新的责任,将其归入单独类别或可能具有职能,是更好的。

我试图总结我同意的这里已经提出的一些问题。

我个人并不认为有一个“更好”的答案。 有效原因do存在于上,原因是你不放弃用固定方法填充的公用事业类别。

简短的回答是,在一个以目标为导向的世界里,你应当使用物体和与物体(资本、多变)相关的所有“货物”。

Polymorphism

如果计算基因距离的方法varies,请roughly。 (很可能是Strategy) 每个变式都有一个通用类别。 概述不同之处。 你们最后会有多个方面。

Open For Extension, Closed for Modification

这意味着,如果计算基因之间距离的新方法落下,请shouldn t 修改现有代码,但 添加新的。 你们冒着打破那里已经存在的东西的风险。

在这种情况下,你应当增加一个新的基因组,而不是修改在#geneDistance上写的代码。

Tell Don t Ask

你们应该告诉你们要做些什么,不要问他们自己的国家,并为他们作出决定。 http://en.wikipedia.org/wiki/Single_responsibility_principle” rel=“nofollow noretinger”>,single responsibility principle since that s poly吗?

Testability

静态方法可能很容易孤立地加以测试,但是,你将在其他班子使用这一固定方法。 在孤立地测试这些班级时,你将很难做。 或者不是。

页: 1 他的话比我能够说的话要好。

import junit.framework.Assert;

import org.junit.Test;

public class GeneTest
{
    public static abstract class Gene
    {
        public abstract int geneDistance(Gene other);
    }

    public static class GeneUtils
    {
        public static int geneDistance(Gene g0, Gene g1)
        {
            if( g0.equals(polymorphicGene) )
                return g0.geneDistance(g1);
            else if( g0.equals(oneDistanceGene) )
                return 1;
            else if( g0.equals(dummyGene) )
                return -1;
            else
                return 0;            
        }
    }


    private static Gene polymorphicGene = new Gene()
                                    {

                                        @Override
                                        public int geneDistance(Gene other) {
                                        return other.geneDistance(other);
                                        }
                                    };

    private static Gene zeroDistanceGene = new Gene() 
                                    {                                        
                                        @Override
                                        public int geneDistance(Gene other) {
                                        return 0;
                                        }
                                    };

    private static Gene oneDistanceGene = new Gene() 
                                    {                                        
                                        @Override
                                        public int geneDistance(Gene other) {
                                        return 1;
                                        }
                                    };

    private static Gene hardToTestOnIsolationGene = new Gene()
                                    {

                                        @Override
                                        public int geneDistance(Gene other) {
                                        return GeneUtils.geneDistance(this, other);
                                        }
                                    };

    private static Gene dummyGene = new Gene()
                                    {

                                        @Override
                                        public int geneDistance(Gene other) {
                                        return -1;
                                        }
                                    };                                    
    @Test
    public void testPolymorphism()
    {
        Assert.assertEquals(0, polymorphicGene.geneDistance(zeroDistanceGene));
        Assert.assertEquals(1, polymorphicGene.geneDistance(oneDistanceGene));
        Assert.assertEquals(-1, polymorphicGene.geneDistance(dummyGene));
    }

    @Test
    public void testTestability()
    {

        Assert.assertEquals(0, hardToTestOnIsolationGene.geneDistance(dummyGene));
        Assert.assertEquals(-1, polymorphicGene.geneDistance(dummyGene));
    }    

    @Test
    public void testOpenForExtensionClosedForModification()
    {

        Assert.assertEquals(0, GeneUtils.geneDistance(polymorphicGene, zeroDistanceGene));
        Assert.assertEquals(1, GeneUtils.geneDistance(oneDistanceGene, null));
        Assert.assertEquals(-1, GeneUtils.geneDistance(dummyGene, null));
    }    
}

这里有一只大塔和一个独木舟:调查Java SDK图书馆课堂的楼梯,看看你是否能够将不同班级固定方法的共体分类。

在这种情况下,我将把它当作一种隐蔽的方法。 如果你在0克无效时有合乎逻辑的答案,那么就必须使用BOTH(这种情况比你认为更经常发生)。

例如,aString.startsWith(, 如果法规无效,你可以认为,将合同归还无效(如果你认为职能可以是NUL-TOLERATE)。 这使我能够简化我的方案,因为没有必要在客户法典中进行点击。

final Stirng         aPrefix = "-";
final Vector aStrings = new Vector();
for(final String aString : aStrings) {
    if (MyString.startsWith(aString, aPrefix))
        aStrings.aStringadd();
}

而不是

final Stirng         aPrefix = "-";
final Vector aStrings = new Vector();
for(final String aString : aStrings) {
    if ((aString != null) && aString.startsWith(aPrefix))
        aStrings.aStringadd();
}

注:这是一个过于简化的例子。

只是一个想法。

我将采用这一榜样方法。 但这可能是因为我没有基因组别;)

实例方法可以被大大降低贵国法典复杂程度的子类所取代(无须作陈述)。 在静态方法中,会发生什么情况? 另一种静态方法? 如果你必须处理多变基因清单,那么你必须研究哪类基因来选择正确的距离方法......从而增加政变和复杂性。

我选择第二种办法。 在使这种方法静态化方面没有好处。 由于该方法属于基因组,因此静态只能增加一个没有额外收益的额外参数。 如果你需要一个实用的班子,那就是一种不同的交易。 但我认为,如果你能够把方法添加到有关类别,通常不需要使用类别。

我认为,问题领域应当超越一般性的大纲和(或)业务协调处的考虑。

例如,我猜测,就遗传分析而言,基因和距离的概念相当具体,不需要通过继承来专门处理。 如果情况并非如此,那么,人们可以提出选择例如方法的有力理由。

选择案件方法的主要原因是多变。 固定方法不能被子类所压倒,这意味着你可以根据具体情况具体实施。 这可能不适用于你,但值得一提。

如果基因距离完全独立于基因类型,我宁愿使用单独的通用类别,使这种独立性更加明确。 附有<条码>遗传学<>。 作为<代码>一部分的方法 通用类别意味着距离是一种与基因有关的行为。