In fase di esecuzione, trova tutte le classi in un'applicazione Java che estendono una classe base

Voglio fare qualcosa del genere:

List<Animal> animals = new ArrayList<Animal>();

for( Class c: list_of_all_classes_available_to_my_app() )
   if (c is Animal)
      animals.add( new c() );

Quindi, voglio guardare tutte le classi nell'universo della mia applicazione e quando trovo una che discende da Animal, voglio creare un nuovo oggetto di quel tipo e aggiungerlo all'elenco. Questo mi permette di aggiungere funzionalità senza dover aggiornare un elenco di cose. Posso evitare quanto segue:

List<Animal> animals = new ArrayList<Animal>();
animals.add( new Dog() );
animals.add( new Cat() );
animals.add( new Donkey() );
...

Con l'approccio sopra, posso semplicemente creare una nuova classe che estende Animal e verrà raccolto automaticamente.

AGGIORNAMENTO: 16/10/2008 9:00 Pacific Standard Time:

Questa domanda ha generato molte risposte fantastiche - grazie. Dalle risposte e dalle mie ricerche, ho scoperto che ciò che voglio davvero fare non è possibile sotto Java. Ci sono approcci, come il meccanismo ServiceLoader di ddimitrov che può funzionare, ma sono molto pesanti per quello che voglio e credo di spostare semplicemente il problema dal codice Java a un file di configurazione esterno. Aggiornamento 5/10/19 (11 anni dopo!) Ora ci sono diverse librerie che possono aiutarti in questo secondo la risposta di @ IvanNik org.reflections sembra buono. Anche ClassGraph della risposta di @Luke Hutchison sembra interessante. Ci sono anche molte altre possibilità nelle risposte.

Un altro modo per affermare quello che voglio: una funzione statica nella mia classe Animal trova e crea un'istanza di tutte le classi che ereditano da Animal, senza ulteriori configurazioni / codifiche. Se devo configurare, potrei anche semplicemente istanziarli nella classe Animal. Lo capisco perché un programma Java è solo una federazione libera di file .class che è così.

È interessante notare che questo sembra abbastanza banale in C #.

Uso org.reflections :

Reflections reflections = new Reflections("com.mycompany");    
Set<Class<? extends MyInterface>> classes = reflections.getSubTypesOf(MyInterface.class);

Un altro esempio:

public static void main(String[] args) throws IllegalAccessException, InstantiationException {
    Reflections reflections = new Reflections("java.util");
    Set<Class<? extends List>> classes = reflections.getSubTypesOf(java.util.List.class);
    for (Class<? extends List> aClass : classes) {
        System.out.println(aClass.getName());
        if(aClass == ArrayList.class) {
            List list = aClass.newInstance();
            list.add("test");
            System.out.println(list.getClass().getName() + ": " + list.size());
        }
    }
}

Il modo Java per fare quello che vuoi è usare il meccanismo ServiceLoader .

Inoltre, molte persone riescono ad avere un file in una posizione del percorso di classe ben nota (ad esempio /META-INF/services/myplugin.properties) e quindi utilizzando ClassLoader.getResources () per enumerare tutti i file con questo nome da tutti i barattoli. Ciò consente a ciascun vaso di esportare i propri provider e puoi istanziarli riflettendo usando Class.forName ()

Pensaci da un punto di vista orientato all'aspetto; quello che vuoi fare, in realtà, è conoscere tutte le classi in fase di esecuzione che HANNO esteso la classe Animal. (Penso che sia una descrizione leggermente più accurata del tuo problema rispetto al tuo titolo; altrimenti, non penso che tu abbia una domanda di runtime.)

Quindi quello che penso tu voglia è creare un costruttore della tua classe di base (Animal) che aggiunga al tuo array statico (preferisco ArrayLists, io stesso, ma a ciascuno il loro) il tipo della Classe corrente che viene istanziata.

Quindi, approssimativamente;

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

Ovviamente, avrai bisogno di un costruttore statico su Animal per inizializzareDerivedClass ... Penso che questo farà quello che probabilmente vorrai. Si noti che questo dipende dal percorso di esecuzione; se hai una classe Cane che deriva da un animale che non viene mai invocato, non la avrai nell'elenco dei tuoi animali.

Sfortunatamente questo non è del tutto possibile poiché ClassLoader non ti dirà quali classi sono disponibili. Tuttavia, puoi avvicinarti abbastanza facendo qualcosa del genere:

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
            }
        }
    }
}

Modifica: johnstok ha ragione (nei commenti) che funziona solo con applicazioni Java standalone e non funziona con un server applicazioni.

È possibile utilizzare ResolverUtil ( sorgente non elaborata ) da Stripes Framework
se è necessario qualcosa di semplice e rapido senza refactoring di alcun codice esistente.

Ecco un semplice esempio che non ha caricato nessuna delle classi:

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 {}

Funziona anche in un application server poiché è lì che è stato progettato per funzionare;)

Il codice sostanzialmente fa quanto segue:

• iterare su tutte le risorse nei pacchetti specificati
• mantenere solo le risorse che terminano in .class
• Carica quelle classi usando ClassLoader#loadClass(String fullyQualifiedName)
• Controlla se Animal.class.isAssignableFrom(loadedClass);

Il meccanismo più robusto per elencare tutte le sottoclassi di una determinata classe è attualmente ClassGraph , poiché gestisce la più ampia gamma possibile di meccanismi di specifica del percorso di classe , incluso il nuovo sistema di moduli JPMS. (Sono l'autore.)

List<Class<Animal>> animals;
try (ScanResult scanResult = new ClassGraph().whitelistPackages("com.zoo.animals")
        .enableClassInfo().scan()) {
    animals = scanResult
        .getSubclasses(Animal.class.getName())
        .loadClasses(Animal.class);
}

Java carica dinamicamente le classi, quindi il tuo universo di classi sarebbe solo quello che è già stato caricato (e non ancora scaricato). Forse puoi fare qualcosa con un caricatore di classi personalizzato che potrebbe controllare i supertipi di ogni classe caricata. Non credo che ci sia un'API per interrogare l'insieme di classi caricate.

Usa questo

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);

Modificare:

• libreria per (ResolverUtil): Stripes

Grazie a tutti coloro che hanno risposto a questa domanda.

Sembra che questo sia davvero un dado difficile da decifrare. Ho finito per rinunciare e creare un array statico e getter nella mia 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;
    }
}

Sembra che Java non sia impostato per l'auto-scoperta come C #. Suppongo che il problema sia che, dal momento che un'app Java è solo una raccolta di file .class in un file directory / jar da qualche parte, il runtime non conosce una classe fino a quando non viene referenziato. In quel momento il caricatore lo carica - quello che sto cercando di fare è scoprirlo prima di fare riferimento a ciò che non è possibile senza uscire dal file system e guardare.

Mi piace sempre il codice che può scoprire se stesso invece che doverlo raccontare su se stesso, ma purtroppo funziona anche questo.

Grazie ancora!

Utilizzando OpenPojo è possibile effettuare le seguenti operazioni:

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));
}

Questo è un problema difficile e dovrai scoprire queste informazioni usando l'analisi statica, che non è facilmente disponibile in fase di esecuzione. Fondamentalmente ottieni il percorso di classe della tua app ed esegui la scansione delle classi disponibili e leggi le informazioni sul bytecode di una classe da cui eredita la classe. Nota che un cane di classe non può ereditare direttamente dall'animale ma può ereditare dall'animale che a sua volta eredita dall'animale, quindi dovrai tenere traccia di quella gerarchia.

Un modo è fare in modo che le classi utilizzino un inizializzatore statico ... Non penso che queste siano ereditate (non funzionerà se lo sono):

public class Dog extends Animal{

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

È necessario aggiungere questo codice a tutte le classi coinvolte. Ma evita di avere un grosso brutto giro da qualche parte, testando ogni classe alla ricerca di bambini di animali.

Ho risolto questo problema in modo abbastanza elegante usando le annotazioni a livello di pacchetto e quindi facendo di quell'annotazione come argomento un elenco di classi.

Trova le classi Java che implementano un'interfaccia

Le implementazioni devono solo creare un pacchetto-info.java e inserire l'annotazione magica con l'elenco delle classi che vogliono supportare.