如何自动将子类放入ArrayList？

Question

I have a superclass, and then several subclasses, like this:

public abstract class A {
    public abstract int getValue();
}

public class B extends A {
    public int getValue() {
        return 1;
    }
}

public class C extends A {
    public int getValue() {
        return 123;
    }
}

public class D extends A {
    public int getValue() {
        return 15234;
    }
}

There are about 100 or so subclasses. I also have a manager:

public class Manager {
    public static ArrayList<A> list = new ArrayList<A>();
}

How can I "magically" add an instance of all subclasses of A to list without manually creating an instance of every single subclass and adding it to the list? Perhaps with using an Initialization Block?

EDIT

It's not important how I access list in Manager . I edited it to be static.

Answer 1

(2nd attempt - my first attempt was based on a misunderstanding of the Question.)

I'm assuming that what you want to do is build a (static) list that:

• contains exactly one instance of each of the subclasses,
• is created and populated ahead of time, and
• doesn't involve code in each subclass creating / adding an instance of itself to the list.

Firstly, an instance initializer block won't do this. An instance initializer is run when you create an instance ... and something has to new the class (ie each of the subclasses) for this to happen.

I think the only viable approach is to write some hairy reflective code that:

• iterates over all classes on the classpath,
• loads each one using Class.forName() ,
• reflectively tests to see if the class is a subclass of A ,
• if it is, reflectively invokes the classes no-args constructor and adds the resulting instance to "the list".

This is (IMO) pretty hacky!! And it is going to be expensive ... unless you can limit the "package space" that needs to be searched for these subclasses.

---

Actually, this could be a problem that would be better solved using an enum ... especially if the subclasses don't have behavioural differences that require different method implementations. (For instance your getValue() method could just return a private variable ... that you initialize using a constructor.) See @Paul Bellora's answer.

(The thing that would prevent this from being applicable would be if there needed to be multiple instances of some of the subclasses. That's not possible with enums .)

Answer 2

Each class is going to represent a command.

Based on the description of your problem, it sounds like A could be an enum :

public enum A {

    B(1) {
        @Override
        public void execute() {
            //code and stuff
        }
    },
    C(123) {
        @Override
        public void execute() {
            //code and stuff
        }
    },
    D(15234) {
        @Override
        public void execute() {
            //code and stuff
        }
    };

    private final int value;

    private A(int value) {
        this.value = value;
    }

    public int getValue() {
        return value;
    }

    public abstract void execute();
}

Now, there is exactly one instance of each command, and you can easily iterate commands with A.values() .

Answer 3

This is a bit of a hackish way to do it, but if all your subclasses are in one folder (the actual class files) you could iterate over the files in the folder and use the ClassLoader . You code would look something along the lines of -

for(String className : classNames){
    Class clazz = classLoader.loadClass(className);
    list.add(clazz.newInstance());
}

Look at the ClassLoader API for more info. Also keep in mind that this is not very efficient, but if you are just doing this once you should be fine.

Answer 4

Although it doesn't quite make sense... one way you can do is, do things similar to Spring's component scanning: make use of things like PathMatchingResourcePatternResolver and find out all possible classes. Iterate through them and add to list if that is a subclass of A.

Answer 5

Could be like this :

public abstract class A {
    public A(Manager m) {
        m.list.add(this);
    }
    public abstract int getValue();
}

public class B extends A {
    public B(Manager m) {
        super(m);
    }
}

This way you never again have to deal with m.list.add(new A()); while subclassing. But I don't know if this is what you are looking for...

---

EDIT :

It's not important how I access list in Manager. I edited it to be static.

If you don't care about using singletons, here is a very basic implementation:

But read What is bad about singletons .

public class Manager {
   private static Manager instance = null;
   protected Manager() {
      // Exists only to defeat instantiation.
   }
   public static Manager getInstance() {
      if(instance == null) {
         instance = new Manager();
      }
      return instance;
   }
}

Then:

public abstract class A {
    public A() {
        Manager.getInstance().list.add(this);
    }
    public abstract int getValue();
}

public class B extends A {
}

But, again this is very not satisfying as a design...

Answer 6

1) You need to find all available subclasses of class A. For that you need to scan all classes on the Java classpath. To make things easier we can assume that all subclasses are in the same location as A.class. A is supposed to be in a jar or in a folder. We can find out its actual location as

URL url = A.class.getProtectionDomain().getCodeSource().getLocation();

2) Lets assume that it is a folder, eg file:/D:/workspace1/x/target/classes/. Now we should walk thru all .class files in this folder and subfolders. We can use File.listFiles or Java 7 NIO2 for that. We have 2 options

a) load each class and check its superclass

   Class cls = Class.forName();
   if (cls.getSuperClass() == A.class) {
     ...

b) use javaassist framework http://www.javassist.org or similar to work with class file directly

DataInputStream ds = new DataInputStream(new BufferedInputStream(path));
ClassFile cf =  new ClassFile(ds);
String superClass = cf.getSuperClass();
if (superClass.equals("A")) {
    Class cls = Class.forName(cf.getName());
...

option b is loads only the classes you actually need, option a is simpler but it loads all classes in the folder

In both cases you create of an instance as

A a = (A) cls.newInstance();

assuming that all subclasses have no-arg constructor

Answer 7

How about using a class path scanner to automatically detect your target classes :

   List<Class<?>> classes = CPScanner.scanClasses(new ClassFilter().packageName("com.foo.*").superClass(A.class));

Since you've got the target classes, you can easily initialize them by using newInstance method.

By the way use the maven dependency below to use the given snippet:

<dependency>
    <groupId>net.sf.corn</groupId>
    <artifactId>corn-cps</artifactId>
    <version>1.1.1</version>
</dependency>

Cheers.