How to share properties between class instances and other possible users of those properties?

Question

Say that there are multiple classes {C1, C2, ...} which implement an interface I, containing, among other things, methods called getColor(), getName(), and move(). Every instance of C1 returns the same value when getColor() and getName() are called, same with C2 and all of the other classes that implement I. Move is defined per class, too, but is affected by instance variables and may not behave the same way per instance. The implementations of getColor() and getName() in the C1 class might look like:

public Color getColor() {
    return Color.RED;
}

public String getName() {
    return "C1!!!";
}

All objects implementing the interface I can be added to and drawn to a screen. Suppose, however, that the way in which those objects are added, is through a different screen, with buttons on it. When one of those buttons is clicked, it signals to the application that the type of object associated with the clicked should be added to the screen.

If the goal is to label the button associated with C1 with the String returned by C1's getName() and color the button with the Color returned C1's getColor(), one could instantiate a new instance of C1, and then retrieve its name and color to customize its associated button:

...
I instance = new C1();
Button C1Button = new Button();
C1Button.setLabel(instance.getName());
C1Button.setColor(instance.getColor());
...

... and then instantiate a new instance of C2 and C3 and ... and C50, following the same process as with C1.

This seems rather dirty though, the classes are no longer being instantiated for the sake of fulfilling the other methods in I, but just to obtain the color and name properties for the buttons. Furthermore, that would be a awful lot of code. Can anyone provide suggestions as to how the color and name properties could be decoupled from the classes implementing I, so as to reduce the length of code required if the number of classes implementing I grows dramatically past two? Are there any specific design patterns that might be used to resolve this?

Answer 1

I usually do that sort of thing by making an enum like this, separate from the implementation classes

public enum TypeOfC
{
    C1(Color.RED, C1::new),
    //you don't have to use different classes for every one!
    CX(Color.BLACK, () -> new C1(5)),
    C2(Color.BLUE, C2::new);

    private final Color m_color;
    private final Supplier<I> m_constructor;

    TypeOfC(Color color, Supplier<I> ctor)
    {
        m_color = color;
        m_constructor = ctor;
    }

    public Color getColor()
    {
        return m_color;
    }

    public I create()
    {
        return m_ctor.get();
    }
}

Then you can make buttons like:

for (TypeOfC t : TypeOfC.values())
{
    Button b = new Button();
    b.setColor(t.getColor());
    b.setLabel(t.name());  // make a different getter if you don't want the enum constant name
    b.setAction(()->doWatever(t.create()));
    allButtons.add(b);
}

Answer 2

One possible answer that I found involves using something like the type object pattern. It seems to be conceptually related to Matt's suggestion. Instead of defining multiple different classes that inherit from I, only one class, C needs to be defined, which accepts another class, Properties, in its constructor. All properties of C can then be retrieved from the Properties class associated with it:

public class C implements I {
    private final Properties properties;

    public C(Properties p) {
        this.properties = p;
    }

    @Override
    public Properties getProperties() {
        return properties;
    }
}

The properties can all be defined in a PropertyDictionary. When constructing new C's, the appropriate properties for an object can be grabbed from the PropertyDictionary. This way, the classes inheriting from I still maintain the same functionality (in a changed method name, though) and other accesors of the data can learn what they want to about the possible values that C can take by querying the PropertyDictionary:

Properties p = new Properties("Class name", Color.YELLER);
I instance = new C(p);
// instance.getProperties().getColor() == p.getColor(); --> True
...
for(Properties prop : PropertyDictionary.getProperties()) {
    Button b = new Button();
    b.setLabel(prop.getName());
    b.setColor(prop.getColor());
}

Multiple instances of C with the same Properties all reference the same Properties instance in the PropertyDictionary, somewhat like in Flyweight:

final Properties p = new Properties("Cat", Color.BLACK);
List<I> cats = new ArrayList<>(1000);

// make 1000 black cats:
for(int i = 0; i < 1000; i++) {
    cats.add(new C(p));
}