I need a way to randomize outcomes passing and holding classes

Question

I'm trying to add let's say 5 classes that they all extend a General class and implements an init() method in a different way. What I need is a way to store those classes while passing a number of chances for that Class to "happen"

For this I created a Class holder:

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

Also a GeneralOutcome class that the ones that will be added to a list will extend:

public class GeneralOutcome {

    public void init(String text, int times) {

    }
}

And the way I'm adding them to a list:

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

    }
}

The problem is that I'm not able (Don't know how really) cast back to GeneralOutcome to I can access the .init() method. I get The method init() is undefined for the type Class<capture#3-of ? extends GeneralOutcome>

I know this isn't the best way to do this. So I'm open to both, a fix for this and also what would be a better way to achieve something like this.

Answer 1

What you are trying to do here doesn't work for some reasons.

First of all, your init method isn't static. So that call

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

leads directly to a compile-time error.

But then, the whole design looks strange. What is the point of holding Class objects in the first place?

Why don't you create an interface

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

to later instantiate objects of whatever class implementing that interface? So that you can finally can deal with lists of such objects (together with those probabilities)?

[ I used the name foo on purpose: alone the strange name "init" makes it very unclear what your code is intended to do! In that sense you should rethink your design, and find better method names to express what those methods will be doing! ]

Long story short: using/holding Class objects doesn't buy you anything in your example code - it only adds complexity. So my advise is: start working there and get rid of that "detour". You might also want to read about the Open/Closed principle - that could give you some guidance how a good OO design looks like that uses abstract classes / subclassing in order to split "behavior" between base and derived classes.