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

我尝试使用设计模式和-原则,并有一个问题.
以前,对不好的编码风格习惯感到抱歉！

在这种情况下,我有一个类似ITest的接口：

public interface ITest
{
    public void method1();
}

然后将方法和字段(如果有的话)实现为具体的类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
    }
}

您会看到类B的method2()不可用,因为它与ITest的接口有关.
现在,如果我需要这种“重要”方法怎么办？
有几种可能性.我可以在接口中对其进行抽象,或者使类B抽象并扩展到另一个类,依此类推,或者在main()方法中进行引用,例如：

B test = new B();

但这将违反该原则.
因此,我将接口修改为：

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

并在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()方法中,我可以使用带有少许钩子或链接机制的两个方法,而无需引用新对象,也不会违反设计原理,并且不需要额外的类来进行扩展或抽象.

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

另外,我可以封装,继承和抽象其他方法,字段等.
这意味着,我可以创建更复杂,更灵活的层次结构.

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

谢谢收看:-)

解决方法:

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

我们没有实现此方法的理智方法.唯一合理的事情是返回null.这样做将迫使我们界面的所有用户不断执行防御性的空检查.

如果他们必须在使用方法的结果之前每次进行检查,那么他们也可以只执行一次instanceof并强制转换为B.那么,您要添加什么值？您只是在使界面不连贯,更容易混淆.

标签：design-principles,coding-style,anti-patterns,java,design-patterns
来源： https://codeday.me/bug/20191025/1926684.html