Question

在Java中，在单例中调用方法的代码是更好的实践，为什么？

请注意，以下代码是psudocode，不一定是可编译的代码。我问这个，因为方法2（直接调用方法）在代码中更容易实现，但是从我的经验中看不到。

我正在为Android开发，但我想这个问题可能适用于任何Java程序。

B类中发生了一些事情。必须调用A类中的方法。

方法1：从ClassB中调用在ClassA中注册的接口

public class ClassA
{
    // Member class B object
    ClassB mClassBObject = new ClassB();

    // Singleton has a private constructor
    private ClassA(){}

    public void onCreate() // Or main, or whatever method...
    {
        // Set callback for ClassB
        mClassBObject.setOnSomethingHappened
        (
            new OnSomethingHappened()
            {
                public void callback()
                {
                    // Do something in Class A called in Class B
                }
            }
        );
    }

}

public class ClassB
{
    // Registered member callback
    OnSomethingHappened mCallback;

    // Interface for callback
    public interface OnSomethingHappened()
    {
        public void callback();
    }

    // Method to set callback for this object
    public void setOnSomethingHappened(OnSomethingHappened callback)
    {
        mCallback = callback;
    }     

    // A method that invokes the callback in Class A
    private void someMethod()
    {
        if (mCallback != null)
        {
            mCallback.callback();
        }        
    }

}

方法2：直接从ClassB中的ClassA调用方法

// We could also call a static method, but in this example, we are assuming a Singleton.
public class ClassA
{
    // Reference to self
    private static mSelf;

    // Singleton has a private constructor
    private ClassA(){}

    public void onCreate() // Or main, etc
    {
        mSelf = this; // Store a reference to this Singleton class
    }

    public void someMethod()
    {
        // Do something in ClassA
    }

    public static getSelf()
    {
        return mSelf;
    }
}

public class ClassB
{

    // Code...
    private void someMethodInClassB()
    {
        // Get ClassA to call
        ClassA classAObject = ClassA.getSelf();

        if (classAObject != null)
        {
            // Call method in ClassA
            classAObject.someMethod();
        }
    }


}

Answer 1

这实际上取决于您希望依赖关系链的方式。我将概括我认为你试图描述的模式。

我是第二个例子，B取决于A.正如你所提到的，这更简单，因为我们正在尝试设置的正是这种关系。

在第一个例子中，A依赖于B.从技术上讲，这可以写成A和B都依赖于C（回调机制）。这种设置很受欢迎，因为它减少了组件（A和B）之间的耦合，为将来的更改提供了更大的灵活性。

你所写的方式并没有在最佳实践中完全捕捉到这种耦合的减少＆＃34;虽然有点......你会找到很好的例子，其中B代表一个库或第三方组件，A代表你的代码。显然，库不能直接依赖于您的代码，因此使用了这种依赖性反转方式。

Java：最佳实践 - 回调vs成员类

1 个答案: