Comment utiliser à bon escient les attributs statiques et gérer la destruction des objets.

Nous allons travailler avec des moutons. Un mouton est blanc ou noir. Lorsqu'un mouton nait, il y a une chance sur deux pour qu'il soit blanc et une chance sur deux pour qu'il soit noir. Pour simplifier, on considère qu'après avoir créé un mouton blanc, on créera forcément un mouton noir.

L'objectif est de connaitre à un instant t le nombre total de moutons créés et le nombre total de moutons encore vivants. Un mouton peut être créé ou détruit à n'importe quel moment du programme.

La classe Mouton s'impose en tant que concept. L'idée est de réaliser une classe Troupeau à qui on va déléguer la gestion des moutons. En voici la première version, rien d'extraordinaire:

 +----------------------------+                 +----------------------+
 |          Mouton            |                 |      Programme       |
 +----------------------------+                 +----------------------+
 |-nom: String                |1..1           * |- nbMoutonsActuel: int|   
 |-couleur: String            |-----------------|- nbMoutonsTotal : int|
 |----------------------------|                 +----------------------+
 |+ String donneNom()         |                 |+ajouteMouton()       |
 |+ String donneCouleur()     |                 |+supprimeMouton()     |
 |+ Mouton(String c, String n)|                 |+supprimeMouton(int i)|
 |+ afficheInfos()            | //nom + couleur |+afficheStatut()      | //information sur le nombre de moutons
 +----------------------------+                 +----------------------+

Les objets Mouton seraient gérés par un tableau dynamique (ArrayList par exemple) dans la classe Programme.

Réalisez l'implémentation de ce modèle. Qu'en pensez-vous?

On est obligé d'utiliser une autre classe pour gérer les moutons (troupeau). Si on décide de créer un mouton sans passer par la classe programme, alors le nombre total de moutons devient faux, la couleur n'est pas forcement la bonne, etc.

Il faudrait arriver à contraindre encore plus la création des moutons: dès qu'un mouton est créé, n'importe où, il doit pouvoir mettre à jour nbMoutonsActuel et nbMoutonsTotal, et pouvoir décider quelle est la couleur à utiliser.

Cette solution ne répond donc pas au problème posé.

L'idée est cette fois-ci d'utiliser des attributs de classe pour gérer les moutons.

Un attribut de classe concerne l'ensemble de la classe. Il est accessible et partagé par tous les objets de la classe et n'est stocké qu'une fois en mémoire.

En java, on définit un attribut ou une méthode de classe en utilisant le mot-clef “static”. En UML, on souligne l'attribut ou la méthode.

Voici donc notre nouveau modèle modifié, il ne contient plus qu'une seule classe:

 +----------------------------+
 |          Mouton            |
 +----------------------------+
 |S- nbMoutonsActuel: int     | // Variables de classe
 |S- nbMoutonsTotal : int     |
 |-nom: String                |
 |-couleur: String            |
 |----------------------------|
 |+ String donneNom()         |
 |+ String donneCouleur()     |
 |+ Mouton(String n)          |
 |+ afficheInfo()             |
 |S+ afficheStatut            | //méthode de classe
 +----------------------------+

Notez au passage que le constructeur Mouton(String n) n'a plus besoin qu'on lui passe la couleur dont il doit se servir pour créer un mouton: il peut la déduire de la parité de nbMoutonTotal.

public class Mouton
{
	//Attributs
	private static int nbMoutonsCrees = 0; //nombre de moutons crées depuis le lancement du programme
	private static int nbMoutons = 0; //nombre de moutons actuel
	private String couleur = "Noir";
	private String nom;
 
	//constructeur
	public Mouton()
	{
		/*
		* si le nombre de moutons est pair, le nouveau mouton est blanc
		* sinon, il est noir
		*/
		nom = "Mouton " + nbMoutonsCrees;
		if (nbMoutonsCrees % 2 ==0) // l'opérateur % donne le reste de la division euclidienne
		{
			couleur = "Blanc";
		}
 
		//j'augmente mon nombre de moutons. Les deux écritures suivantes sont équivalentes (n++ ou n= n+1)
		nbMoutons++;
		nbMoutonsCrees = nbMoutonsCrees + 1;
		afficheInfo();
	}
 
	//méthodes d'accès
	public String donneNom(){return nom;}
	public String donneCouleur(){return couleur;}
	/*
        * Pourquoi les deux méthodes d'accès suivantes doivent-elles être statiques?
        * Sauriez-vous trouver la réponse sans regarder plus bas?
        */
	public static int donneNbMoutons(){return nbMoutons;}
	public static int donneNbMoutonsCrees(){return nbMoutonsCrees;}
 
