Say I have a super class "Animal" and subclasses "Cat", Dog, Bird". Is there a way to have an array of subclass type rather than class instances with which I'll be able to instantiate instances of each possible subclass?
To simplify, I want this:
Pseudo code: For each possible subclass of "Animal": create an instance of that class.
How can I do that?
Edit: I don't want an array of instances of these subclasses, I want an array of object type.
You can use Ploymorphism to achieve that.
Animal[] animalArray = new Animal[10];
animalArray[0] = new Dog();
animalArray[1] = new Cat();
Basically all subclasses of animal Class. When you want to retrieve the objects you can simply typecaset it
Dog dog = (Dog)animalArray[0];
To know the class you can simple use getClass() method. For example
Animal[] animalArray = new Animal[10];
animalArray[0] = new Dog();
System.out.println(animalArray[0].getClass());
will print class Dog.
After OP's comment
THERE IS NO WAY TO GET ALL SUBTYPES OF A CLASS even using reflection.
But you can do it by another way , you can say which is the only but longest way.
Answer before OP's comment
As your question is not clear yet but I guess you want to use array or Collection which will store all of the instances even it is the instance of superclass or subclass.Then I guess you need to do like this.
List<Object> list = new ArrayList<Object>();
list.add(new Cat());
list.add(new Dog());
list.add(new Animal());
list.add(new Cat());
for (int i = 0; i < list.size(); i++) {
if(list.get(i) instanceof Cat){
System.out.println("Cat at "+i);
}else if(list.get(i) instanceof Dog){
System.out.println("Dog at "+i);
}else if(list.get(i) instanceof Animal){
System.out.println("Animal at "+i);
}
}
This code is tested
Note: Keep in mind that Don't place parent class check like in case of example code (list.get(i) instanceof Animal) at top, otherwise it will pass both cases (if checks are only if-if-if) or skip one case(and always return the object as a Animal if checks are if-else if-else if) (list.get(i) instanceof Animal) and (list.get(i) instanceof Cat) If the returning object is a Cat object.
As mentioned in another answer, this is not possible using purely reflection.
Unless you can customize your classes to specifically handle this case, you'd need to dive into either iterating over classes from the class loader, or using a custom class loader that adds the information into an internal data structure so that when it is requested later you don't have to reiterate over all classes.
Assuming you're not interested in diving into class loader code (it sounds like you are not), the next best way of doing this is adding static code to your classes that gets run at class loading time. For example:
public class Animal {
protected static List subclasses = new ArrayList();
//...
}
public class Cat extends Animal {
static {
subclasses.add(Cat.class);
}
//...
}
This would be essentially what you would do with a custom class loader, where this code would live in the class loader instead of the class.
Repeat this pattern for all subclasses. Then when you want to create instances, you have class references inside the subclasses list, which you would instantiate with Class.newInstance (or another suitable reflection method if your constructors have arguments).
Since Java17, there is the concept of sealed classes, were we know all the available subclasses: Class.isSealed()
Class.getPermittedSubclasses()
