Java 我需要一种方法来随机分配通过和举办课程的结果

我试图添加5个类，它们都扩展了一个通用类，并以不同的方式实现了

init（）

方法。 我需要的是一种存储这些类的方法，同时为该类传递一些“发生”的机会

为此，我创建了一个类持有者：

public class ClassHolder {

    private Class<? extends GeneralOutcome> holdClass;
    private int chances;

    public ClassHolder(Class<? extends GeneralOutcome> holdClass, int chances) {
        super();
        this.holdClass = holdClass;
        this.chances = chances;
    }

    public Class<? extends GeneralOutcome> getHoldClass() {
        return holdClass;
    }
    public void setHoldClass(Class<? extends GeneralOutcome> holdClass) {
        this.holdClass = holdClass;
    }
    public int getChances() {
        return chances;
    }
    public void setChances(int chances) {
        this.chances = chances;
    }
}

我将它们添加到列表中的方式：

public class Randomizer {

    private static List<ClassHolder> myList = new ArrayList<ClassHolder>();

    private static ClassHolder outcome01 = new ClassHolder(Outcome01.class, 10);
    private static ClassHolder outcome02 = new ClassHolder(Outcome02.class, 10);
    private static ClassHolder outcome03 = new ClassHolder(Outcome03.class, 10);
    private static ClassHolder outcome04 = new ClassHolder(Outcome04.class, 10);
    private static ClassHolder outcome05 = new ClassHolder(Outcome05.class, 10);


    public static void main(String[] args) {

        for(int i = 0; i < outcome01.getChances(); i++) {
            myList.add(outcome01);
        }
        for(int i = 0; i < outcome02.getChances(); i++) {
            myList.add(outcome02);
        }
        for(int i = 0; i < outcome03.getChances(); i++) {
            myList.add(outcome03);
        }
        for(int i = 0; i < outcome04.getChances(); i++) {
            myList.add(outcome04);
        }
        for(int i = 0; i < outcome05.getChances(); i++) {
            myList.add(outcome05);
        }

        System.out.println(myList.size());

        int rand = (int) (Math.random() * myList.size());

        System.out.println(rand);

        ClassHolder theHoldClass = myList.get(rand);

        System.out.println(theHoldClass.getHoldClass());

        Class<? extends GeneralOutcome> theOutcome = theHoldClass.getHoldClass();

        theOutcome.init();

    }
}

公共类随机化器{
私有静态列表myList=newarraylist（）；
私有静态类持有者outcome01=新类持有者（outcome01.class，10）；
私有静态类持有者outcome02=新类持有者（outcome02.class，10）；
私有静态类持有者outcome03=新类持有者（outcome03.class，10）；
私有静态类持有者outcome04=新类持有者（outcome04.class，10）；
私有静态类持有者outcome05=新类持有者（outcome05.class，10）；
公共静态void main（字符串[]args）{
for（int i=0；iClass由于某些原因，您试图在这里做的事情不起作用

首先，您的init方法不是静态的

Class<? extends GeneralOutcome> theOutcome = theHoldClass.getHoldClass();
theOutcome.init();

以后是否实例化实现该接口的任何类的对象？以便最终能够处理此类对象的列表（以及这些概率）

[我故意使用了foo这个名称：仅使用奇怪的名称“init”就不清楚您的代码打算做什么！从这个意义上说，您应该重新考虑您的设计，并找到更好的方法名称来表示这些方法将要做什么！]

长话短说：在示例代码中，使用/持有类对象并不能为您带来任何好处-它只会增加复杂性。因此，我的建议是：开始在那里工作，摆脱那种“迂回”。您可能还想了解-这可能会给您一些指导，告诉您一个好的OO设计是如何使用抽象类/子类划分“行为”的在基类和派生类之间。
接口aproach似乎是OP真正想要的。此外，它通常比继承的复杂性更好。@FredrikLundvall可能。在这里，我很难想出“OP想要什么”首先；-）是的，这是一个谜；-）但最好的猜测是不同类中的常见行为，但我在阅读你的答案之前没有看到。谢谢。我想我试图使它比实际需要的更复杂。现在使用接口方法，简化代码删除Holder的内容，我确实如此；）
Class<? extends GeneralOutcome> theOutcome = theHoldClass.getHoldClass();
theOutcome.init();

public interface OutcomeFunctionality {
   public void foo(String text, int times);
}