超类可以将其子类静态地存储在列表中吗？

Question

I have a super class, SuperClass. I want a JList displaying every subclass of SuperClass. Not how many subclasses of SuperClass were instantiated, but how many subclasses I have actually defined in my program. The point is that it should be easy to add new subclasses without changing code anywhere else.

I'm hoping that my SuperClass can define a static map that would increase for every subclass I define (not instantiate). Now by clicking on the items of the JList the appropriate subclasses should be instantiated.

I will try to show what I want to do:

public abstract class SuperClass {
    protected static ArrayList<?extends SuperClass> subclasses = new ArrayList<>();
}
class SubClassOne extends SuperClass {
    static {
        subclasses.add(this)
    }
}

Now I realize there are lots of problems with above code, but I hope it clarifies what I want. I'm entirely clueless how I should proceed with regards to instantiating my subclasses from the JList.

Please specify if I can give any more information that could be of help.

Answer 1

You can use a static initializer block in your subclasses:

public class MySubclass extends MySuperclass {

    static {
        MySuperclass.register(MySubclass.class);
    }
}

then in your superclass you can have a register method like this:

protected static void reigster(Class<?> clazz) {
    subclasses.add(clazz);
}

Then when you want to instantiate a class:

MySuperclass subclassInstance = subclasses.get(someIndex).newInstance();

Note that this only works if you actually load those classes. For dynamic class loading you might have to implement your own ClassLoader or use some dynamic OSGi framework like the Apache Felix.

Answer 2

Approach 1:

public abstract class SuperClass {
    protected static ArrayList<Class<? extends SuperClass>> subclasses = new ArrayList<>();
}
class SubClassOne extends SuperClass {
    static {
        subclasses.add(SubClassOne.class);
    }
 }

Approach 2

Scan entire classpath (using reflection), iterate for each class and check if the class inherits from your superclass.
You could look into Reflections library . I'd do it for you in an easy way.

Hope this helps.

Answer 3

As demonstrated by the other answers, it is not suited for inheritance . Rather look at the factory pattern: some factory class that holds (a map of) classes, and it can instantiate objects of one of those classes.

There are some standard mechanisms in Java.

1. You could make your own annotation; use annotation processing

    @Factored public class A { } @Factored public class B { } 

   This is a large coding overhead.

2. You could use the java service provider interface

   This SPI is used for detecting XML parsers and such, where jars on the class path have a file under MANIFEST with a text file with a file name the interface class path. In it one or more implementation classes may be listed. These implementations can then be listed.

   This is a declarative approach, so lacks the desired automatism.

3. Make an enum of factories

   Suitable only for a limited close-world set of classes, also giving strong dependencies.

    public enum Factory<T> { F_A(A.class), F_B(B.class); private static final Set<Class<T>> klasses = new HashSet<>(); static { for (Factory f : values()) { klasses.add(f.klass); } } public final Class<T> klass; private Factory(Class<T> klass) { this.klass = klass; } //public <S extends T> S instantiate(Class<S> kl) { public T instantiate() { ... } }