为什么不使用静态变量为子类共享对象？

Question

我的问题有点长。 我正在学习抽象工厂模式。

我有一个抽象工厂的抽象类。 我想分享混凝土工厂所需的“资源”。 所以我只是将 AbstractFactory 中的变量设为静态

public class AbstractFactory{
    private static Vector vector = new Vector();

    protected Vector void getVector() {
        return vector;
    }

    protected void setVector(Vector v){
        this.vector = v;
    }

    public abstract Circle createCircle();
}

它的子类看起来像：

public class ConcreteFactory extends AbstractFactory{
    public ConcreteFactory(){
        super();
    }

    public Circle createCircle(){
        Circle circle = new Circle();
        getVector().add(circle);
        return circle;
    }
}

但是，我的老师说我不应该使用静态对象实例 因为静态变量经常用于一些常量。

因此，对于 Vector，我使用 instance variable instance 而不是 static variable ，当我实例化具体工厂时，我从外部传递向量。

所以我的课程的新设计将如下所示：

public class AbstractFactory{
    private Vector vector;

    protected Vector void getVector() {
        return vector;
    }

    protected void setVector(Vector v){
        this.vector = v;
    }

    public abstract Circle createCircle();
}

public class ConcreteFactory extends AbstractFactory{
    public ConcreteFactory(Vector v){
        super();
        setVector(v);
    }

    public Circle createCircle(){
        Circle circle = new Circle();
        getVector().add(circle);
        return circle;
    }
}

**

我的问题是：为什么我不应该使用静态变量来共享对象？

**

在具体工厂之间共享资源将更容易，无需传入 Vector 当我创建一个具体工厂的实例时。

Answer 1

有时，今天让你的生活变得更轻松的东西会让你的生活变得更加困难。

一些例子：你并不总是知道你的类将被使用的环境。也许你的工厂的不同实例最终会被不同的类加载器加载（这在 Web 应用程序中经常发生）。以这种方式使用静态实例变量可能会导致完全不可预测的行为。静态变量几乎总是一个坏主意。

也就是说，我认为你在课堂上真正想做的是：

public class AbstractFactory{
    private final Vector vector;

    protected AbstractFactory(Vector vector){
        this.vector = vector;
    }

    protected Vector void getVector() {
        return vector;
    }

    public abstract Circle createCircle();
}

和

public class ConcreteFactory extends AbstractFactory{
    // USE THIS IF YOU NEED TO SHARE THE VECTOR AMONGST MULTIPLE FACTORY INSTANCES
    public ConcreteFactory(Vector vector){
        super(vector);
    }
    // OR USE THIS IF THE VECTOR IS SPECIFIC TO THE FACTORY
    public ConcreteFactory(){
        super(new Vector());
    }    

    public Circle createCircle(){
        Circle circle = new Circle();
        getVector().add(circle);
        return circle;
    }
}

在实例变量上使用 final 对这类事情来说是个好主意 - 它可以防止您意外更改代码中其他地方的变量。但这是可选的。我所做的关键更改是将向量添加到抽象基类的构造函数中，然后从超类传入。

Answer 2

static 属性不应该以这种方式使用。
statics 是某种东西，在运行时只能使用一次。
在您的情况下，这意味着从您的AbstractFactory 派生的 所有 工厂将共享这个单一向量。

看这个例子：

ConcreteFactory a = new ConcreteFactory();
ConcreteFactory b = new ConcreteFactory();
a.createCircle();
b.createCircle();

对象a 和b 现在将在向量中有两个条目，因为它们共享相同的静态向量。

我也觉得

protected void setVector(Vector v){
    this.vector = v;
}

是非法的，因为vector 不是Factory 实例的属性，而是Factory 本身的属性！

除此之外，它只是一种糟糕的、容易出错的（尝试在更大范围内进行调试）和简单丑陋的编码风格。

相信你的老师 - 他是对的；）

Answer 3

static final 变量有时被用作常量这一事实不应阻止您使用相同的机制，只要它提供最佳服务（记录器是我能给出的唯一其他示例）。

不过，当没有与外部世界的隐式组件耦合时，这总是好的。如果将向量定义为静态变量，则用户无法使您的工厂基于上下文且彼此独立。如果你将向量作为工厂的参数，那么由工厂创建者（现在通常是 Spring 上下文加载器）来定义哪些工厂共享向量，哪些不共享。

在您的案例中将向量作为参数传递的另一个原因与单元测试方面有关。如果您的课程旨在从外部获取矢量，您可以模拟它并更彻底地测试您的课程。