这是一种反模式还是违反了一些设计原则？

Question

我自己尝试设计模式和原则并提出了一个问题。之前，对于不良的编码风格习惯感到抱歉!!

在这种情况下，我有一个类似 ITest 的界面：

public interface ITest
{
    public void method1();
}

然后将方法和字段（如果有）实现到具体的 class B 中，如下所示：

public class B implements ITest
{
    //This is the method from the interface
    @Override
    public void method1()
    {
        System.out.println("method1");
    }

    //This is another method in class B
    public void method2()
    {
        System.out.println("method2");
    }
}

现在在应用程序代码中我这样写：

public class Main 
{
    public static void main(final String args[]) throws Exception 
    {
        //One principle says:
        //programm to an interface instead to an implementation
        ITest test = new B();

        //method from interface
        test.method1();
        //this method is not accessible because not part of ITest
        test.method2();     //compile-time error
    }
}

您看到 class B 中的 method2() 不可用，因为对于 ITest 的接口。现在，如果我需要这个 'important' 方法怎么办？有几种可能性。我可以在接口中抽象它或使 class B 抽象并扩展到另一个 class 等等，或者在 main() 方法中进行引用，如：

B test = new B();

但这就违背了原则。所以，我将界面修改为：

public interface ITest
{
    //A method to return the class-type B
    public B hook();
    public void method1();
}

并放入class B 实现：

public class B implements ITest
{
    //this returns the object reference of itself
    @Override
    public B hook()
    {
        return this;
    }

    //This is the method from the interface
    @Override
    public void method1()
    {
        System.out.println("method1");
    }

    //This is the 'important' method in class B
    public void method2()
    {
        System.out.println("method2");
    }
}

现在在我的 main() 方法中，我可以用一个小钩子或链接机制调用这两个方法，而无需引用新对象，也不会违反设计原则，我不需要额外的 class 用于扩展或抽象。

public class Main
{
    public static void main(final String args[])
    {
        //programm to an interface instead into an implemintation
        ITest test = new B();
        //method from interface
        test.method1();
        //method2 will not be accessible from ITest so we referencing B through a method hook()
        //benefits: we don't need to create extra objects nor additional classes but only referencing
        test.hook().method2();
        System.out.println("Are they both equal: "+test.equals(test.hook()));
    }
}

另外，我还可以对其他方法、字段等进行封装、继承、抽象。这意味着，我可以创建更复杂和灵活的层次结构。

我现在的问题：这是一种反模式、糟糕的设计原则还是我们可以从中受益？

感谢观看。 :-)

Answer 1

向 B 实现的接口 ITest 添加方法 returning B 绝对是一个糟糕的设计选择，因为它会强制其他类实现ITest return B，例如

public class C implements ITest {
    @Override
    public B hook()
    {
        return // What do I return here? C is not a B
    }
    ...
}

你的第一选择更好：

B test1 = new B();
C test2 = new C();

Answer 2

Is this a kind of anti-pattern, bad design-principle or could we benefit from this?

是的，这是一个糟糕的模式。

问题源于您将 ITest 与 B 紧密耦合。假设我想创建 ITest 的新实现 - 让我们称之为 C.

public class C implements ITest
{
    @Override
    public B hook()
    {
        // How do I implement this?
    }

    @Override
    public void method1()
    {
        System.out.println("method1");
    }
}

我们没有实现此方法的明智方法。唯一合理的做法是returnnull。这样做会迫使我们界面的任何用户不断执行防御性空检查。

如果他们每次都必须在使用该方法的结果之前进行检查，他们还不如做一个 instanceof 并转换为 B。那么你要增加什么价值？你只是让界面变得不那么连贯，更加混乱。

这是一种反模式还是违反了一些设计原则？

Is this an anti-pattern or violates it some design-principles?

java

design-patterns

coding-style

anti-patterns

design-principles