Java 反射，创建给定int的特定对象_Java_Reflection_Mapping

Java 反射，创建给定int的特定对象

java reflection mapping

Java 反射，创建给定int的特定对象,java,reflection,mapping,Java,Reflection,Mapping,我有像Dog.java，Cat.java，Bird.java，Fish.java，未列出.java等类。我还有一个ID.java，它只保留一些最终的int映射： public class ID{ public static final int CAT = 1; public static final int DOG = 3; // there maybe some integers skipped public static final int FISH = 4; // bu

我有像

Dog.java

，

Cat.java

，

Bird.java

，

Fish.java

，

未列出.java

等类。我还有一个

ID.java

，它只保留一些最终的int映射：

public class ID{
  public static final int CAT = 1;
  public static final int DOG = 3;   // there maybe some integers skipped
  public static final int FISH = 4;   // but all integers are unique
  public static final int BIRD = 6;
  public static final int NOT_LISTED = -1;
}

上面列出的所有类都扩展了

Animal.java

class。我需要的是给定“6”我需要创建一个

Bird

对象，给定“1”我需要创建

Cat

对象。给定“2”或“5”，我可以返回一个未列出的

对象，或者简单地抛出一个错误（这两种方法都有效）。我可以简单地使用开关盒
或HashMap
来完成，但是我的列表很长，我不想在列表增长时更新代码。所以我想到了反思，但我不知道怎么做
我们也欢迎任何其他有效的解决方案。很抱歉，我对反思一无所知。提前谢谢
编辑：ID是必须
您不需要对此进行反射
创建一个枚举而不是您的id类，并在枚举内有一个类引用，即：
enum Animal {
     CAT(1, Cat.class),
     DOG(2, Dog.class),
     FISH(3, Fish.class);


     private final Class clazz;
     private final int id;

     Animal(int id, Class clazz) {
        this.id = id;
        this.clazz = clazz;
     }

     public Object generateInstance() {
         return clazz.generateInstance();
     }

     public class getGeneratedClass() {
         return clazz;
     }

     public int getId() {
         return id;
     }
}

这利用了Java的特性，允许枚举成为功能齐全的类，并记录要在枚举中的每个条目中使用的类
。然后，您可以使用该类
根据需要生成新实例，只要该类具有0参数构造函数
要使用此功能，请执行以下操作：
Animal.DOG.generateInstance() // Returns a Dog object
Animal.CAT.generateInstance() // Returns a Cat object

如果您希望能够从id获取类型，您可以在枚举中构建一个HashMap
来执行查找，或者只需在enum.values（）上循环查找匹配项。
这不需要反射
创建一个枚举而不是您的id类，并在枚举内有一个类引用，即：
enum Animal {
     CAT(1, Cat.class),
     DOG(2, Dog.class),
     FISH(3, Fish.class);


     private final Class clazz;
     private final int id;

     Animal(int id, Class clazz) {
        this.id = id;
        this.clazz = clazz;
     }

     public Object generateInstance() {
         return clazz.generateInstance();
     }

     public class getGeneratedClass() {
         return clazz;
     }

     public int getId() {
         return id;
     }
}

这利用了Java的特性，允许枚举成为功能齐全的类，并记录要在枚举中的每个条目中使用的类
。然后，您可以使用该类
根据需要生成新实例，只要该类具有0参数构造函数
要使用此功能，请执行以下操作：
Animal.DOG.generateInstance() // Returns a Dog object
Animal.CAT.generateInstance() // Returns a Cat object

如果您希望能够从id获取类型，您可以在枚举中构建一个HashMap
来执行查找，或者只需在enum.values（）上循环查找匹配项。
这不需要反射
创建一个枚举而不是您的id类，并在枚举内有一个类引用，即：
enum Animal {
     CAT(1, Cat.class),
     DOG(2, Dog.class),
     FISH(3, Fish.class);


     private final Class clazz;
     private final int id;

     Animal(int id, Class clazz) {
        this.id = id;
        this.clazz = clazz;
     }

     public Object generateInstance() {
         return clazz.generateInstance();
     }

     public class getGeneratedClass() {
         return clazz;
     }

     public int getId() {
         return id;
     }
}

这利用了Java的特性，允许枚举成为功能齐全的类，并记录要在枚举中的每个条目中使用的类
。然后，您可以使用该类
根据需要生成新实例，只要该类具有0参数构造函数
要使用此功能，请执行以下操作：
Animal.DOG.generateInstance() // Returns a Dog object
Animal.CAT.generateInstance() // Returns a Cat object

如果您希望能够从id获取类型，您可以在枚举中构建一个HashMap
来执行查找，或者只需在enum.values（）上循环查找匹配项。
这不需要反射
创建一个枚举而不是您的id类，并在枚举内有一个类引用，即：
enum Animal {
     CAT(1, Cat.class),
     DOG(2, Dog.class),
     FISH(3, Fish.class);


     private final Class clazz;
     private final int id;

     Animal(int id, Class clazz) {
        this.id = id;
        this.clazz = clazz;
     }

     public Object generateInstance() {
         return clazz.generateInstance();
     }

     public class getGeneratedClass() {
         return clazz;
     }

     public int getId() {
         return id;
     }
}

这利用了Java的特性，允许枚举成为功能齐全的类，并记录要在枚举中的每个条目中使用的类
。然后，您可以使用该类
根据需要生成新实例，只要该类具有0参数构造函数
要使用此功能，请执行以下操作：
Animal.DOG.generateInstance() // Returns a Dog object
Animal.CAT.generateInstance() // Returns a Cat object

如果您希望能够从id获取类型，您可以在枚举内构建一个HashMap
来执行查找，或者只是在enum.values（）上循环查找匹配项。
这是一种完全不同的方法，因此我将作为单独的答案来执行此操作
只需创建从id到类的映射：
public static final int CAT = 1;
public static final int DOG = 3;   // there maybe some integers skipped
public static final int FISH = 4;   // but all integers are unique
public static final int BIRD = 6;
public static final int NOT_LISTED = -1;

Map<Integer, Class> classMap = new HashMap<>();
classMap.put(CAT, Cat.class);
classMap.put(DOG, Dog.class);
classMap.put(FISH, Fish.class);

public Object generateInstance(int id) {
     // Will throw NullPointerException if id isnt in map, you might want to consider some checks
     return classMap.get(id).generateInstance();
}

public static final int CAT=1；
公共静态最终整数狗=3；//可能跳过了一些整数
公共静态最终整数FISH=4；//但所有整数都是唯一的
公共静态最终整数=6；
公共静态最终整数未列出=-1；
Map classMap=newhashmap（）；
classMap.put（CAT，CAT.class）；
classMap.put（DOG，DOG.class）；
classMap.put（FISH，FISH.class）；
公共对象生成实例（int-id）{
如果ID不在map中，则抛出nulpPoExtExchange，您可能需要考虑一些检查。
返回classMap.get（id.generateInstance（）；
}

这将满足您的需要，您真的应该看看我在另一个答案中发布的枚举设计——从长远来看，它将提供更好的结果。
完全不同的方法，因此我将作为一个单独的答案来做
只需创建从id到类的映射：
public static final int CAT = 1;
public static final int DOG = 3;   // there maybe some integers skipped
public static final int FISH = 4;   // but all integers are unique
public static final int BIRD = 6;
public static final int NOT_LISTED = -1;

Map<Integer, Class> classMap = new HashMap<>();
classMap.put(CAT, Cat.class);
classMap.put(DOG, Dog.class);
classMap.put(FISH, Fish.class);

public Object generateInstance(int id) {
     // Will throw NullPointerException if id isnt in map, you might want to consider some checks
     return classMap.get(id).generateInstance();
}

public static final int CAT=1；
公共静态最终整数狗=3；//可能跳过了一些整数
公共静态最终整数FISH=4；//但所有整数都是唯一的
公共静态最终整数=6；
公共静态最终整数未列出=-1；
Map classMap=newhashmap（）；
classMap.put（CAT，CAT.class）；
classMap.put（DOG，DOG.class）；
classMap.put（FISH，FISH.class）；
公共对象生成实例（int-id）{
如果ID不在map中，则抛出nulpPoExtExchange，您可能需要考虑一些检查。
返回classMap.get（id.generateInstance（）；
}

这将满足您的需要，您真的应该看看我在另一个答案中发布的枚举设计——从长远来看，它将提供更好的结果。
完全不同的方法，因此我将作为一个单独的答案来做
只需创建从id到类的映射：
public static final int CAT = 1;
public static final int DOG = 3;   // there maybe some integers skipped
public static final int FISH = 4;   // but all integers are unique
public static final int BIRD = 6;
public static final int NOT_LISTED = -1;

Map<Integer, Class> classMap = new HashMap<>();
classMap.put(CAT, Cat.class);
classMap.put(DOG, Dog.class);
classMap.put(FISH, Fish.class);

public Object generateInstance(int id) {
     // Will throw NullPointerException if id isnt in map, you might want to consider some checks
     return classMap.get(id).generateInstance();
}

public static final int CAT=1；
公共静态最终整数狗=3；//可能跳过了一些整数
公共静态最终整数FISH=4；//但所有整数都是唯一的
公共静态最终整数=6；
公共静态最终整数未列出=-1；
Map classMap=newhashmap（）；
classMap.put（CAT，CAT.class）；
classMap.put（DOG，DOG.class）；
classMap.put（FISH，FISH.class）；
公共对象生成实例（int-id）{
如果ID不在map中，则抛出nulpPoExtExchange，您可能需要考虑一些检查。
返回classMap.get（id.generateInstance（）；
}

那会做你想做的