Question

public interface Foo {
}

public class SpecificFoo implements Foo {
}

public interface SomeInterface {
    void thisMethod(Foo someKindOfFoo);
}

public class SomeClass implements SomeInterface {

    public void thisMethod(Foo someKindOfFoo) {
        // calling code goes into this function
         System.out.println("Dont go here please");
    }

    public void thisMethod(SpecificFoo specificFoo) {
        // not into this function
         System.out.println("Go here please");
    }
}

public class SomeOlderClass {

    public SomeOlderClass( SomeInterface inInterface ) {
        SpecificFoo myFoo = new SpecificFoo();

        inInterface.thisMethod(myFoo);
    }
}

电话:

SomeClass myClass = new SomeClass();
SomeOlderClass olderClass = new SomeOlderClass(myClass);

我有一个接口(Some Interface),几个班次上调(例如SomeOlderClass)。我有一个班子来实施接口,但我想在具体实施方面开展安全行动,这些具体实施活动已进入通用接口。

如上述法典所示,我真的希望能够采用另一种方法,与接口中的具体类型相匹配。这并不奏效。我的假设是,打电话的代码只了解接口,而不是使用更具体的方法(即使通过<代码>)实施。具体Foo 执行 Foo

因此,我如何能够以最明智的方式做到这一点? 我可以通过在接口实施类别中添加一个词句(<条码>SomeClass):

public void thisMethod(Foo someKindOfFoo) {
    // calling code goes into this function
    if ( someKindOfFoo.getClass().equals(SpecificFoo.class) )
        thisMethod(SpecificFoo.class.cast(someKindOfFoo));
    else
        System.out.println("Dont go here please");
}

然而,这并不奇怪,因为我必须补充的是,如果我每次发言都加上一种新的oo。我可能忘记这样做。

另一种选择是,在<代码>SomeInterface上添加<>SpecificFoo,让汇编者提醒我,我需要在<编码>SomeClass上执行。问题在于,我最后增加了相当一部分锅炉板。 (如果其他人实施接口,他们必须采用新方法和任何测试)

鉴于<代码>,我似乎还有另一个选择。 Foo和SpecificFoo相互关联。想法?

MORE INFO:

我确实在努力尝试和简化这一问题。由于我补充了更多的细节,复杂性大为增加。但不管怎样, 我认为我可以解释。

基本上,我用Ry 瑞在其上解释的指挥模式书写了《世界展望》网站。

它在《古角度法典》方面有多项执行,但很多人却遭受这一继承问题。我认为,这是在《全球WT-RPC法典》上的一个节奏:。 HOWEVER,因为我正在进一步实施,我注意到一个类似的问题,即纯出现在客户一方,同时以东道方式出现。 (即所有支离破碎,无 g。)

因此,我把基本想法推向一个 raw瓦指挥线的原案,并看到了上文所述的同一问题。

如果你随同Ry 瑞讨论的话,Foo是一种行动,SpecificFoo是我想呼吁的一项具体行动。 <代码>SomeInterface为客户的RPC服务,SomeClass为RPC服务机边。 <代码>SomeOlderClass是一套能够了解海滩和什么东西的碎石服务。

显然,权利? 正如我说过的那样,我认为,所有南太平洋区域渔业管理组织的不光是把水推上基问题的水上,这就是为什么我尽量简化水面。

Answer 1

如果你需要找到操作时间的物体的实际类型,那么设计很可能是错误的。这至少违反了 Open 封闭原则和依附性转移原则。

http://en.wikipedia.org/wiki/Multiple_dispad”rel=“nofollow noreferer”>multiplesign , The thisMethod(Foo) will be打上,而不是thisMethod(SpecificFoo)。。两用产品可以用来克服语言限制,但可能仍然存在某种设计问题......

请提供更多资料,说明你试图取得的成就。现在,这个问题没有提供足够的信息来提出正确的设计。

