Discussion :

[AntoineCompagnie]

Bonjour!

je suis en pleine révision de java et j'ai énormément de mal:

J'ai un code qui modélise la gestion des personnels d'une société ainsi que l’ensemble de ses sites (il sont répartis en deux groupes : sites de production et sites de vente). La classe Personnels décrit un employé et ses éléments de rémunération : la classe interne ElementSalaire contient le salaire de base et les primes de l’employé, la classe interne HistoriqueServices contient les emplois successifs occupés par l’employé. A chaque site est associé un type de prime (ex. prime de résultat pour un site de vente). La classe Site regroupe un ensemble de méthodes permettant la gestion du personnel : ajoutPersonnel(p), suppressionPersonnel(p) réalisent l’ajout, la suppression du personnel p au site courant, tranfertPersonnel(p,ns) réalise le transfert du personnel p du site courant vers le site ns. Le conteneur listePersonnels contient l’ensemble des personnels associés à un site.

Je n'arrive pas à savoir comment on choisit l'un ou l'autre des Primes de Résultats ou des Primes d'ancienneté,
plus précisément je ne comprends pas le résultat d'affichage des primes dans le résultat.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
 
import java.util.*;
interface PersonnelsStandard{
    List historique();
    void ajoutHistorique(Sites s);
    	}
    public class TestPersonnelsv1 {
    public static void main(String[] args) {
    	Personnels p1=new Personnels(101,"Dupont","Paris",2000,2);
    	Personnels p2=new Personnels(102,"Martin","Lyon",2500,10);
    	Sites siteVente1= new SiteVente("Paris");
    	Sites siteVente2= new SiteVente("Lyon");
    	Sites siteProd1= new SiteProduction("Lille");
    	siteVente1.ajoutPersonnel(p1);
    	siteVente1.ajoutPersonnel(p2);
    	System.out.println(p1);
    	System.out.println(p2);
    	siteVente1.transfertPersonnel(p1,siteVente2);
    	siteVente1.transfertPersonnel(p2,siteProd1);
    	System.out.println(p1);
    	System.out.println(p2);
    	}
    }
class Personnels implements Comparable, PersonnelsStandard{
    	int no;
    	int anciennete;
    	String nom;
    	String adresse;
    	ElementsSalaire es;
    	HistoriqueServices histo;
    	Personnels(int no,String n,String a, int base,int anc){
    		this.no=no; à compléter
    	}
    	public String toString(){
    		return no + " " + nom + " " + " base "+ es.salaireBase+" Primes " + es.primes + " sal. Total "+es.salaireTotal()+
    	" Histo Serv. "+historique();
    	}
    	public List historique(){
    	return histo.services;}
    	public void ajoutHistorique(Sites s){histo.services.add(s);}
    	public void ajoutPrime(String pr){
    		if (pr=="PA") {es.primes.add(es.new PrimeAnciennete(this));}
    		if (pr=="PR") {es.primes.add(es.new PrimeResultat(this));}
    	}
    	public void suppressionPrime(String pr){
    		à compléter
    	}
    	public int compareTo(Object o){
    		return(no-((Personnels)o).no);
    	}
 
private class ElementsSalaire{
    	int salaireBase;
    	List primes;
    	ElementsSalaire(int  b){salaireBase=b;primes= new ArrayList();}
    	int salaireTotal(){
    	int x=0;
    	for (int i=0;i<primes.size();i++)x=x+((Prime)(primes.get(i))).montant;
    	return salaireBase+x;}
 
class PrimeAnciennete extends Prime{ 
	PrimeAnciennete(Personnels p){
	super(p);type="PA";calculPrime();
	}
 
void calculPrime(){
	montant=(int)(p.es.salaireBase*anciennete*0.02);
	}
 
public String toString(){return "PA= "+montant;}
}
class PrimeResultat extends Prime{ PrimeResultat(Personnels p){
super(p);type="PR";calculPrime();
}
void calculPrime(){
	montant=(int) (p.es.salaireBase*0.05);
}
public String toString(){
	return type+" "+montant;}
}
}
class HistoriqueServices{
	List services;
	HistoriqueServices(){services= new ArrayList();}
	}
}
 
