在Java中创建类数组

可以在Java中创建静态类数组吗？ 例如：

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

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

我们需要通过数组调用静态方法，而不是实例化它们

编辑：

以下是我们正在努力实现的目标。我们也可以使用许多开关，但将每个对象添加到每个方法中的每个开关听起来是多余的

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);
}

---

您需要区分类和对象。例如，您可能有：

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

或

你的问题不清楚你的意思，但希望这两种情况都能满足。。。请注意，您不能使用泛型数组，因此使用

Class[]

不能指定每个类必须扩展

SceneObject

编辑：现在我们有了更多的信息，听起来你有这样的信息：

abstract class SceneObject {}

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

    static void bar() {
    }
}

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

    static void bar() {
    }
}

这里的两个

foo

方法完全不相关-您不能使用多态性来调用它们，因为它们是静态方法。如果您想使用多态性-即调用一个知道要调用哪个签名的方法，但实现取决于调用的目标-您需要实例方法：

然后你可以写：

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

...

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

---

您需要区分类和对象。例如，您可能有：

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

或

你的问题不清楚你的意思，但希望这两种情况都能满足。。。请注意，您不能使用泛型数组，因此使用

Class[]

不能指定每个类必须扩展

SceneObject

编辑：现在我们有了更多的信息，听起来你有这样的信息：

abstract class SceneObject {}

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

    static void bar() {
    }
}

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

    static void bar() {
    }
}

这里的两个

foo

方法完全不相关-您不能使用多态性来调用它们，因为它们是静态方法。如果您想使用多态性-即调用一个知道要调用哪个签名的方法，但实现取决于调用的目标-您需要实例方法：

然后你可以写：

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

...

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

---

除了生成扩展SceneObject的类数组之外，我们还可以为这些对象创建一个容器：

//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
}

//只包含SceneObject类的容器
公共类类框{
阶级的私有阶级；
公共类框（类中的类）{
this.theClass=类；
}
公共类getTheClass（）{/'getClass（）'方法是保留的，我们使用一个更唯一的名称
返回类；
}
}
//测试班
抽象类SceneObject{}
类加载扩展了SceneObject{}
类菜单扩展了SceneObject{}
类noExtends1{}
//测试
公共图书馆{
ClassBox[]场景={new ClassBox（Loading.class），new ClassBox（Menu.class）}；//这些类扩展了SceneObject
//ClassBox[]sceneserror={new ClassBox（Loading.class），new ClassBox（noExtends1.class）}；//由于第二个数组元素未扩展而给出错误，因此我对其进行了注释
Log.v（“自定义Log.v调用”，String.valueOf（load.class））；
Log.v（“自定义Log.v调用”，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（））；
//结果是：
//V/custom log.V调用：类me2.iwanttobealeader.pie$Loading
//V/custom log.V调用：class me2.iwanttobealeader.pie$菜单
//V/custom log.V调用：类me2.iwanttobealeader.pie$Loading
//V/custom log.V调用：class me2.iwanttobealeader.pie$菜单
}

这个答案的好处是指定了多个继承标准，例如：

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

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

公共类类框
//现在它必须实现抽象类SyncListener并扩展片段

---

还有一个缺点是实例化一个额外的对象，即容器+包含类的变量，而不仅仅是包含类的变量。

除了创建一个扩展SceneObject的类数组之外，我们还可以为这些对象创建一个容器：

//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
}

//只包含SceneObject类的容器
公共类类框{
阶级的私有阶级；
公共类框（类中的类）{
this.theClass=类；
}
公共类getTheClass（）{/'getClass（）'方法是保留的，我们使用一个更唯一的名称
返回类；
}
}
//测试班
抽象类SceneObject{}
类加载扩展了SceneObject{}
类菜单扩展了SceneObject{}
类noExtends1{}
//测试
公共图书馆{
ClassBox[]场景={new ClassBox（Loading.class），new ClassBox（Menu.class）}；//这些类扩展了SceneObject
//ClassBox[]sceneserror={new ClassBox（Loading.class），new ClassBox（noExtends1.class）}；//由于第二个数组元素未扩展而给出错误，因此我对其进行了注释
Log.v（“自定义Log.v调用”，String.valueOf（load.class））；
Log.v（“自定义Log.v调用”，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（））；
//结果是：
//V/custom log.V调用：类me2.iwanttobealeader.pie$Loading
//V/custom log.V调用：class me2.iwanttobealeader.pie$菜单
//V/custom log.V调用：类me2.iwanttobealeader.pie$Loading
//V/custom log.V调用：class me2.iwanttobealeader.pie$菜单
}

这个答案的好处是指定了多个继承标准，例如：

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

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

公共类类框
//现在它必须实现抽象类SyncListener并扩展片段

---

还有一个缺点是实例化一个额外的对象，即容器+包含类的变量，而不仅仅是包含类的变量。

尝试此操作时是否出错？是的。类型不匹配：无法从类转换为SceneObjectRight，因此您可以在将来定义

Class[]scenes=…

，请始终在问题中指定错误。此外，请提供更多的背景信息-我们无法说出您想要实现的目标，这使得帮助您变得更加困难。您尝试此操作时是否出错？是的。类型不匹配：无法从转换