Creating an array of classes in Java

Question

Is it possible to create an array of static classes in Java? For example:

SceneObject[] scenes = {Loading.class, Menu.class};
// Loading and Menu extend SceneObject

We need to call static methods via the array, not instantiate them.

EDIT:

The following is what we are trying to accomplish. We could alternatively use many switches, but it sounds redundant to add every object to every switch in every method.

package net.bitworm.gameengine;

import org.newdawn.slick.GameContainer;
import org.newdawn.slick.Graphics;

import net.bitworm.scenes.*;

public class SceneController {

public enum Scene{
    LOADING_SCENE,
    MENU,
    SCENE_1
}

public static SceneObject[] scenes = {new Loading(), new Menu()};

public volatile static Scene currentScene = Scene.LOADING_SCENE;

public static void setScene(Scene newScene){
    currentScene = newScene;
    System.out.println("Switched to " + currentScene.toString());
}

public static void update(GameContainer container, int delta){
    scenes[currentScene.ordinal()].update(container, delta);
}
public static void render(GameContainer container, Graphics g){
    scenes[currentScene.ordinal()].render(container, g);
}
public static void mouseMoved(int oldx, int oldy, int newx, int newy){
    scenes[currentScene.ordinal()].mouseMoved(oldx, oldy, newx, newy);
}
public static void mousePressed(int button, int x, int y){
    scenes[currentScene.ordinal()].mousePressed(button, x, y);;
}
public static void mouseReleased(int button, int x, int y){
    scenes[currentScene.ordinal()].mouseReleased(button, x, y);
}
public static void mouseWheelMoved(int change){
    scenes[currentScene.ordinal()].mouseWheelMoved(change);
}
public static void keyPressed(int key, char c){
    scenes[currentScene.ordinal()].keyPressed(key, c);
}
public static void keyReleased(int key, char c){
    scenes[currentScene.ordinal()].keyReleased(key, c);
}

Yes. Type mismatch: cannot convert from Class<Menu> to SceneObject — Grayson Pike
– Grayson Pike, Commented Jan 1, 2015 at 9:27
In future, always specify an error in the question. Additionally, give more context - we can't tell what you're trying to achieve, which makes it harder to help you. — Jon Skeet
– Jon Skeet, Commented Jan 1, 2015 at 9:30

Jon Skeet · Accepted Answer · 2015-01-01 09:48:53Z

10

You need to differentiate between classes and objects. For example, you might have:

SceneObject[] scenes = { new Loading(), new Menu() };

or

Class[] classes = { Loading.class, Menu.class };

It's not clear from your question which you mean, but hopefully that should satisfy either case... note that you can't have generic arrays, so with the Class[] you can't specify that each class must extend SceneObject.

EDIT: Now we've got a bit more information, it sounds like you've got this:

abstract class SceneObject {}

class Menu extends SceneObject {
    static void foo() {
    }

    static void bar() {
    }
}

class Loading extends SceneObject {
    static void foo() {
    }

    static void bar() {
    }
}

The two foo methods here are completely unrelated - you can't use polymorphism to call them, because they're static methods. If you want to use polymorphism - i.e. call a method knowing which signature you want to call, but with an implementation that depends on the target of the call - you need instance methods:

abstract class SceneObject {
    abstract void foo() {
    }

    abstract void foo() {
    }
}

class Menu extends SceneObject {
    @Override void foo() {
    }

    @Override void bar() {
    }
}

class Loading extends SceneObject {
    @Override void foo() {
    }

    @Override void bar() {
    }
}

Then you can write:

SceneObject[] scenes = { new Loading(), new Menu() };

...

for (SceneObject scene : scenes) {
    scene.foo();
    scene.bar();
}

edited Jan 1, 2015 at 9:48

answered Jan 1, 2015 at 9:28

Jon Skeet

1.5m893 gold badges9.3k silver badges9.3k bronze badges

Sign up to request clarification or add additional context in comments.

15 Comments

Grayson Pike Over a year ago

Cannot create a generic array of Class<? extends SceneObject>

Grayson Pike Over a year ago

Yep. that works, unfortunatley, when we try to call the methods from the array, the methods are undefined for type Class.

Jon Skeet Over a year ago

@RayToal: Well not really - you could have a List<Class<? extends SceneObject>> easily enough. It's just that arrays can't be generic.

Grayson Pike Over a year ago

Is it possible to create an array to call static methods from without instantiating any classes or using a switch?

Jon Skeet Over a year ago

@GraysonPike: Why are you so against creating instances? It's not like you need to create lots of instances of these. Don't fight against the language.

|

Then Enok · Accepted Answer · 2017-02-19 16:00:38Z

1

Other than making an array of classes that extend SceneObject, we can make a container for these objects:

//a container that holds only the classes of SceneObject
public class ClassBox<T extends SceneObject> {
    private Class<T> theClass;

    public ClassBox(Class<T> theClass) {
        this.theClass = theClass;
    }
    public Class getTheClass() { //'getClass()' method is reserved, we use a more unique name
        return theClass;
    }
}

//testing classes
abstract class SceneObject {}
class Loading extends SceneObject {}
class Menu extends SceneObject {}
class noExtends1 {}

//testing 
public void main() {
    ClassBox[] scenes = {new ClassBox<>(Loading.class), new ClassBox<>(Menu.class)}; //these classes extend SceneObject
//  ClassBox[] sceneserror = {new ClassBox<>(Loading.class), new ClassBox<>(noExtends1.class)}; //gives error because 2nd array elem is not extending, so I commented it

    Log.v("custom log.v call", String.valueOf(Loading.class));
    Log.v("custom log.v call", String.valueOf(Menu.class));
    Log.v("custom log.v call", String.valueOf(scenes[0].getTheClass()));
    Log.v("custom log.v call", String.valueOf(scenes[1].getTheClass()));

//result is:
//V/custom log.v call: class me2.iwanttobealeader.pie$Loading
//V/custom log.v call: class me2.iwanttobealeader.pie$Menu
//V/custom log.v call: class me2.iwanttobealeader.pie$Loading
//V/custom log.v call: class me2.iwanttobealeader.pie$Menu
}

This answer has the benefit of specifying multiple criteria of inheritance for example:

public class ClassBox<T extends Fragment & FR_DbRequests.SynchListener>
//now it must implement the abstract class SyncListener and extend Fragment

But also the disadvantage of instantiating an additional object ,namely the container+variable containing the class, instead of just the variable containing the class.

edited Feb 19, 2017 at 16:00

answered Feb 19, 2017 at 0:51

Then Enok

6616 silver badges18 bronze badges

2 Comments

Stephen Rauch Over a year ago

When giving an answer it is preferable to give some explanation as to WHY your answer is the one.

Then Enok Over a year ago

Actually it's not "the one", it's just another way of making an array of classes, but let me just edit the answer.

Collectives™ on Stack Overflow

Creating an array of classes in Java

2 Answers 2

15 Comments

2 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

15 Comments

2 Comments

Your Answer

Sign up or log in

Post as a guest

Related