abstract class Prime implements Comparable{
	Personnels p;
	int montant; String type;
	static List L=new ArrayList(); Prime(Personnels p){this.p=p;L.add(this);}
	abstract void calculPrime();
	public String toString(){return type;}
	public int compareTo(Object o){return montant - ((Prime)o).montant;}
}
 
/*****************************************SITES************************************************/
abstract class Sites{ String localisation; String refSite;Set listePesrsonnels;}
 
Sites(){	à compléter	}
 
void transfertPersonnel(Personnels p, Sites ns){
	ns.ajoutPersonnel(p);
	suppressionPersonnel(p);
}
 
void affectationPersonnel(Personnels p){
	ajoutPersonnel(p);
}
 
void ajoutPersonnel(Personnels p){
	listePesrsonnels.add(p);
	p.ajoutHistorique(this);
}
 
void suppressionPersonnel(Personnels p){
	listePesrsonnels.remove(p);
}
 
static Set listePersonnelsSSPrime(){
	à compléter
}
 
}
class SiteProduction extends Sites{
	int capaciteProduction;
	SiteProduction(String l){localisation = l; capaciteProduction = 1000;} public String toString(){return "Site Prod. " + localisation;}
 
void ajoutPersonnel(Personnels p){
	super.ajoutPersonnel(p);
	p.ajoutPrime("PA");
}
 
void suppressionPersonnel(Personnels p){
	super.suppressionPersonnel(p);
	p.suppressionPrime("PA");
	}
}
 
class SiteVente extends Sites{
	int capacitéStock;
	SiteVente(String l){localisation = l;}
	public String toString(){return "Site Vente. " + localisation;} void ajoutPersonnel(Personnels p){
		super.ajoutPersonnel(p);
		p.ajoutPrime("PR");
		}
 
void suppressionPersonnel(Personnels p){
	super.suppressionPersonnel(p);
	p.suppressionPrime("PR");
	}
 
}

Les résultats donnés sont:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
101 Dupont base 2000 Primes [PR 100] sal. Total 2100 Histo Serv. [Site Vente Paris]
102 Martin base 2500 Primes [PR 125] sal. Total 2625 Histo Serv. [Site Vente Paris]
101 Dupont	base 2000 Primes [PR 100] sal. Total 2100 Histo Serv. [Site Vente Paris, Site Vente Lyon]
//il en manque un en PA

Je ne sais pas comment on choisit PR ou PA...

[joel.drigo]

Salut,

Déjà, ce serait mieux si tu présentais ton code de façon standard (indentation, convention de format, aération et séparation, etc...), ce serait plus lisible. Et ne parlons pas des variables (nommage, portée...), et autres. Quant à ça :if (pr=="PA") à remplacer par if ("PA".equals(pr).

Ensuite, dans Prime, tu as un attribut type (soit type de prime) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
abstract class Prime implements Comparable{
	Personnels p;
	int montant; String type;
	static List L=new ArrayList(); Prime(Personnels p){this.p=p;L.add(this);}
	abstract void calculPrime();
	public String toString(){return type;}
	public int compareTo(Object o){return montant - ((Prime)o).montant;}
}

Si tu ajoutes un getter (public String getType(), tu pourras l'utiliser pour tester le type de prime "PA".equals(prime.getType()).
J'aurais d'ailleurs utilisé une enum au lieu d'une String pour le type.

Tu a également la possibilité d'utiliser instanceof pour tester la classe :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

if ( prime instanceof PrimeAnciennete )

Donc pour supprimer une prime de type truc, tu parcours ta liste de primes et tu testes le type pour savoir si la prime est du type en question. Attention, tu ne peux supprimer les primes du type voulus au cours du parcours qu'avec un Iterator (et Iterator.remove()). Sinon, il faudra les collecter dans une liste à part et utiliser removeAll().
Autre solution, "indexée" les primes par type, en utilisant une Map (une EnumMap avec une enum en particulier).