How to determine current class type?

Question

I had 2 classes, B and C, who needed to keep track of their instances, so each of them has an ArrayList of their respective types to which instances were added in the constructor.

Since this seemed like common behaviour, I tried to find some sort of standard Java interface or class that expresses this behaviour, something like an InstanceManager interface. I didn't find any

I ended up trying to write an abstract class for it and I got stuck because I don't know how to specify the specific type of the subclasses. For example:

public abstract class C { public static ArrayList<C> list; }
public class A extends C { }
public class B extends C { }

In this case, B.list or A.list would be lists of C objects, but I would actually want them to be lists of B and A objects, respectively.
Is there any way I could make that happen easily?
I am thinking something along the lines of

public abstract class C { public static ArrayList<thisclass> list; }

but that would obviously not work.

I realise that I could probably use generics to handle this, but it feels redundant and I can't help wishing that there is a way to somehow infer the child class type in this situation.

Also, is there any standard Java interface for handling instance management or unique instance id generation?

EDIT:
I have come to understand that static variables are not inherited, and the subclasses' static variables actually refer to the same thing. As such, is there any way I can define instance managing behaviour without resorting to redundancy, having to write the same things in all subclasses?

If this is a `static` holder, you're out of luck. Both `A` and `B` will share the same list. — Sotirios Delimanolis, Nov 04 '14 at 16:58
why not use a Map>, insert each instance to the appropriate list according to the runtime type — yurib, Nov 04 '14 at 16:59
@yurib I could, but that would imply having a centralised collection of all subclasses, and I'd prefer to have different lists for each type. — Ionuț-Claudiu Herciu, Nov 04 '14 at 17:05
@RedCat23 nope, you'd still have a different list for each type... each map entry is a key value pair for a specific subclass, the key is the class and the value is the list — yurib, Nov 04 '14 at 17:09
@yurib You're right, that would work nicely. It might be useful for others to put it as an answer. — Ionuț-Claudiu Herciu, Nov 04 '14 at 17:31

score 0 · Answer 1 · answered Nov 04 '14 at 17:17

0

Using generics, you can do something like:

abstract class C<T> {
    public List<T> list;
}

class A extends C<A> {
}

class B extends C<B> {
}

answered Nov 04 '14 at 17:17

jjlema

850
5
8

But that wouldnt hold instances, since it isnt static. Please read the question carefully – Terry Storm Nov 04 '14 at 17:26

yurib · Answer 2 · 2014-11-04T18:08:56.313

0

Keep a class name to list of instances mapping, determine the type at runtime to insert instances to the appropriate list:

 Map<String,List<?>> instances;
 ....
 instances.get(instance.getClass().getName()).add(instance);

edited Nov 04 '14 at 18:08

answered Nov 04 '14 at 17:48

yurib

8,043
3
30
55

Radiodef · Accepted Answer · 2014-11-04T18:48:35.240

It's already been pointed out that a Map is appropriate here; however there are a few other concerns:

Multithreading.
Garbage collection.

#1 is fairly easy to factor in but worthwhile to point out.

#2 is important because you want to think carefully about whether or not keeping a list of all instances should prevent them from being garbage collected. If not, you need to become familiar with the WeakReference class.

Here is an example of the more complicated case.

public final class InstanceManager<T> {
    private final Map<Class<?>, List<Reference<T>>> refMap = (
        new HashMap<Class<?>, List<Reference<T>>>()
    );

    public synchronized <U extends T> U manage(U instance) {
        Class<?> cls = instance.getClass();
        List<Reference<T>> refList = refMap.get(cls);

        if(refList == null) {
            refList = new LinkedList<Reference<T>>();
            refMap.put(cls, refList);
        }

        refList.add(new WeakReference<T>(instance));
        return instance;
    }

    public synchronized <U extends T> List<U> getAll(Class<U> cls) {
        List<U> returnList = new LinkedList<U>();

        List<Reference<T>> refList = refMap.get(cls);
        if(refList != null) {

            Iterator<Reference<T>> it = refList.iterator();
            while(it.hasNext()) {
                T instance = it.next().get();

                if(instance == null) {
                    it.remove();
                } else {
                    returnList.add(cls.cast(instance));
                }
            }
        }

        return returnList;
    }
}

As an example of usage,

InstanceManager<Object> im = new InstanceManager<Object>();

Object o1 = im.manage(new Object());
Object o2 = im.manage(new Object());

String s1 = im.manage("a");
String s2 = im.manage(new String("b"));

System.out.println("Object count: " + im.getAll(Object.class).size());
System.out.println("String count: " + im.getAll(String.class).size());

o2 = s1 = s2 = null;

System.gc();
Thread.sleep(1000);

System.out.println("Object count: " + im.getAll(Object.class).size());
System.out.println("String count: " + im.getAll(String.class).size());

The output here is

Object count: 2
String count: 2
Object count: 1
String count: 1

because this InstanceManager allows its referents to be garbage collected. If that's not the desired behavior (you aren't keeping references to the instances elsewhere) then of course you need to release them manually.

But either way this allows you to do something like

public abstract class C {
    private static final InstanceManager<C> manager = new InstanceManager<C>();

    protected C() {
        manager.manage(this);
    }
}

where all instances of C and its subclasses are automatically managed and categorized by actual type.

Brilliant answer, thank you. But would it work if I were to, say, make the'InstanceManager' no longer `final`, make its methods `private` and inherit from it? — Ionuț-Claudiu Herciu, Nov 04 '14 at 19:30
Also, why did you enclose the `HashMap` initialization in parantheses? — Ionuț-Claudiu Herciu, Nov 04 '14 at 19:31
Trying to inherit from the instance manager sounds like a design nightmare. Better to make it a `public static` member of `C` for example. Better separation of concerns. Parenthesizing the `new HashMap` is just a multiline syntax I use. There's no significance to it except it looks nice to me. — Radiodef, Nov 04 '14 at 19:47

How to determine current class type?

3 Answers3