Oop 面向对象设计问题

假设有两个类：

A

和

B

A

可以在

B

上操作

我需要能够查询

A

已操作的所有

B

实例

对于一个特定的

B

实例，我需要能够查询对其进行操作的所有

a

实例

这类问题的优雅解决方案是什么（在OO品味中？

import java.util.*；
import java.util.*;
class A {
    void operate(B b) {
        operatedOn.add(b);
        b.operatedOnBy.add(this);
    }
    final Set<B> operatedOn = new HashSet<B>();
}
class B {
    final Set<A> operatedOnBy = new HashSet<A>();
}
public class Main {
    public static void main(String[] args) {
        A a=new A();
        B b=new B();
        a.operate(b);
        System.out.println(a+" "+a.operatedOn);
        System.out.println(b+" "+b.operatedOnBy);
    }
}

甲级{
无效操作（B）{
新增（b）项；
b、 通过添加（此项）进行操作；
}
final Set operatedOn=new HashSet（）；
}
B类{
final Set operatedOnBy=new HashSet（）；
}
公共班机{
公共静态void main（字符串[]args）{
A=新的A（）；
B=新的B（）；
a、 操作（b）；
系统输出打印项次（a+“”+a.operatedOn）；
系统输出打印项次（b+“”+b.operatedOnBy）；
}
}

导入java.util.*；
甲级{
无效操作（B）{
新增（b）项；
b、 通过添加（此项）进行操作；
}
final Set operatedOn=new HashSet（）；
}
B类{
final Set operatedOnBy=new HashSet（）；
}
公共班机{
公共静态void main（字符串[]args）{
A=新的A（）；
B=新的B（）；
a、 操作（b）；
系统输出打印项次（a+“”+a.operatedOn）；
系统输出打印项次（b+“”+b.operatedOnBy）；
}
}

在像Java这样的语言中，我会做如下操作：

package com.whatever.blah;

public class A {
    private Set<B> patients = new HashSet<B>;

    public void operateOn(B patient) {
        patient.startRecoveringFromOperation(this);
        patients.add(patient);
    }

    public List<B> getPatients() {
        return patients;
    }
}

public class B {
    private Set<A> surgeons = new HashSet<A>;

    //this has package access to `A` can access it but other classes can't
    void startRecoveringFromOperation(A theSurgeon) {
        surgeons.add(theSurgeon);
    }

    public List<A> getSurgeons() {
        return surgeons;
    }
}

package com.whatever.blah；
公共A类{
私有集患者=新哈希集；
公开无效手术（B患者）{
患者。开始从手术中恢复（本次）；
患者。添加（患者）；
}
公众病人名单（）{
返回病人；
}
}
公共B级{
私有设置允许
A
访问
B
的
开始覆盖fromOperation（）在其他语言中隐藏方法的时候，使用其他方法可以实现这一点。例如，在C++中，您可以声明<代码> < <代码> > <代码> > < <代码> > > < /p> 在像java这样的语言中，我会做如下的事情：

package com.whatever.blah;

public class A {
    private Set<B> patients = new HashSet<B>;

    public void operateOn(B patient) {
        patient.startRecoveringFromOperation(this);
        patients.add(patient);
    }

    public List<B> getPatients() {
        return patients;
    }
}

public class B {
    private Set<A> surgeons = new HashSet<A>;

    //this has package access to `A` can access it but other classes can't
    void startRecoveringFromOperation(A theSurgeon) {
        surgeons.add(theSurgeon);
    }

    public List<A> getSurgeons() {
        return surgeons;
    }
}

package com.whatever.blah；
公共A类{
私有集患者=新哈希集；
公开无效手术（B患者）{
患者。开始从手术中恢复（本次）；
患者。添加（患者）；
}
公众病人名单（）{
返回病人；
}
}
公共B级{
私有设置允许
A
访问
B
的
开始覆盖fromOperation（）在其他语言中隐藏方法时，可以使用不同的方法来完成这一点。例如，在C++中，你可以声明<代码> <代码> > <代码> > <代码> B>代码>。
这取决于你使用的语言，但理论上你可以创建某种列表，并且每个都可以创建一个列表。当一个事件被触发，其中A对B进行操作时，你会将其添加到该列表中。另一种情况也是如此。对我来说，这听起来像是观察者模式。如果你使用Java，也许你需要扩展一些类/接口。这取决于你使用的语言，但理论上你可以创建某种类型的列表，并且每次触发事件时，操作符B上的es添加到该列表中。其他情况也是如此。对我来说，听起来像是观察者模式。如果你使用Java，可能需要扩展一些类/接口。看起来你在复制数据……这是最优雅的设计吗？顺便说一句，我看不出哪里定义了
B
。@new_perl-那
B
是一个打字错误，应该是错误的n
患者
（现已修复）。我不能说这是否是最优雅的设计，因为这完全取决于你想用它完成什么。这只是问题的一个可能解决方案。它确实存储了一些冗余数据，以简化为给定的
B
查找每个
A
的逻辑。是的，这只允许你对
B
进行操作>通过查看
A
，因为我假设这是理想的使用模式。如果这不适合您的设计，您当然可以随意修改它。看起来您在复制数据……这是最优雅的设计吗？顺便说一句，我不知道
b
定义在哪里。@new_perl-那
b
是一个打字错误，应该是<代码>患者
（现已修复）。我不能说这是否是最优雅的设计，因为这完全取决于你想用它完成什么。这只是问题的一个可能解决方案。它确实存储了一些冗余数据，以简化为给定的
B
查找每个
A
的逻辑。是的，这只允许你对
B
进行操作>通过查看
A
，因为我假设这是所需的使用模式。如果这不适合您的设计，您当然可以根据需要修改它。