在java中如何在多个类中使用一个接口？

我有一个活动和两个片段

我想在活动中使用fire

listener.receivePreview（obj）

然后

执行：OneFragment->receivePreview

执行：TwoFragment->receivePreview

---

尝试在每个返回接口实例的片段中创建一个函数

public OnReceiveListener getListener() {
    mListener = this;
    return mListener
}

并在您的活动中调用该方法时编写以下代码

fragmentInstance.getListener().receivePreview();

---

我认为您可以使用观察者模式，这在您的情况下是一个很好的实践

如GoF所述：

“定义对象之间的一对多依赖关系，以便当一个对象更改状态时，自动通知并更新其所有依赖项”

阅读更多

在您的情况下，您有这样的关系（一对多），当活动中发生事件时，您希望知道这两个片段

片段是实现观察者类，您的活动具有主题角色，如上图所示

我希望这可以帮助您以一种非常好的方式实现代码。 可以在以下链接中找到一些教程：

编辑：在给定情况下：

public interface OnReceiveListener { // this is your observer interface  !
        // This can be any number of events to be sent to the activity
        void receivePreview(Object... obj);
    }

片段与此设计模式的定义正确，因此我不会更改其代码：

public class OneFragment extends Fragment implements OnReceiveListener{

@Override
public void receivePreview(Object... obj) {

}
}

public class TwoFragment extends Fragment implements OnReceiveListener{

@Override
public void receivePreview(Object... obj) {

}

您需要在活动中引用片段（作为观察者）

我用答案。看来这个解决方案很有用

    public class MainAct extends AppCompatActivity {

         static List<OnReceiveListener> onReceiveList = new ArrayList<OnReceiveListener>();

        public void attachOnReceiveListener(OnReceiveListener listener) {
            if (!onReceiveList.contains(listener)) {
                onReceiveList.add(listener);
            }
        }

        public interface OnReceiveListener {
            // This can be any number of events to be sent to the activity
            void receivePreview(Object... obj);
        }

        public onReceivePreview(Object... obj) {
                 for (OnReceiveListener listener : onReceiveList) {
                    listener.receivePreview(obj);
                }
        }
     }

    public class OneFragment extends Fragment implements OnReceiveListener{


        @Override
        public void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            MainAct  mainAct = new MainAct();
            mainAct.attachOnReceiveListener(this);

        }

        @Override
        public void receivePreview(Object... obj) {

        }
    }

    public class TwoFragment extends Fragment implements OnReceiveListener{

        @Override
        public void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            MainAct  mainAct = new MainAct();
            mainAct.attachOnReceiveListener(this);

        }
        @Override
        public void receivePreview(Object... obj) {

        }
    }

public类MainAct扩展了appcompative活动{
静态列表onReceiveList=new ArrayList（）；
public void attachOnReceiveListener（OnReceiveListener侦听器）{
如果（！onReceiveList.contains（侦听器））{
onReceiveList.add（侦听器）；
}
}
公共接口OnReceiveListener{
//这可以是要发送到活动的任意数量的事件
作废接收预览（对象…对象）；
}
公共onReceivePreview（对象…对象）{
for（OnReceiveListener侦听器：onReceiveList）{
listener.receivePreview（obj）；
}
}
}
公共类OneFragment扩展了ReceiveListener上的片段实现{
@凌驾
创建时的公共void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
MainAct MainAct=新MainAct（）；
mainAct.attachOnReceiveListener（本）；
}
@凌驾
公共无效接收预览（对象…对象）{
}
}
公共类TwoFragment扩展了ReceiveListener上的片段实现{
@凌驾
创建时的公共void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
MainAct MainAct=新MainAct（）；
mainAct.attachOnReceiveListener（本）；
}
@凌驾
公共无效接收预览（对象…对象）{
}
}

您能否更清楚地解释一下，您到底想要实现什么目标？另外，如果你想要一个单一的接口，为什么要在两个片段中都实现它呢？试试greenrobots eventbus库我同意你的评估，给出一个在给定情况下如何使用它的示例可能会有所帮助。我同意你的看法，我认为设计模式是一个应该在适当情况下使用的概念。但首先我们需要了解什么是设计模式以及为什么要使用它们。在这种情况下，答案很清楚，但我将编辑我的答案以给出适当的示例。@ahmadaghazadeh Ghorbanat:））谢谢。请查看我的解决方案。

ArrayList< OnReceiveListener > observers =  new ArrayList< OnReceiveListener>();

public class MainAct extends AppCompatActivity {
private static MainAct instance;

public static MainAct getInstance() {
 if(instance != null)
    return instance;
}

// I think it is better to create the instance variable in the onCreate() method of the MainAct activity

onCreate(...)
{
.
.
.
instance = this;
...
}

public void registerObserver(OnReceiveListener observer){
observers.add(observer)
}
/* To avoid memory leaks, remember to unregister receivers when no longer observing */
public void unregisterObserver(OnReceiveListener observer) {
    observers.remove(observer);
}
notifyObservers(){
// call this method in the listener you want 

for( Observer obser : observers)
    obser. receivePreview(param )

}
...

//in fragment initialization: 
MainAct.getInstance().registerObserver(this)

    public class MainAct extends AppCompatActivity {

         static List<OnReceiveListener> onReceiveList = new ArrayList<OnReceiveListener>();

        public void attachOnReceiveListener(OnReceiveListener listener) {
            if (!onReceiveList.contains(listener)) {
                onReceiveList.add(listener);
            }
        }

        public interface OnReceiveListener {
            // This can be any number of events to be sent to the activity
            void receivePreview(Object... obj);
        }

        public onReceivePreview(Object... obj) {
                 for (OnReceiveListener listener : onReceiveList) {
                    listener.receivePreview(obj);
                }
        }
     }

    public class OneFragment extends Fragment implements OnReceiveListener{


        @Override
        public void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            MainAct  mainAct = new MainAct();
            mainAct.attachOnReceiveListener(this);

        }

        @Override
        public void receivePreview(Object... obj) {

        }
    }

    public class TwoFragment extends Fragment implements OnReceiveListener{

        @Override
        public void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            MainAct  mainAct = new MainAct();
            mainAct.attachOnReceiveListener(this);

        }
        @Override
        public void receivePreview(Object... obj) {

        }
    }