避免在使用层次结构参数的操作中进行静态绑定

我发现了一个关于静态绑定的问题。

我的真实课程非常扩展，所以我将使用几个玩具课程来表达我的问题。

我们假设我们有以下层次结构。

public class Element{}

public class Element1 extends Element{}

public class Element2 extends Element{}

我有一个Stock使用不同的类Element专业化定义为Element等级制度。

public class Stock{

    public void operation(Element1 e1){
        System.out.println("Operation - " + e1.getClass().getName());
    }

    public void operation(Element2 e2){
        System.out.println("Operation - " + e2.getClass().getName());
    }
}

最后，我有一个StockManager它允许管理Stock.

public StockManager{

    Stock stock;
    public StockManager(Stock stock){
        this.stock=stock;
    }

    public void manage(List<Element> elements){
        for(Element element: elements){
            stock.operation(element);
        }
    }
}

当然，这段代码无法编译，因为Stock没有定义一个方法，其中包括Element作为论证。在这种情况下，我们可以使用不同的方法修复代码。

首先，我将能够定义一个方法来定义Element作为输入 arg，例如

public void operation(Element e){
    System.out.println("Operation - " + e.getClass().getName());
}

该方法可以定义一个开关来管理不同的具体元素（Element1, Element2）。然而，这对我来说是不可能的，因为开关违反了开/关原理，而且我有很多（很多）具体元素。

另一种选择，我可以使用类似的东西访客模式。 我可以发送Stock对象为具体元素。具体元素将负责使用Stock运营。因此，该类可以更改为：

public abstract class Element{
    public abstract void stockOperation(Stock stock);
}

public class Element1 extends Element{
    public abstract void stockOperation(Stock stock){
        stock.operation(this);
    }
}

public class Element2 extends Element{
    public abstract void stockOperation(Stock stock){
        stock.operation(this);
    }
}

And the StockManager.

public StockManager{

    Stock stock;
    public StockManager(Stock stock){
        this.stock=stock;
    }

    public void manage(List<Element> elements){
        for(Element element: elements){
            element.stockOperation(stock);
        }
    }
}

它允许在编译时确定具体元素的静态类型。并且动态绑定将负责调用stockOperation正确的具体元素的方法（Element1 or Element2）。但是!!，我在具体元素中有重复的代码，并且我将有几个具体元素。

因此，我想知道我们是否知道解决此问题的任何模式设计或任何最佳实践。 （另一种选择，可能使用反射，但我不想使用它）。

问题在于您将各个库存操作放置在库存对象中。无论您是否使用开关，只要您有另一种元素类型，您就需要通过添加新的重载来修改库存operation到它。正如您所说，您的 Stock 类应该禁止修改。

因此，您必须将所有库存操作归咎于 Element 对象本身。这基本上是您的第二个建议，但是您在每个不同的元素中进行实现。

public abstract class Element{
    public abstract void stockOperation(Stock stock);
}

public class Element1 extends Element{
    @Override
    public void stockOperation(Stock stock){
        System.out.println("Operation - Element1");
    }
}

public class Element2 extends Element{
    @Override
    public void stockOperation(Stock stock){
        System.out.println("Operation - Element2");
    }
}

您可能需要与库存对象进行通信才能进行实际操作。用传递给每个人的股票来做到这一点stockOperation，使方法可用，允许元素获取或设置库存对象内所需的任何内容，例如操作的结果。

这样，如果你有一个新的Element类型，你只需要在新的Element中编写新的操作，并且你可以保持相同的Stock类而不需要改变它。这是扩展而不是修改。