Garder une trace de tous les objets d'une classe

Je suis nouveau dans la programmation orientée objet et je continue de rencontrer ce problème. (Je programme en Java) J'ai été un peu réticent à poser des questions à ce sujet, car il semble que ce soit un problème de base, mais je ne trouve aucune information à ce sujet, ou des questions à ce sujet ici, et aucune des les manuels que j'ai lus (à un niveau assez basique bien sûr) ont abordé cette question:

Souvent, je dois garder une trace de tous les objets d'une classe qui ont été créés, pour les parcourir à diverses fins. Comme j'écris actuellement des programmes, de nombreux objets sont uniquement référencés à partir d'autres objets, ce qui signifie que je n'ai pas de tableau ou de collection avec lequel les référencer tous.

J'imagine que, comme cela semble être une nécessité très fondamentale dans la POO, il devrait y avoir un moyen assez institutionnalisé et simple de procéder à ce sujet? Est-il habituel de conserver une liste séparée de tous les objets d'une classe?

J'ai pensé à un tableau ou à une collection statique, auquel à travers son constructeur, chaque nouvel objet créé serait ajouté. Cela ne fonctionnerait cependant pas avec les sous-classes, car les constructeurs ne sont pas hérités?

Je me rends compte que cette question pourrait ne pas avoir une réponse facile; J'espère juste que quelqu'un pourra m'éclairer un peu sur ce sujet. Je sens que si je manque ici d'un élément central de connaissances.

Je ne sais pas pourquoi vous devez conserver une liste de toutes les instances d'une classe.

Cela entraînerait une fuite de mémoire car ces objets ne seront jamais supprimés, car la liste les référencera toujours après aucune autre classe.

Mais si vous voulez vraiment suivre cette voie:

1. Utilisez le modèle Factory. Une classe d'usine avec des méthodes qui instancient la classe et renvoient les objets. De cette façon, vous disposez d'un point centralisé pour contrôler les instanciations.
2. Utilisez le modèle Singleton pour contenir une liste ou des listes contenant les instances.
3. Faites en sorte que l'usine place chaque objet d'un certain type dans une liste après les avoir créés.

Soit dit en passant: les constructeurs sont hérités.

Il convient de noter que les références faibles peuvent être utilisées en combinaison avec les autres solutions données pour permettre au garbage collector de disposer des objets suivis lorsqu'ils ne sont plus référencés ailleurs. Cela élimine les fuites de mémoire sans nécessiter de code ailleurs pour éliminer manuellement les objets, ou autrement prendre soin qu'ils soient suivis. Vous pouvez fournir un ReferenceQueue pour recevoir la notification des références aux objets qui ont été libérés.

J'ai pensé à un tableau ou à une collection statique, auquel à travers son constructeur, chaque nouvel objet créé serait ajouté. Cela ne fonctionnerait cependant pas avec les sous-classes, car les constructeurs ne sont pas hérités?

Les constructeurs des classes de base sont invoqués avant les constructeurs des classes dérivées. Chaque classe a au moins un constructeur et les constructeurs ne peuvent pas être remplacés.

Lors de la création de jeux, les gens veulent parfois une collection «autogérée» de chaque type d'objet de jeu.

Une implémentation ressemble à ceci:

public class Car {

    static ArrayList<Car> list = new ArrayList<Car>();

    public Car() {
        list.add(this);
    }

    void kill() {
        list.remove(this);
    }

    static public void updateAll()
    {
        for (int i = list.size() - 1; i >= 0; i--)
        {
                list.get(i).update();
        }
    }

    public void update()
    {
        //update logic
    }
}

De cette manière, les méthodes manipulant la collection peuvent être déclarées statiques tandis que les méthodes non statiques manipulent une instance (updateAll vs update).

Bien que très bien pour des scénarios très simples, avec une complexité même modérée, il est généralement préférable de créer des classes de gestionnaire distinctes.

Essayez de penser le contexte. Lorsque vous créez un objet, vous le faites dans un certain contexte. Par exemple, si votre jeu consiste à tirer sur des extraterrestres, votre application créera tout le temps de nouveaux objets extraterrestres. Ils seront affichés dans un champ appelé Espace (qui pourrait être la classe qui représente l'interface utilisateur principale).

Il est parfaitement naturel pour Space d'avoir une propriété nommée currentAliens, qui serait un tableau, auquel vous ajoutez chaque nouvel extraterrestre que vous créez. Si vous voulez permettre à votre utilisateur de déchirer le tissu de l'espace-temps et de détruire tous les extraterrestres à la fois, vous devez parcourir cette collection et détruire chaque objet.

Si vous vouliez avoir accès à cette collection d'étrangers à partir d'autres parties de votre application (par exemple, à partir d'une page Paramètres, où vous voudrez peut-être autoriser les utilisateurs à éliminer certains types d'étrangers d'un seul coup), votre contexte Paramètres serait doivent avoir accès à l'objet Space.