一种通用的解决办法是,由于行动取决于<代码>的操作时间类型。 Foo,该方法应为的一部分。 Foo,使其执行可以因<代码>而有所不同。 Foo s类型。因此,你的例子将改成下文(可能添加<条码>/条码>或<条码>的其他参数。

public interface Foo {
    void thisMethod();
}

public class SpecificFoo implements Foo {
        public void thisMethod() {
                 System.out.println("Go here please");
        }
}

Answer 2

采用双重派遣方式: 在<代码>上添加一种方法 Foo界面, 一些Class#thisMethod。然后,该法典将适用这种方法。

public interface Foo {
  public void thatMethod(SomeClass a);
  public void thatMethod(SomeOlderClass a);
}

public class SomeClass implements SomeInterface {
    public void thisMethod(Foo someKindOfFoo) {
        someKindOfFoo.thatMethod(this);
    }
}

Answer 3

令我感到,问题描述过于抽象,无法提出建议。你显然有一个设计问题,因为你一般不需要检查接口的类型。我会给我一个回想。首先,我需要使你的问题更加具体,让我的小大脑了解。而不是Foos,如何对待鸟类?

public interface Bird {
}

public class Ostrich implements Bird {
}

public interface BirdManager {
    void fly(Bird bird);
}

public class AdvancedBirdManager implements BirdManager {

    public void fly(Bird bird) {
        System.out.println("I am in the air. Yay!");
    }

    public void fly(Ostrich ostrich) {
        System.out.println("Sigh... I can t fly.");
    }
}

public class ZooSimulation {
    public ZooSimulation(BirdManager birdManager) {
        Ostrich ostrich = new Ostrich();
        birdManager.fly(ostrich);
    }
}

public static void main(String[] args) {
    AdvancedBirdManager advancedBirdManager = new AdvancedBirdManager();
    ZooSimulation zooSimulation = new ZooSimulation(advancedBirdManager);
}

这里,Ostrich将宣布“我是空的。 Yay"不是我们想要的。

因此,在忽视我在此没有基本业务目标的情况下,问题是,鸟类动物群将寻找一种与所采用的类型相匹配的最小的方法。因此,不管我给什么鸟类,它总是与<条码>fly(Bird)相匹配。我们可以采用一些<条码>。在那里进行检查,但随着你增加更多种类的鸟类,你的设计将进一步降解。这里是艰难的一部分——如果在你的问题范围内这样做的话,我就没有想法,但我认为,如果我把逻辑从管理人员转向鸟类,这种令人振奋:

public interface Bird {
    void fly();
}

public class BasicBird implements Bird {
    public void fly() {
        System.out.println("I am in the air. Yay!");
    }
}

public class Ostrich implements Bird {
    public void fly() {
        System.out.println("Sigh... I can t fly.");
    }
}

public interface BirdManager {
    void fly(Bird bird);
}

public class AdvancedBirdManager implements BirdManager {

    public void fly(Bird bird) {
        bird.fly();
    }
}

public class ZooSimulation {
    public ZooSimulation(BirdManager birdManager) {
        Ostrich ostrich = new Ostrich();
        birdManager.fly(ostrich);
    }
}

public static void main(String[] args) {
    AdvancedBirdManager advancedBirdManager = new AdvancedBirdManager();
    ZooSimulation zooSimulation = new ZooSimulation(advancedBirdManager);
}

我们的奥斯特里科现在说,正确的东西,鸟类管理人员仍然把它当作鸟类。同样,不完善的联络处(Ostriches不应有fly()方法),而是说明我的想法。

Answer 4

只要实施<代码>的次数不多 Foo,我将在<代码>上宣布每一次<代码>的抽象方法。 Foo,并且有一个抽象的顺序,要求采用一种为最普通类型界定的缺省方法:

public interface Foo {
}

public class SpecificFoo implements Foo {
}

public interface SomeInterface {
        void thisMethod(Foo someKindOfFoo);
        void thisMethod(SpecificFoo specificFoo);
        void thisMethod(OtherSpecificFoo otherSpecificFoo);
}

public abstract class AbstractSomeInterface {
        public void thisMethod(Foo wrongFoo) {
            throw new IllegalArgumentException("Wrong kind of Foo!");
        }

        public void thisMethod(SpecificFoo specificFoo) {
            this.thisMethod((Foo) specificFoo);
        }

        public void thisMethod(OtherSpecificFoo otherSpecificFoo) {
            this.thisMethod((Foo) specificFoo);
        }
}

public class SomeClass extends AbstractSomeInterface {
        public void thisMethod(SpecificFoo specificFoo) {
                 // calling code goes into this function
                 System.out.println("Go here please");
        }
}

public class SomeOlderClass {

        public SomeOlderClass( SomeInterface inInterface ) {
                SpecificFoo myFoo = new SpecificFoo();

                inInterface.thisMethod(myFoo);
        }
}

友情链接