Question

我有一个班级，它有一个方法：

public class A{
    public virtual void doChanges (String message, object[] args){
    }
}

有些课程使用＆＃39; doChange＆＃39; A＆＃39;中的方法：

public class MethodClaller{
    A a = new A();
    public void caller(){
        a.doChanges ("Test",null);
    }
}

所有子类应覆盖doChanges：

public class B:A{
    public override void doChanges(String message, object[] args){
    }
}

问题是：我想在多个程序（如组件）和每个程序中使用Class A 和Class MethodCaller ，方法 doChange 每当 doChange 调用 A 时，应自动呼叫所有 A 的孩子。所以像这样的代码：

new MethodCaller.call();

应在 B 的所有实例中调用 doChanges 。

这听起来像事件处理。但我不知道该怎么做。如果 A 且 B 与解决方案中的父级和子级不相关，则无关紧要。我只是觉得这是正确的结构。

Answer 1

您正在使用继承，其中模式是有序的。

而不是B继承自A（这只是两个类之间的静态依赖关系），您应该注册B的实例，以便A的实例可以委托。查找delegation pattern以理解这句话。

执行此操作是第一个概念性步骤，但稍后您可能（没有人可以肯定地说）最终会有更大的内容，即Composite Pattern。

要在复合材料中自动注册实例，您将使用创建Factory Pattern。

它会是这样的：

A将允许其实例为复合材料;
B将是可附加到A;

您将在B上设置工厂方法，以实例化B的元素，这需要A的实例：

A a; // get the instance "a" from somewhere
B.Create(a); // will create an instance of B and attach it to a

要强制使用此功能，您private将B的构造函数与通常一样（请参阅工厂模式）。

Create()将是这样的：

private B() // prevent direct instance creation
{
    // ...
}

public static void Create(A a)
{
    B b;

    b = new B();
    a.Register(b);
}

因此，您确定将所有B 附加到A（类似于您的要求所有B必须扩展A ）。< / p>

Register()中的A将是：

private List<B> _bs = new List<B>();

public void Register(B b)
{
    _bs.Add(b);
}

Do()中的A将是：

public void Do(object args)
{
    // pre-procedure of A

    foreach (B b in _bs)
    {
        b.Do(args);
    }

    // post-procedure of A
}

现在确保B实现Do()方法而不使用类之间的静态依赖关系，通过定义组件接口来利用复合模式：

interface AComponent
{
    void Do(object args);
}

从中获取B：

class B implements AComponent
{
    ...

最后从B：

中引用界面（而不是A）

private List<AComponent> _components = new List<AComponent>();

public void Register(AComponent component)
{
    _components.Add(component);
}

public void Do(object args)
{
    // pre-procedure of A

    foreach (AComponent component in _components)
    {
        component.Do(args);
    }

    // post-procedure of A
}

最后一步是使用复合接口在create方法中将B与A解耦：

interface AComposite
{
    void Register(AComponent component);
}

从中获取A：

class A implements AComposite
{
    ...

使用create方法中的界面：

public static void Create(AComposite composite)
{
    composite.Register(new B());
}

现在您A和B松散耦合，但B的实例必须在A的实例上注册，这样当Do()触发时，所有实例B也会触发Do()方法。

作为一种好处，您可以使AComponent的实现与B完全不同（根据继承），并且仍然可以使用Do()方法启动它们。您甚至可以混合AComponent的不同实现的实例，就像多态允许通过虚方法一样。

这对你有意义吗？

父方法调用时调用子方法

1 个答案: