Java-获取扩展抽象类的所有类

Question

Okay, so I'm starting to use Abstract classes, but I have a question : I have this abstract class Quest . My objective is to, when initializing a new Quest object, give it a random Quest type (Represented by a class extending Quest). For now my code is :

switch (r) {
    case 0:
        quest = new Bandit_Raids2();
        break;
    case 1:
        quest = new Bandit_Raids();
        break;
    case 2:
        quest = new Escort_Mission();
}

Is there any way to do this automatically, or just cleaner ?

Answer 1

I propose a different approach:

You could make your abstract class Quest an enum , and then implement the abstract methods in each enum constant (below is just an example):

public enum Quest {
    ESCORT_MISSION {
        public void start(){/* escort something */}
    },
    BANDIT_RAIDS{
        public void start(){/* raid bandits */}
    },
    BANDIT_RAIDS2{
        public void start(){/* raid bandits, again */}
    };

    public abstract void start();

    // add here other methods and/or constructors and/or fields
}

That way you could then randomly select an enum constant (which is an instance of Quest ):

Quest[] values = Quest.values();
int randomIndex = ThreadLocalRandom.current().nextInt(values.length);
Quest quest = values[randomIndex];

The only downside to this is that you have to put all the implementations into a single class file, which can get quite messy, quite easily

Answer 2

For the first part of the question, to do such thing in an automatic way will probably require reflexion but for the second part about being clean, most people will find it not that clean.

A possible solution if you agree to reduce a little the scope to "all classes that extends Quest" would be to have some static initializer method on all subclasses of Quest to register themself as a possible Quest and having a generic way to create instance for them something like

public abstract class Quest {
    private static final List<Supplier<Quest>> suppliers = new ArrayList<>();

    protected static void register(Supplier<Quest> questSupplier) {
        suppliers.add(questSupplier);
    }

    public static Quest createQuest(){
        int r = 0; // replace by the random call you want there
        return suppliers.get(r).get();
    }
}




public class BanditQuest extends Quest{
    static {
        Quest.register(() -> new BanditQuest());
    }
}

Answer 3

I would use the factory pattern.

public abstract class Quest {
    // some generic code
}

public class BanditQuest extends Quest {
    // some specific code
}

public interface Factory {
    Quest create();
}

public class BanditFactory implements Factory {
    @Override
    public Quest create() {
        return new BanditQuest();
    }
}

List<Factory> factories = new ArrayList<Factory>();
factories.add(new BanditFactory());
// add all factories here

Quest quest = factories.get(r).create();

You need to make sure that r is not bigger than your list though.