Composition aggregation java

Bonjour,

j'ai un tp a faire est on me demande de faire des compositions et agrégations.
Je comprend bien que la composition signifie que si on détruit le "composé", le "composant" est détruit aussi.

J'ai une Machine avec les attributs:
idMachine - son identifiant (int)
nomMachine - son nom (String)
dateAchat - sa date d'achat (GregorianCalendar)
dateFinGarantie - sa date de fin de garantie (GregorianCalendar)

qui est composé de:

• 1 processeur (class Processeur) --> composition
• 1-n Disque Dur (ArrayList<DisqueDur>) --> composition
• 1-n barrette de RAM (ArrayList<Ram>) --> composition
• 1-n Ecran (ArrayList<Ecran>) --> Agrégation

Je voudrais savoir comment définir mon constructeur Machine.

Code:

---

1 2 3 4

public Machine(int idMachine, String nomMachine, GregorianCalendar dateAchat, GregorianCalendar dateFinGarantie, Processeur processeur,ArrayList<DisqueDur> aListDisqueDur,ArrayList<RAM> aListRam){

---

cette syntaxe est elle correcte? Sommes nous obliger d'avoir les ArrayList dans le constructeur?

En fait ma question est, pour être cohérent avec la composition, peut-on passé par des objets "temporaire" tel que

Code:

---

1 2 3 4

Processeur p1 = new Processeur(marqueProcesseur,modeleProcesseur, numSerieProcesseur); Machine m1=new Machine(1,"MonPc",aujourdhui,finGarantie,p1);

---

ou faut-il obligatoirement passer par ce genre d'appel?:koi:

Code:

---

1 2 3

Machine m1=new Machine(1,"MonPc",aujourdhui,finGarantie, new Processeur(marqueProcesseur,modeleProcesseur,numSerieProcesseur));

---

Vu que c'est un tp, j'ai vu des tas de choses différentes chez les membres de mon groupe. Je ne sais pas qui a tord ou raison, et vu que les formateurs ne sont pas d'un grand secours:kill:, je me tourne vers les forums, qui je pense seront surement d'une meilleure aide.:ave:

Donc j'attends vos conseils, merci d'avance.

Bonjour, ton constructeur est correct, cependant, tu devrais remplacer GregorianCalendar par Calendar et ArrayList par List pour être moins restrictif dans les paramètres.

Les 2 derniers code sont strictement identiques mis à part la variable temporaire. Par contre, la 1ère solution est beaucoup plus lisible et rend donc le code plus facile à maintenir.
L'évolutivité et la maintenance ne sont sûrement pas les 1ers objectifs des exercices, mais autant s'y préparer pour le monde professionnel, ce sera apprécié.

Merci CheryBen pour le conseil de lisibilité.:ccool:

Je trouve aussi que cela est beaucoup plus lisible, vu que je vais devoir faire un constructeur comprenant les infos de la machine, un processeur, un disque dur, un barrette de ram et un écran.
Donc lors de l'instanciation de machine cela fera au minimum 4 lignes pour une seule instruction si je ne passe pas par des variables temporaires.

Mais concernant la "composition" ces variables temporaires ne posent-elles pas de problème? vu que si je détruis la machine, les composants seront toujours existants.

Ou faut-il faire un truc du style:

Code:

---

1 2 3 4 5 6

Processeur p1 = new Processeur(1, "Marque proc","modele proc"); DisqueDur d1=new DisqueDur(1,"Marque Disque Dur","Modele DisqueDur", "Capacité Disque Dur"); Machine m1=new Machine(1,"nom Machine",p1,d1); p1=null; d1=null;

---

Afin d'être sur que p1 et d1 pointent vers rien.
Je cherche juste a savoir quelle est la technique la plus "professionnelle". Parce que je trouve que

Code:

---

1 2	p1=null; d1=null;

---

ça fait bidouille.


Merci.

Surtout cela ne libèrera pas la mémoire prise par p1 et d1 :P

Dans ton constructeur de Machine, j'imagine que tu auras ceci :

Code:

---

1 2	this.processeur = p1; this.disqueDur = d1;

---

En faisant ça, on créé une référence (processeur) vers l'objet p1 et une référence (disqueDur) vers d1.

Ensuite dans ta fonction qui précédente qui a appelé le constructeur, si tu fais d1 = null et p1 = null, tu mets simplement tes variables locales à null (tes références locales) mais les objets pointés par d1 et p1 ne seront pas détruits car référencés dans Machine.


Deuxièmement, tu déclares les variables m1, d1 et p1 dans la même fonction. Elles ont donc la même portée, et seront effaçables (et non pas effacées) par la garbage collector en même temps. Il est donc inutil de mettre à null des variables, par contre il vaut mieux en limiter la portée.

Tout a fait d'accord avec toi:)
En faisant pointer p1 et d1 vers null, je ne détruit pas les objets qui sont toujours référencés par l'objet m1 (m1.listDisqueDur et m1.processeur). C'est bien ce qui m'est demandé (je crois, comme je l'ai dit les formateurs ne sont pas très clairs).

C'est vrai aussi que m1, p1 et d1 sont instanciés dans la même fonction, donc elle auront la même portée.

Après tout ça, je dois faire une interface vers une base de données Oracle.

Je pense que les "problèmes" de portées auront disparu une fois que j'aurais fait cette interface (bien que je ne vois pas, maintenant, comment l'utiliser du coté métier).

En tout cas, encore merci, de m'avoir accordé un peu de temps.:bravo: