实例化另一个对象

我读了你的文章好几遍了,有些东西仍然让我困惑。例如,在您的a/b/c示例中,您谈论的行为是相同的,除非值不同。我认为你需要把行为和陈述的概念分开。行为是一个类将要做的事情,状态是其属性的值。阶级的行为,如果经常依赖于国家,即:

Color getColor() {
    if (color == null) return parent.getColor();
    else return color;
}

class Foo {
    Foo parent = null;
    Color color;

    Foo(Foo parent) {
        this.parent = parent;
    }

    Color getColor() {
        //If there is no parent we have to return color regardless.
        if (parent == null) {
            return color;
        }

        // If there is a parent we can choose which to return.
        return color == null ? parent.getColor() : color;
    }

    void setColor(Color color) {
        this.color = color;
    }
}

除非您需要与FooInstance不同的行为,否则可以对单个类执行所需的操作。

我不知道有哪个第三方API提供这种数据结构。但它们可能存在。

feature 属于 java.util.Properties

package stackoverflow;
import java.util.Properties;

public class Main {
    static Properties propsBase;
    static Properties propsOverlay;
    static Properties propsOverlayOverlay;

    public static void main(String[] args) {
        propsBase = new Properties();
        propsOverlay = new Properties(propsBase);
        propsOverlayOverlay = new Properties(propsOverlay);

        propsBase.setProperty("key1", "value1");
        propsBase.setProperty("key2", "value2");
        debugAllProps();

        propsOverlay.setProperty("key1", "overlayValue1");
        debugAllProps();

        propsOverlayOverlay.setProperty("key1", "overlayOverlayValue1");
        debugAllProps();

        propsOverlayOverlay.remove("key1");
        debugAllProps();

        propsOverlay.remove("key1");
        debugAllProps();
    }

    private static void debugAllProps() {
        printProps("propsBase", propsBase);
        printProps("propsOverlay", propsOverlay);
        printProps("propsOverlayOverlay", propsOverlayOverlay);
        System.out.println("------------------------------------------------");
    }

    private static void printProps(String desc, Properties props) {
        System.out.printf("%-25s", desc + " sees:");
        for (String key : props.stringPropertyNames()) {
            System.out.printf(" %s=%s", key, props.getProperty(key));
        }
        System.out.println();
    }
}

输出:

propsBase sees:           key2=value2 key1=value1
propsOverlay sees:        key2=value2 key1=value1
propsOverlayOverlay sees: key2=value2 key1=value1
-------------------------------------------------
propsBase sees:           key2=value2 key1=value1
propsOverlay sees:        key2=value2 key1=overlayValue1
propsOverlayOverlay sees: key2=value2 key1=overlayValue1
-------------------------------------------------
propsBase sees:           key2=value2 key1=value1
propsOverlay sees:        key2=value2 key1=overlayValue1
propsOverlayOverlay sees: key2=value2 key1=overlayOverlayValue1
-------------------------------------------------
propsBase sees:           key2=value2 key1=value1
propsOverlay sees:        key2=value2 key1=overlayValue1
propsOverlayOverlay sees: key2=value2 key1=overlayValue1
-------------------------------------------------
propsBase sees:           key2=value2 key1=value1
propsOverlay sees:        key2=value2 key1=value1
propsOverlayOverlay sees: key2=value2 key1=value1

这种方法有一些重要的局限性:

• java.util.Properties属性 ,您只能存储和检索 String 价值观。

• 您必须注意只使用由 java.util.Properties属性 Hashtable ,不知道层次结构并忽略它。

java.util.Properties属性 ,而是使用 Properties 作为灵感的一般方法。你可以把源代码读到 java.util.Properties属性 看着里面 src.zip ,它与JDK一起安装。

我对收藏的看法是

• 允许对象键和对象值
• 可能不会对任何现有的集合进行子类化-主要是为了避免让每个超类方法“层级意识”。 decorate 一 HashMap .
• 可能会实现一些 java.util
• 可能支持泛型

看起来您正在尝试实现类似于CSS的行为——特别是 部分。这并不是一个特别常见的模式,但我以前必须实现这种模式。我不想把类型分成 Foo FooInstance --我将创建一个类,该类将以一般方式处理此模式,可能使用 HashMap

public class Foo {
    private Foo parent;
    private HashMap<string, Object> propertyValues = new HashMap<string, Object)>();

    public Foo() {
    }

    public Foo(Foo parent) {
        this.parent = parent;
    }

    protected Object getProperty(string propertyName) {
        if (properties.containsKey(propertyName))
            return properties.get(propertyName);
        else if (parent != null)
            return parent.getProperty(propertyName);
        else
            return null;
    }

    protected void setProperty(string propertyName, value) {
        properties.put(propertyName, value);
    }

    public Color getColor() {
        return (Color)getProperty("color");
    }

    public void setColor(Color color) {
        setProperty("color", color);
    }
}

我只想用装饰图案。这两个类不一定需要相同,但需要实现一个公共接口,并在构造函数中获取另一个,然后让getter移交给包装类,直到其中一个在包装类中被重写。在这个例子中,为了简单起见,我只使用了一个类,但是可以灵活地使用任何颜色。从测试开始:

import junit.framework.TestCase;

import java.awt.*;

public class CascadingTest extends TestCase {

    public void testCascade() throws Exception {
        Colorful a = new Foo();
        a.setColor(Color.RED);
        assertEquals(Color.RED, a.getColor());

        Colorful b = new Foo(a);
        assertEquals(Color.RED, b.getColor());

        b.setColor(Color.PINK);
        assertEquals(Color.PINK, b.getColor());

        b.setColor(null);
        assertEquals(Color.RED, b.getColor());
    }
}

import java.awt.*;

public interface Colorful {
    Color getColor();
    void setColor(Color color);
}

import java.awt.*;

public class Foo implements Colorful {

    private Color color;
    private Colorful parent;

    public Foo() {}

    public Foo(Colorful parent) {
        this.parent = parent;
    }

    public Color getColor() {
        if (parent != null && this.color == null) {
            return parent.getColor();
        } else {
            return color;
        }
    }

    public void setColor(Color color) {
        this.color = color;
    }
}