Des objets qui communiquent

Cet exercice permet d'apercevoir comment on peut faire communiquer des objets. Tout l'exercice est facile, pourtant l'expérience montre que faire communiquer les objets est une difficulté pour les débutants avec un langage objet.

Partage d'un même objet

Il s'agit de faire en sorte que deux classes partagent un même objet ; ce genre de situation se produit tout le temps lorsqu'on travaille avec un langage objet.
On définit ici quatre classes très simples.
On précise qu'un attribut privé (ce qui est indiqué avec le mot private précédant sa déclaration) ne peut être accédé directement que du code de sa propre classe. Si on veut qu'un attribut privé soit accessible d'une autre classe, il faut définir une méthode qui retourne la valeur de cet attribut ; si on veut qu'un attribut privé puisse être modifié à partir d'une autre classe, il faut prévoir une méthode qui effectue cette modification ; de telles méthodes s'appellent des accesseurs. Dans une application plus complète, on définirait sans doute des accesseurs supplémentaires pour gérer les attributs privés des classes Gadget, A et B.

La classe Gadget contient :
- un attribut privé nommé valeur de type int,
- une méthode d'en tête
  public String toString()
  qui retourne la chaîne de caractères "valeur du gadget : " concaténée avec la chaîne de caractères donnant valeur.
- une méthode incrementer qui admet un paramètre de type int et incrémente l'attribut nommé valeur de la quantité indiquée par le paramètre.

La classe A est :

class A
{
    private Gadget gadget = new Gadget();
    private int entier;

    Gadget getGadget()
    {
	return gadget;
    }

    public String toString()
    {
	return "Instance de A, " + " entier = " + entier + ", "+ gadget;
    }
}

On rappelle qu'ainsi, dans la méthode toString, gadget est traduit en gadget.toString().

La classe B contient :
- un attribut privé de type Gadget, non initialisé au moment de sa définition (contrairement à celui de la classe A), nommé gadget ;
- un attribut privé de type int nommé entier ;
- une méthode to String identique à celle de la classe A, au nom de la classe près ;
- un constructeur ayant un paramètre de type Gadget servant à initialiser son attribut gadget ;
- une méthode incrementer ayant deux paramètres de type int ; cette méthode incrémente l'attribut entier de la valeur de son premier paramètre et incrémente l'attribut valeur de gadget de la valeur de son second paramètre.
La classe EssaiAB contient uniquement une méthode main ; cette méthode :
- définit et initialise une variable locale a de type A ;
- définit et initialise une variable locale b de type B en faisant en sorte que l'attribut gadget de b soit égal à l'attribut gadget de a ;
- puis son code est
```
	System.out.println(a);
	System.out.println(b);
	b.incrementer(5, 10);
	System.out.println("Après incrémentation : ");
	System.out.println(a);
	System.out.println(b);
```

Les classes A et B partagent un même objet de type Gadget ; deux objets peuvent de même partager un même tableau : il est possible de partager un objet ou un tableau car ils sont man,ipulés par référence, mais il n'est pas possible de partager un attribut de type primitif.

Un exemple d'exécution
Pour la commande java EssaiAB, on obtient :

Instance de A,  entier = 0, valeur du gadget = 0
Instance de B,  entier = 0, valeur du gadget = 0
Après incrémentation : 
Instance de A,  entier = 0, valeur du gadget = 10
Instance de B,  entier = 5, valeur du gadget = 10

Corrigé qui contient les quatre classes.

Un objet qui construit un objet qui le connaît

Cet exercice est encore assez formel, et ne sert qu'à s'entraîner à faire communiquer des objets.
On définit trois classes très simples.

La classe Outil possède :
- un attribut privé de type Bricoleur (classe décrite ci-dessous) nommé b ;
- un attribut privé de type int nommé puissance ;
- un constructeur qui sert à initialiser les deux attributs :
```
    Outil(Bricoleur _b, int _puissance)
    {
	b = _b;
	puissance = _puissance;
    }
```
- une méthode nommée faire sans paramètre ; cette méthode élève l'attribut taille de b à la la puissance correspondant à son attribut nommé puissance et retourne la valeur du résultat ;
La classe Bricoleur possède :
- un attribut privé de type int nommé taille ;
- un attribut privé de type Outil nommé outil ;
- un constructeur ayant deux paramètres de type int ; le premier paramètre sert à initialiser l'attribut taille ; le second paramètre est utilisé dans la construction d'un objet de type outil initialisant l'attribut nommé outil; il faut faire en sorte que dans l'objet outil construit, le paramètre b soit l'instance de la classe Bricoleur que l'on est en train de décrire ;
- un accesseur qui retourne la valeur de taille ; une méthode nommée bricoler :
```
    void bricoler()
    {
	System.out.println(outil.faire());
    }
```

La classe EssaiBricoleur contient uniquement une méthode main ; cette méthode est :

    public static void main(String[] arg)
    {
	new Bricoleur(Integer.parseInt(arg[0]), Integer.parseInt(arg[1])).bricoler(); 
    }

Corrigé qui contient les trois classes.

Deux instances qui se connaissent

On définit ici deux classes.

La classe Personne contient :
- un attribut privé de type String nommé nom ;
- un attribut privé de type Personne nommé ami ;
- un constructeur ayant un paramètre de type String servant à initialiser l'attribut nom ;
- un constructeur ayant deux paramètres, un de type String et un de type Personne, servant à initialiser les attribut nom et ami ;
- un accesseur en lecture pour l'attribut ami qui retourne la valeur de cet attribut ;
- un accessseur en écriture pour l'attribut ami qui sert à changer la valeur de cet attribut ;
- une méthode d'en tête public String toString() qui retourne une chaîne de caractères donnant nom et, si ami vaut null, le fait qu'il n'y a pas d'ami, ou bien le nom de ami.
La classe EssaiAmi contient uniquement une méthode main ; cette méthode possède trois variables locales de type Personne, nommée personneSeule, ami1 et ami2 ; elle doit faire en sorte que ami1 soit l'ami de ami2 et vice-versa. Les noms de la personne seule et des amis sont donnés par la ligne de commande. On utilisera les instructions System.out.println(personneSeule); System.out.println(ami1); et System.out.println(ami2); pour tester la classe Personne

Un exemple d'exécution
Pour la commande java EssaiAmis Marie Olivier Antoine, on obtient par exemple :

Marie n'a pas d'ami
Olivier a pour ami Antoine
Antoine a pour ami Olivier

Corrigé qui contient les deux classes.