En tiempo de ejecución, busque todas las clases en una aplicación Java que amplíen una clase base

La forma Java de hacer lo que quieres es usar el mecanismo ServiceLoader.

También muchas personas ruedan su propio archivo al tener un archivo en una ubicación de classpath bien conocida (es decir, /META-INF/services/myplugin.propiedades) y luego usando ClassLoader.getResources () para enumerar todos los archivos con este nombre de todos los jars. Esto permite que cada jar exporte sus propios proveedores y puede instanciarlos mediante reflexión utilizando Class.forName ()

Piense en esto desde un punto de vista orientado a aspectos; lo que realmente quiere hacer es conocer todas las clases en tiempo de ejecución que han extendido la clase Animal. (Creo que esa es una descripción un poco más precisa de su problema que su título; de lo contrario, no creo que tenga una pregunta de tiempo de ejecución.)

Así que lo que creo que desea es crear un constructor de su clase base (Animal) que se suma a su matriz estática (prefiero ArrayLists, yo mismo, pero a cada uno su propio) el tipo de la clase actual que está siendo instanciada.

Así que, aproximadamente;

public abstract class Animal
    {
    private static ArrayList<Class> instantiatedDerivedTypes;
    public Animal() {
        Class derivedClass = this.getClass();
        if (!instantiatedDerivedClass.contains(derivedClass)) {
            instantiatedDerivedClass.Add(derivedClass);
        }
    }

Por supuesto, necesitarás un constructor estático en Animal para inicializar instantiatedDerivedClass... Creo que esto hará lo que probablemente quieras. Tenga en cuenta que esto depende de la ruta de ejecución; si tiene una clase Dog que deriva de Animal que nunca se invoca, no la tendrá en su lista de clases Animal.

Desafortunadamente esto no es del todo posible ya que el ClassLoader no le dirá qué clases están disponibles. Sin embargo, puedes acercarte bastante haciendo algo como esto:

for (String classpathEntry : System.getProperty("java.class.path").split(System.getProperty("path.separator"))) {
    if (classpathEntry.endsWith(".jar")) {
        File jar = new File(classpathEntry);

        JarInputStream is = new JarInputStream(new FileInputStream(jar));

        JarEntry entry;
        while( (entry = is.getNextJarEntry()) != null) {
            if(entry.getName().endsWith(".class")) {
                // Class.forName(entry.getName()) and check
                //   for implementation of the interface
            }
        }
    }
}

Edit: johnstok es correcto (en los comentarios) que esto solo funciona para aplicaciones Java independientes, y no funcionará bajo un servidor de aplicaciones.

Puedes usar ResolverUtil (fuente cruda ) del Marco de Franjas
si necesita algo simple y rápido sin refactorizar ningún código existente.

Aquí hay un ejemplo simple de no haber cargado ninguna de las clases:

package test;

import java.util.Set;
import net.sourceforge.stripes.util.ResolverUtil;

public class BaseClassTest {
    public static void main(String[] args) throws Exception {
        ResolverUtil<Animal> resolver = new ResolverUtil<Animal>();
        resolver.findImplementations(Animal.class, "test");
        Set<Class<? extends Animal>> classes = resolver.getClasses();

        for (Class<? extends Animal> clazz : classes) {
            System.out.println(clazz);
        }
    }
}

class Animal {}
class Dog extends Animal {}
class Cat extends Animal {}
class Donkey extends Animal {}

Esto también funciona en un servidor de aplicaciones, ya que es donde fue diseñado para funcionar;)

El código básicamente hace lo siguiente:

• iterar sobre todos los recursos en el paquete(s) usted especifica
• mantenga solo los recursos que terminan en .clase
• Cargue esas clases usando ClassLoader#loadClass(String fullyQualifiedName)
• Comprueba si Animal.class.isAssignableFrom(loadedClass);

Java carga clases dinámicamente, por lo que su universo de clases serían solo aquellas que ya se han cargado (y aún no se han descargado). Tal vez pueda hacer algo con un cargador de clases personalizado que pueda verificar los supertipos de cada clase cargada. No creo que haya una API para consultar el conjunto de clases cargadas.

Gracias a todos los que respondieron a esta pregunta.

Parece que este es un hueso duro de roer. Terminé renunciando y creando una matriz estática y getter en mi clase base.

public abstract class Animal{
    private static Animal[] animals= null;
    public static Animal[] getAnimals(){
        if (animals==null){
            animals = new Animal[]{
                new Dog(),
                new Cat(),
                new Lion()
            };
        }
        return animals;
    }
}

Parece que Java simplemente no está configurado para la auto-descubribilidad de la manera en que C# es. Supongo que el problema es que desde una aplicación Java es solo una colección de .archivos de clase en un archivo de directorio / jar en algún lugar, el tiempo de ejecución no conoce una clase hasta que se hace referencia a ella. En ese momento el cargador carga lo que estoy tratando de hacer es descubrirlo antes de referenciarlo, lo cual no es posible sin ir al sistema de archivos y mirar.

Siempre me gusta el código que puede descubrirse a sí mismo en lugar de tener que contarlo sobre sí mismo, pero por desgracia esto también funciona.

Gracias de nuevo!

Usando OpenPojo puedes hacer lo siguiente:

String package = "com.mycompany";
List<Animal> animals = new ArrayList<Animal>();

for(PojoClass pojoClass : PojoClassFactory.enumerateClassesByExtendingType(package, Animal.class, null) {
  animals.add((Animal) InstanceFactory.getInstance(pojoClass));
}

Usa esto

public static Set<Class> getExtendedClasses(Class superClass)
{
    try
    {
        ResolverUtil resolver = new ResolverUtil();
        resolver.findImplementations(superClass, superClass.getPackage().getName());
        return resolver.getClasses();  
    }
    catch(Exception e)
    {Log.d("Log:", " Err: getExtendedClasses() ");}

    return null;
}

getExtendedClasses(Animals.class);

Editar:

• biblioteca para (ResolverUtil): Rayas

Intenta ClassGraph. (Descargo de responsabilidad, soy el autor). Para el ejemplo dado, el código ClassGraph sería:

List<Animal> animals =
    new ClassGraph()
        .whitelistPackages("com.zoo.animals")
        .enableAllInfo()
        .scan()
        .getSubclasses(Animal.class.getName())
        .loadClasses(Animal.class);

ClassGraph puede hacer mucho más que esto también {echa un vistazo a la API .

Este es un problema difícil y tendrá que encontrar esta información utilizando análisis estático, no está disponible fácilmente en tiempo de ejecución. Básicamente, obtenga el classpath de su aplicación y escanee las clases disponibles y lea la información de código de bytes de una clase de la que hereda. Tenga en cuenta que un Perro de clase no puede heredar directamente de Animal,pero podría heredar de Mascota que es a su vez hereda de Animal, por lo que tendrá que realizar un seguimiento de esa jerarquía.

Una forma es hacer que las clases usen inicializadores estáticos... No creo que estos sean heredados (no funcionará si lo son):

public class Dog extends Animal{

static
{
   Animal a = new Dog();
   //add a to the List
}

Requiere que agregue este código a todas las clases involucradas. Pero evita tener un gran bucle feo en algún lugar, probando cada clase en busca de hijos de Animales.

Resolví este problema con bastante elegancia usando Anotaciones a nivel de paquete y luego haciendo que la anotación tenga como argumento una lista de clases.

Buscar clases Java implementando una interfaz

Las implementaciones solo tienen que crear un paquete-info.java y poner la anotación mágica en la lista de clases que quieren apoyar.