Java object type represented by variable

Question

How can i represent an object type with a variable such as a string. For example I have DrawPanel1, DrawPanel2, DrawPanel3, all the way through DrawPanel12. and in a separate class I have a method to create each one with "DrawPanel1 panel = new DrawPanel1();" but I want to have a method.

public void TestPanel(int panelNum){} 

where it so it creates DrawPanel(panelNum), so if 2 is passed in it creates a new DrawPanel2.

I thought of doing this with [ String Panel = ("DrawingPanel"+panelNum); ] but when I used Panel rather than the name of the object it wouldn't work.

Answer 1

I think I understand what you are asking, and I'm going to provide an answer to your immediate question. What you are attempting sounds a little over-complicated, however. The following may need a bit of tweaking...

public void testPanel(Class<?> clazz) {
    Object instance = Class.forName(class.getName());
    ...
}

At this point, instance won't do you much good. You could also create an interface DrawPanelI with the methods used by your different DrawPanel's and have each of them implement that interface. Then, change Object instance to DrawPanelI instance. Now, you can invoke the common methods through instance.

Answer 2

It is a very time consuming task to have variables DrawPanel1 - DrawPanel12. Instead, it would be much easier to have a list of them.

//Making the list
List<DrawPanel> drawPanels = new ArrayList<DrawPanel>();

//Adding to the list
drawPanels.add(new DrawPanel());

//Retrieving from the list
DrawPanel panel = drawPanels.get(0);//"DrawPanel1"

//Processing the list
for (DrawPanel panel: drawPanels){
   panel.doStuff();
}

Answer 3

Assuming there is a DrawPanel interface then it would be possible to use a factory pattern:

public class DrawPanelFactory() {
    public DrawPanel create(int whichTypeOfPanel) {
        if (whichTypeOfPanel == 1) {
            return new DrawPanel1();
        }
        ...
        if (whichTypeOfPanel == 12) {
            return new DrawPanel12();
        }

        throw new IllegalArgumentException("Unsupported panel type:" + whichTypeOfPanel);
   }
}

That ends up being a lot of if statements, but still easily testable. To avoid the if statements use a static Map<Integer, DrawPanelFactoryDelegate> to associate a specific integer value with a specific factory that knows how to create that specific type of DrawPanel:

public class DrawPanelFactory() {
    private static Map<Integer, DrawPanelFactoryDelegate> drawPanelFactories = new ...;
    static {
        drawPanelFactories.put(1, new DrawPanelFactory1());
        ...
        drawPanelFactories.put(12, new DrawPanelFactory12());
    }

    public DrawPanel create(int whichTypeOfPanel) {
        DrawPanelFactoryDelegate delegateFactory = drawPanelFactories.get(whichTypeOfPanel);
        if (delegateFactory != null) {
            return delegateFactory .create();
        }
        throw new IllegalArgumentException("Unsupported panel type:" + whichTypeOfPanel);
   }
}

interface DrawPanelFactoryDelegate {
    public DrawPanel create();
}

DrawPanel1Factory implements DrawPanelFactoryDelegate {
    public DrawPanel create() {
        return DrawPanel1();
    }
}

...

DrawPanel12Factory implements DrawPanelFactoryDelegate {
    public DrawPanel create() {
        return DrawPanel12();
    }
}

then in use:

DrawPanelFactory drawPanelFactory = new DrawPanelFactory();
DrawPanel aDrawPanel = drawPanelFactory.create(1);
...
DrawPanel yetAnotherDrawPanel = drawPanelFactory.create(12);