Java：最佳做法-回调与成员类

Question

在Java中，最好在单例中使用什么代码来调用方法，为什么？

请注意，以下代码是伪代码，不一定是可编译代码。 我问这个问题，因为方法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）之间的耦合，为将来的更改提供了更大的灵活性。

但是，您编写的方式并没有完全以“最佳实践”的方式捕获这种耦合的减少。...您会找到很好的示例，其中B代表库或第三方组件，而A是您的代码。 显然，该库不能直接依赖您的代码，因此使用了这种依赖关系反转样式。