是否存在用于实现可变和不可变版本的Holder对象的模式？

user1214609 发表于 Dev

用户名

在我的应用程序中，持有人对象的类型很少，其主要目的是存储异构相关数据。它们的生命周期可以分为两个部分：

尽快收集数据；
在持有人的余生中，提供对存储数据的只读访问。

使持有者不可变是非常诱人的，但是数据一次无法提供给构造函数。我看到的最简单的解决方法是制作一个holder类的两个版本，一个是可变的，另一个不是：

public class MutableHolder {
    public int field1;
    public String field2;
    // ...
    public Object fieldN;
}

public class Holder {
    public final int field1;
    public final String field2;
    // ...
    public final Object fieldN;

    public Holder(MutableHolder mutableHolder) {
        this.field1 = mutableHolder.field1;
        this.field2 = mutableHolder.field2;
        // ...
        this.fieldN = mutableHolder.fieldN;
    }
}

但是，我觉得这种方法违反了DRY原则（如果我想更改任何内容，我一定不要忘记更新两个类的字段以及构造函数），并且容易出错。所以这是我的问题：是否存在我不知道的用于实现可变和不可变版本的Holder对象的任何现有模式？

编辑

我突然发现上面的代码是Builder模式的非常准系统的版本（请参阅this或this）。这使我认为，在这种情况下，违反DRY被认为是可以接受的。

摩洛尼克斯

我也已经为此绊脚了一段时间。这是我想出的一种设计模式，在其他地方没有看到过。

public class Bob
{
    // member variables
    private int value;

    // simple constructor
    private Bob()
    {
        value(0);
    }

    // constructor with value
    private Bob(int value)
    {
        value(value);
    }

    // get value
    public final int value()
    {
        return this.value;
    }

    // set value
    private final void value(int value)
    {
        this.value = value;
    }


    // mutable class modifies base class
    public static class Mutable extends Bob
    {
        // simple constructor
        private Mutable()
        {
            super();
        }

        // constructor with value
        private Mutable(int value)
        {
            super(value);
        }

        // set value
        public final void value(int value)
        {
            super.value(value);
        }
    }


    // factory creator for immutable
    public static final Bob immutable(int value)
    {
        return new Bob(value);
    }

    // factory creator for mutable
    public static final Mutable mutable()
    {
        return new Mutable();
    }

    // another mutable factory creator
    public static final Mutable mutable(int value)
    {
        return new Mutable(value);
    }
}

该类不是最终的，子类应该是安全的。
所有构造函数都必须是私有的。
公共访问者应该是最终决定。
基类中的私有mutators应该是最终的。
Mutable类中的公共mutators应该是最终的。
使用工厂方法构造不可变的可变对象。

这就像子类的可变模式一样，但是由于Mutable类是一个内部类，因此它可以访问基类中的私有字段和方法，因此无需保护任何可能被覆盖的内容。基类就像一个标准的可变类，除了构造函数和变量是私有的。可变子类是一个薄层（每个方法都是...），它暴露了变异器。

创建一个不可变的实例：Bob test1 = Bob.immutable（99）; 创建一个可变实例：Bob.Mutable test2 = Bob.mutable（）;

本文收集自互联网，转载请注明来源。

如有侵权，请联系[email protected] 删除。

编辑于2021-02-14

我来说两句

0条评论

登录后参与评论

来自分类Dev

Related 相关文章

文章