	//méthodes
        /*
        * Cette méthode doit-elle nécessairement être statique?
        * Pourquoi est-elle privée?
        */
	private static void enleveMouton(int nbM)
	{
		nbMoutons = nbMoutons - nbM;
	}
 
        // Pourquoi cette méthode doit-elle être statique?
	public static void afficheStatut()
	{
		System.out.println("Il y a maintenant " + nbMoutons + " moutons.");
		System.out.println("Nous avons créé en tout " + nbMoutonsCrees + " moutons.");
	}
 
        // Pourquoi cette méthode n'est pas statique?
	public void afficheInfo()
	{
		System.out.println("Ce mouton s'appelle " + nom + " et il est " + couleur);
	}
}

Intéressons-nous maintenant à ce qui se passe lorsqu'on supprime un mouton.

En java, tout objet hérite de la classe Object (voir la doc en ligne sur cette classe).

La méthode finalize est appellée lors de la destruction d'un objet. Donc si je veux intervenir lors de la destruction d'un objet, je dois redéfinir la méthode finalize, ajouter le code que je veux exécuter, et finir en n'oubliant pas d'appeler en dernière instruction super.finalize() pour bien détruire l'objet. C'est parti:

        /*
	* Je redéfinie la méthode finalize dans la classe Mouton pour pouvoir gérer le nombre de moutons
	* de mon application: chaque fois que la méthode est appellée, ça retire automatiquement un mouton.
	*
	* La méthode finalize de la classe Object peut générer une exception "Throwable".
	* Je ne souhaite pas gérer cette exception dans la méthode suivante, c'est pourquoi je rajoute la clause
	* "throws" + "Nom de l'exception".
	* en gros, je demande à ceux qui vont utiliser la méthode finalize de Mouton de gérer les erreurs possibles 
	* (je me débarrasse du problème dans l'immédiat ;-), tout en sachant qu'il faudra à un moment faire un bloc 
	* Try-catch quand même!).
	* Cette technique est utile pour permettre de laisser aux utilisateurs d'une méthode qu'on a créée le soin de 
	* gérer les erreurs dans leur propre programme.
	*/
	public void finalize() throws Throwable
	{
		//on enlève un mouton:
		Mouton.enleveMouton(1);
		//appel de la méthode finalize
		super.finalize();
	}

On termine maintenant par le programme principal:

	//Programme principal
	public static void main(String arguments[])
	{
		/*
                * on affiche le statut
                * aurait-on pu faire cela si afficheStatut n'était pas statique?
                * voilà un exemple qui illustre pourquoi certaines méthodes doivent être statiques et d'autres non
                */
		Mouton.afficheStatut();
 
		//on commence à créer 2-3 bestioles:
		Mouton m1 = new Mouton();
		Mouton m2 = new Mouton();
		Mouton m3 = new Mouton();
 
		// La méthode finalize peut générer une erreur, on l'encadre donc avec un bloc try, et on attrape 
	 	// l'erreur pour la gérer si elle arrive dans le bloc catch
		try
		{
			m3.finalize();
			System.out.println("Mouton détruit!");
		}
		catch (Throwable t)
		{
			System.out.println("Erreur lors de la destruction du mouton!");
			t.printStackTrace(); // pour afficher la pile d'appels
		}
		m3 = null;
		Mouton.afficheStatut();
 
		//on continue avec quelques autres moutons:
		m3 = new Mouton();
		Mouton m4 = new Mouton();
		Mouton.afficheStatut();
 
		//etc.....
 
	}
}

• Quelles classes de l'API que vous connaissez utilisent cette technique? Regardez Math, Color, BordeLayout…
• Lorsqu'une classe doit partager un attribut constant (par exemple Pi, North, Red), on peut utiliser une variable de classe constante avec le mot-clef final:

	public static final double Pi = 3.141592;

• Vous souvenez-vous du ramasse-miette (garbage collector)? C'est le composant de java qui lors de l'exécution est chargé de libérer les zones mémoires qui ne servent plus, lorsqu'un objet a été détruit par exemple. Pour accélérer son passage après l'appel du destructeur finalize, on peut faire pointer l'objet sur null:

	Mouton monMouton = new Mouton();
	monMouton.finalize();
	monMouton = null;

• Notre programme est-il parfait? Pas sûr! Observez le code suivant que vous pouvez ajouter à la méthode main:

	//Pour planter le programme...
	Mouton m5 = m4;
	try
	{
		m5.finalize();
		m5 = null;
	}
	catch(Throwable t)
	{
		System.out.println("Erreur lors de la destruction du mouton!");
		t.printStackTrace(); // pour afficher la pile d'appels	
	}
	m4.afficheInfo();
	Mouton.afficheStatut();
	m4= null;

Que se passe-t-il? Pourquoi?

Auriez-vous une solution à proposer pour éviter ce genre de problème? Est-ce possible simplement?