TD/TP PAC - Programmation n° 3 - Frederic Vernier Home Page

Université Paris Sud
Licence d’informatique/IUP-Miage2
Année 2004-2005
Auteur : Frédéric Vernier
Semaine : 11-16 octobre 2004
Conditions : sur machine avec les outils standards java
web: http://vernier.frederic.free.fr/indexpac.html
TD/TP PAC - Programmation n° 3
Exercice 1
En supposant que nous disposons du code Java suivant :
Personne.java
public class Personne {
private String nom
= "";
private String prenom
= "";
private int
numeroSecu = 0;
/**
* Constructeur avec un nom et unnumero de secu
**/
public Personne(String nom_arg, String prenom_arg, int nss_arg){
nom
= nom_arg;
prenom
= prenom_arg;
numeroSecu = nss_arg;
}
/**
* @return la description de l'instance en chaîne de caractère
**/
public String toString(){
return("Nom : " + nom + " Prénom : " +
prenom + " Numéro SS : "+numeroSecu);
}
}
Employe.java
/**
* Un employe est pour l'instant une personne avec un numero d'employe
* et un salaire.
**/
public class Employe extends Personne{
public static final float SMIC = 1023.34f;
private int numeroEmploye
= -1;
private float salaire
= SMIC;
public Employe (String nom_arg, String prenom_arg,
int nss_arg, int numEmpl_arg) {
super(nom_arg, prenom_arg, nss_arg);
numeroEmploye = numEmpl_arg;
}
public String toString() {
return (super.toString() + " Numéro d'Employé: " + numeroEmploye +
"touchant " + salaire);
}
}
Client.java
/**
* un client est une personne avec un numero de client
**/
public class Client extends Personne {
private int numeroClient;
public Client (String nom_arg, String prenom_arg,
int nss_arg, int numClient_arg) {
super(nom_arg, prenom_arg, nss_arg);
numeroClient = numClient_arg;
}
public String toString() {
return (super.toString() + " Numéro Client : " +numeroClient);
}
}
ClientPrefere.java
public final class ClientPrefere extends Client {
// entre 0.0 et 1.0. 0.1 = 10% de marge sur un credit
private float margeCredit;
public ClientPrefere (String nom_arg, String prenom_arg,
int nss_arg, int numClient_arg, float margeCredit_arg) {
super(nom_arg, prenom_arg, nss_arg, numClient_arg);
margeCredit = margeCredit_arg;
}
public String toString() {
return (super.toString() + " Marge Crédit: " + margeCredit);
}
}
1. Ecrivez graphiquement la hiérarchie des classes.
•
•
•
Ici, on rappelle la notion de l'héritage on sait que nous aurons le sch´ema suivant de l'héritage en
regardant les extends : A extends B = B h´erite de A.
ClientPrefere hérite de Client qui hérite de Personne
Employe hérite de Personne. Dans cet exercice on montre l’utilisation de super() qui fait appel au
constructeur de la classe dont on hérite : il faut bien insister sur le fait que cet appel à super() est
OBLIGATOIREMENT la première ligne du constructeur.
Personne
nom, prenom, numsecu
Employe
numemploye, salaire
Client
numClient
ClientPrefere
margeCredit
2. Rajoutez les classes suivantes : Fournisseur, Stagiaire(CDD), ClientEnLitige et
proposez les champs principaux ainsi que les fonctionnalités principales.
Personne
nom, prenom, numsecu
Employe
numemploye, salaire, DateDebutContrat
Client
Fournisseur
numClient
numFournisseur, prix, delai
CDD
CDI
ClientEnLitige
ClientPrefere
DateFinContrat
DateTitularisation
MontantLitige
margeCredit
PB: un CDD ne peut être requalifié en CDI après coup. -> creer un classe Contrat, CDI et
CDD puis faire dans Employe avoir une reference vers son contrat.
3. Pourquoi n'y a t-il pas d'argument salaire dans le constructeur de Employe ?
Parce que les employés ont le SMIC par défaut. Comme il n'y a pas de fonction void
setSalaire(float Salaire) il n'y a donc aucune perspective de carrière dans cette
entreprise !
4. Qu’affiche le morceau de programme suivant ?
Test.java
public class Test {
public static void main (String [] args) {
Personne personne1;
Personne personne2;
Personne personne3;
System.out.println();
personne1 = new Employe ("Brian", "Mulroney", 546241895, 237);
personne2 = new Client ("Brian", "Savage", 162738904, 2633);
personne3 = new ClientPrefere ("Jean", "Chrétien",
268490123, 1429, 0.3f);
System.out.println(personne1);
System.out.println();
System.out.println();
System.out.println(personne2);
System.out.println();
System.out.println();
System.out.println(personne3);
}
}
Réponse :
Ici, on veut montrer comment fonctionne le polymorphisme en java. Bien que p1, p2 et p3 soient déclares de
type Personne, ce sont respectivement des instances d’Employe, de Client et de ClientPrefere (java
type au moment de la création d’une instance : ”new”). En utilisant l’algorithme (du transparent intitule
Algorithme du cours de Fred), java appelle la méthode dans la classe de définition, l’affichage produit est
donc le suivant :
Nom : Brian Pr•nom : Mulroney Num•ro SS : 546241895 Num•ro d'Employ•:
237touchant1023.34
Nom : Brian Pr•nom : Savage Num•ro SS : 162738904 Num•ro Client : 2633
Nom : Jean Pr•nom : Chr•tien Num•ro SS : 268490123 Num•ro Client : 1429
Marge Cr•dit: 0.3
PS: Java gère les accents ... mais pas la console DOS depuis laquelle j'appelle mon prg
Grrrrrrrrrrrrr !
5. L’entreprise veut désormais pouvoir savoir à tout moment le nombre de clients préférés
qu’elle a et connaître le pourcentage des clients préférés par rapport à l'ensemble de ses
clients.
Modifiez la classe ClientPrefere et Client pour répondre aux besoins de l’entreprise :
la classe ClientPrefere doit posséder la méthode de classe suivante :
float getPourcentageDeClientsPreferes() qui renvoie le pourcentage de clients
préférés.
Il faut être capable de compter le nombre d’instance de la classe ClientPrefere, ceci se fait par une variable de
classe (mot clé static).
Client.java
/**
* un client est une personne avec un numero de client
**/
public class Client extends Personne {
private int numeroClient;
protected static int NbClient = 0;
// JUSTE PROTECTED POUR ETRE ACCEDER DEPUIS CLIENTPREFERES !
public Client (String nom_arg, String prenom_arg,
int nss_arg, int numClient_arg) {
super(nom_arg, prenom_arg, nss_arg);
numeroClient = numClient_arg;
NbClient ++;
}
public String toString() {
return (super.toString() + " Numéro Client : " +numeroClient);
}
}
ClientPrefere.java
public final class ClientPrefere extends Client {
// entre 0.0 et 1.0. 0.1 = 10% de marge sur un credit
private float margeCredit;
private static int NbClientPrefere = 0;
public ClientPrefere (String nom_arg, String prenom_arg,
int nss_arg, int numClient_arg, float margeCredit_arg) {
super(nom_arg, prenom_arg, nss_arg, numClient_arg);
margeCredit = margeCredit_arg;
NbClientPrefere ++;
}
public String toString() {
return (super.toString() + " Marge Crédit: " + margeCredit);
}
static float getPourcentageDeClientsPreferes(){
// NB le transtypage en float est obligatoire pour eviter de faire
// une devision sur les entiers
return (float)NbClientPrefere / (float)NbClient;
}
}
6. A partir d’un tel programme, est-il possible de définir un type de client
ChefEntreprise qui seront des clients préférés pour lesquels on doit aussi pouvoir
connaître le chiffre d’affaires de l’entreprise ? Proposez une solution.
On ne peut dériver une classe ”final”. Il faut supprimer le mot clé ”final” et écrire la classe
suivante dans le fichier ChefEntreprise.java :
7.
ChefEntreprise.java
public class ChefEntreprise extends ClientPrefere{
private double chiffreAffaires;
public ChefEntreprise (String n, String p,int nss,
int nc, int mc, double ca) {
super(n, p, nss, nc, mc);
chiffreAffaires = ca;
}
public String toString() {
return (super.toString() + " Chiffre d’affaires : " +
chiffreAffaires);
}
}
Exercice 2
• On considère la banque X.
• Cette banque permet à ses clients d’ouvrir des comptes qu’elle gère.
• Un compte est défini par un numéro d’agence, un numéro de compte et un solde.
• La banque X gère deux types de compte : des comptes courants et des comptes
« épargne ».
• Les clients doivent pouvoir déposer et retirer de l’argent sur un compte, consulter le
solde d’un compte.
• Un client doit pouvoir effectuer un virement d’un compte courant vers un autre de ses
compte (courant ou ”épargne”).
• Un client doit pouvoir effectuer un virement vers le compte d'un autre client en payant
le prix de 1,5 euros par transaction.
• Les comptes ”épargne” rapportent de l’argent : ils ont un taux d’intérêt tx et chaque
dépôt d’argent d’un montant M sur un compte ”épargne” provoque une augmentation
du solde de ce compte de M +M*tx.
Modéliser les Classes, leur hiérarchie en respectant la contrainte suivante:
le sommet de la hiérarchie est une classe Compte sur laquelle on ne gérera pas des dépôts
directement (Compte doit être une classe abstraite). Cette classe doit toutefois regrouper le
maximum d’attributs et méthodes de ses descendantes.
Coder et tester en créant un compte courant cc1, un compte épargne ce1 dont le taux est
0.05, réaliser un versement de 2000 euros sur cc1 puis effectuer un virement de 500 euros
de cc1 vers ce1. On imaginera un autre compte épargne ce2 du proprio de votre logement à
qui vous verserez un loyer de 1000euros.
Compte.java
public abstract class Compte {
/* numeroCompte et solde sont
protected int numeroCompte
protected double solde
protected Client proprietaire
des attributs communs aux deux types de compte */
= 0;
= 0;
= null;
/* PAS DE CONSTRUCTEUR dans une classe abstraite : une classe abstraite ne sert qu’a
modeliser des traitements communs `a ses descendants, on ne peut pas construire une
instance d’une telle classe */
/* Etant donne qu’un depot sur un compte courant et sur un compte "epargne" sont
differents, le comportement de void deposer(double montant) est code dans les classes
descendantes */
public abstract void deposer(double montant);
/* void retirer(double montant) et double consulterSolde() sont les memes qu’elle que
soit le type de compte, on code leur comportement ici */
public void retirer(double montant){
solde-=montant;
}
public double consulterSolde(){
return solde;
}
public String toString(){
return ("Compte No: "+numeroCompte+" - Solde : "+solde);
}
}
CompteCourant.java
public class CompteCourant extends Compte{
public CompteCourant(int nc, Client prop) {
solde = 0.0;
numeroCompte = nc;
proprietaire = prop;
}
public void deposer(double montant){
solde+=montant;
}
public void virement(double montant, Compte destinataire){
if (destinataire.proprietaire!=proprietaire)
solde-=1.5;
solde-=montant;
destinataire.deposer(montant);
}
}
CompteEpargne.java
public class CompteEpargne extends Compte{
protected double taux;
public CompteEpargne(int nc, double tx, Client prop) {
numeroCompte = nc;
solde = 0.0;
taux = tx;
proprietaire = prop;
}
public void deposer(double montant){
solde+=(montant + taux*montant);
}
public String toString(){
return (super.toString()+" - Taux : "+taux);
}
}
TestBanque.java
public class TestBanque {
public static void main(String[] args){
Compte cc1, ce1, ce2;
Client Client1 = new Client ("Brian", "Savage", 162738904, 1);
Client Client2 = new Client ("Celine", "Dion",
162738905, 2);
cc1 = new CompteCourant(1, Client1);
ce1 = new CompteEpargne(2, 0.05, Client1);
ce2 = new CompteEpargne(3, 0.05, Client2);
cc1.deposer(2000);
/* On est oblige de transtyper cc1 en CompteCourant car l’operation
de virement est specifique a la classe CompteCourant */
((CompteCourant)cc1).virement(1000, ce2);
((CompteCourant)cc1).virement(500, ce1);
System.out.println(cc1);
System.out.println(ce1);
System.out.println(ce2);
}
}
Exercice 3
En Java nous disposons de la classe Vector, un vecteur d’objet de type Object. Tout objet
en java hérite par défaut de la classe Object. Nous voulons créer et manipuler un vecteur
d’entiers.
Nous voulons :
1. créer un vecteur d’entiers dont les entrées sont données en ligne de commande,
2. afficher un vecteur d’entiers,
3. calculer la somme des éléments d’un vecteur d’entiers.
La classe Vector de Java nous propose les méthodes suivantes de manipulation de
vecteurs :
1. Vector() constructeur de vecteur.
2. Vector(int capacite_arg) constructeur de vecteur de capacité initiale est égale à
capacite_arg.
3. boolean add(int index_arg, Object element_arg)insère l’objet element_arg à
la position index_arg du vecteur.
4. boolean add(Object element_arg) ajoute l’objet element_arg à la fin du vecteur.
5. int size() renvoie la taille vecteur.
6. Object elementAt(int index_arg) renvoie l’objet stocké à l’indice index_arg du
vecteur.
Correction : La difficulté de cet exercice réside dans le fait qu’un vecteur fait référence à
des Objects alors que le type int n’est pas un objet, il faut utiliser la classe enveloppe
Integer. Ils doivent donc faire attention au transtypage chaque fois qu’ils manipulent les
éléments d’un vecteur. Rappeler aussi qu'on ne peut pas modifier un Integer !
GestionVector.java
import java.util.*;
public class GestionVector {
static public Vector creer(String tab[]){
Vector v =new Vector(tab.length);
for(int cpt=0; cpt<tab.length;cpt++){
v.add(new Integer(Integer.parseInt(tab[cpt])));
}
return(v);
}
static int somme(Vector v){
Integer entier;
int somme=0;
for(int cpt=0; cpt < v.size(); cpt++){
entier= (Integer) v.elementAt(cpt);
somme = somme + entier.intValue();
}
return(somme);
}
static void afficher(Vector v){
Integer un_entier;
for(int cpt=0; cpt < v.size(); cpt++){
un_entier= (Integer) v.elementAt(cpt);
System.out.print(" "+un_entier.intValue());
}
System.out.println();
}
public static void main(String[] args){
Vector vecteur;
vecteur=creer(args);
afficher(vecteur);
System.out.println("Somme : "+ somme(vecteur));
}
}
Exercice 4
L’objectif de cet exercice est de corriger le programme suivant :
QUESTION SUBSIDIAIRE : une petite ville peut-elle être capitale ? Comment faire
pour que se soit le contraire ?
Réponse : NON (mais OUI), Capitale hérite de Ville, pas de PetiteVille. Un objet de type
PetiteVille ne peut être capitale ... mais rien n'empêche une ville d'être petite sans être
de la classe PetiteVille. Faire une classe GrandeVille qui hérite de Ville. Rendre Ville
abstraite et faire hériter Capitale de GrandeVille. Mettre des ifs dans les
constructeurs ... ou creer une fonction static dans Ville static Ville creerVille(int
nb_hab)) qui fait un if sur le nb d'habitants et invoque le bon constructeur !
villes/Ville.java
package villes;
public class Ville{
protected String nom;
protected int nombreHabitants;
public Ville(String n){
n = nom;
nombreHabitants = 0;
}
public Ville(String n, int nh){
n = nom;
nombreHabitants = nh;
}
public String toString(){
return (nom + " - "+nombreHabitants+" habitants");
}
// retourne le nom de la ville
public String getNom() {
return nom;
}
// change le nombre d'habitants
public void setNombreHabitants(int n) {
nombreHabitants = n;
}
// retourne le nombre d'habitants de la ville
public int getNombreHabitants(int n) { // INUTILE
return nombreHabitants;
}
}
villes/PetiteVille.java
package villes;
public class PetiteVille extends Ville{
public PetiteVille(String nom_arg, int nh_arg){
super(nom_arg);
nombreHabitants = nh_arg; // OU ALORS super(nom_arg, nh_arg)
}
public String toString(){
return (super.toString()+" - Statut : petite ville");
}
public void setNombreHabitants(int n) {
nombreHabitants = n; // INUTILE CAR ON HERITE DEJA DE CES FONCTIONS
}
public int getNombreHabitants(int n) {
return nombreHabitants;
}
}
pays/Capitale.java
package pays;
import villes.*; // SINON LE COMPILO NE TROUVE PAS LA CLASSE VILLE
class Capitale extends Ville{
protected Pays pays; // SINON CapitaleEconomique N'Y ACCEDE PAS
public Capitale(String nom_arg, Pays pays_arg){
super(nom_arg);
pays = pays_arg;
}
public Pays getPays() {
return pays;
}
public String getNom(){
return pays+" - "+nom;
}
public String toString(){
return (nom + " - "+nombreHabitants+" habitants – Statut"+
" : capitale de "+pays);
}
}
pays/Pays.java
package pays;
import java.util.*;
class Pays extends Object{
private String nom
= "";
private Ville lacapitale
= null;
private Vector VillesPrincipales = null;
public Pays(String nom_arg){
VillesPrincipales = new Vector();
nom = nom_arg; // CAR PAYS N'HERITE PAS DE VILLE !!!
}
public void setCapitale(Ville capitale_arg){
lacapitale = capitale_arg;
//CAR SINON ON AJOUTE NULL
VillesPrincipales.add(lacapitale);
}
}
pays/CapitaleEconomique.java
package pays; // SINON ON ACCEDE A RIEN !
import villes.*;
class CapitaleEconomique extends Capitale{
public CapitaleEconomique(String nom_arg, Pays pays_arg){
super(nom_arg, pays_arg); // LE CONSTRUCTEUR AVEC 1 SEUL ARG EST
// DANS VILLE PAS DANS CAPITALE
}
public String toString(){
return (nom + " - "+nombreHabitants+" habitants - Statut :"+
" capitale de "+pays);
}
}