Université Mohammed V de Rabat

Département d’informatique

TD 4 et TP 4 : classes et héritages

Exercice 1 : (Valeurs et références, surcharge)

Qu'affiche le programme suivant ?
class A {
private int val=O;
public static void affichePlus(int a){
a++;
System.out.println(a);
}
public static void affichePlus(A a){
a.val++;
System.out.println(a.val);
}
public static void main(String[] args) {
A uneClasse = new A();
A uneAutreClasse = new A();
affichePlus(uneClasse.val);
affichePlus(uneClasse.val);
affichePlus(uneClasse);
affichePlus(uneClasse);
affichePlus(uneAutreClasse);
affichePlus(uneAutreClasse);
if(uneClasse==uneAutreClasse)
System.out.println("Egales");
else System.out.println("Differentes");
}
}
Affichage :

Exercice 2 (Classification)
On prend les classes suivantes : Etudiant, Personne, EtudiantTravailleur, Enseignant,
EtudiantSportif et Travailleur.
1. dessinez une arborescence cohérente pour ces classes en la justifiant,
2. où se situeront les champs suivants : salaire,
emploiDuTemps, anneDEtude, nom, age et sportPratique.
-1/17-
Exercice 3 (Constructeurs)

Les exemples suivants sont-ils corrects ? Justifiez.

1. class A {
private int a;
public A(){ System.out.println(a); }
public A(int a){ this.a = a; this(); }
}
Correction : Non : dans le constructeur à un paramètre l'appel au constructeur
sans paramètre doit être effectué en premier.
2.class A {
int a;
}
class B extends A{
int b;
B(int a, int b){ super.a = a; this.b = b; }
}
Correction : Oui.

3. class A {
int a;
A(int a){ this.a = a; }
}
class B extends A{
int b;
B(int a,int b){ super.a = a; this.b = b; }
}

Correction : Non : En l'absence d'appel explicite à un constructeur de la super

classe dans le constructeur de la classe B, un appel implicite au constructeur par
défaut de la super classe est tenté; or la définition d'un constructeur quelconque
masque l'existence du constructeur par défaut. La correction est donc d'appeler
explicitement dans la sous-classe le constructeur de la super classe : super(a) ;
4. class A {
private int a;
A(){this.a=O;}
}
class B extends A {
private int b;
B(){super.a=O; this.b=O;}
}

Correction : Non : La classe B n'a pas accès au champ a. Il faut utiliser le

constructeur de la super classe super(); this.b=O;
Exercice 4 (Redéfinition)
Les exemples suivants sont-ils corrects ? Justifiez.
1. class A{
public void f(){System.out.println("Bonjour.");}
}
class B extends A{
-2/17-
private void f(){System.out.println("Bonjour les amis.");}
}
Correction : Non : on ne peut redéfinir une méthode en restreignant sa
visibilité.
2. class A{
public int f(int a){ return a++; }
}
class B extends A{
public boolean f(int a){ return (a==O);}
}

Correction : Non : on ne peut redéfinir une méthode et changer le type du

résultat.

3. class A{
public int f(int a) { return a++; }
}
class B extends A {
public int f(int a, int b) { return a+b;}
}
class test {
B obj = new B();
int x = obj.f(3);
int y = obj.f(3,3);
}

Correction : Oui. L'appel f(3) utilise la méthode de la super classe.

4.class A {
public int f(int a) { return a++; }
}
class B extends A {
public int f(int a, int b) { return a+b;}
}
class test {
A obj = new B();
int x = obj.f(3);
int y =obj.f(3,3);
}
Correction : Non, le compilateur va rejeter le programme car obj a été déclaré de la
classe A pour le quel f est défini avec un seul argument. Pour corriger, il faut ajouter le
cast dans : i n t y = ( ( B ) o b j ) . f ( 3 , 3 ) ;

Exercice 5 (Liaison dynamique) Qu'affiche le programme suivant ?

class A {
public String f(){ return ("A");}
}
class B extends A {
public String f() { return ("B");}
}
class test {
public static void main (String [] args){
A a1 = new A();
-3/17-
 A a2 = new B();
B b = new B();
System.out.println(a1.f()); System.out.println(a2.f());
System.out.println(b.f());
}
}
Correction :

ABB
Le choix de la méthode est fait dynamiquement pendant l'exécution.

Exercice 6 (Liaison dynamique)

Qu'affiche le programme suivant ?

class A {
public String f(B obj){ return ("A et B");}
public String f(A obj){ return ("A et A");}
}
class B extends A {
public String f(B obj){ return ("B et B");}
public String f(A obj){ return ("B et A");}
}
class test {
public static void main (String [] args){
A a1 = new A();
A a2 = new B();
B b = new B();
System.out.println(a1.f(a1));
System.out.println(a1.f(a2));
System.out.println(a2.f(a1));
System.out.println(a2.f(a2));
System.out.println(a2.f(b));
System.out.println(b.f(a2));
}
}
Correction :

A et A
A et A
B et A
B et A
B et B
B et A
Le choix de la méthode est fait dynamiquement pendant l'exécution, tandis que le
type de l'argument est déterminé à la compilation.

Exercice 7 (Polymorphisme)
Qu'affiche le programme suivant ?
class A {
public String f(D obj) { return ("A et D");}
public String f(A obj) { return ("A et A");}
}
-4/17-
class B extends A {
public String f(B obj) { return ("B et B");}
public String f(A obj) { return ("B et A");}
}
class C extends B{
}
class D extends B{
}
class test {
public static void main(String [] args){
A a1 = new A();
A a2 = new B();
B b = new B();
C c = new C();
D d = new D();
System.out.println(a1.f(b));
System.out.println(a1.f(c));
System.out.println(a1.f(d));
System.out.println(a2.f(b));
System.out.println(a2.f(c));
System.out.println(a2.f(d));
System.out.println(b.f(b)); System.out.println(b.f(c));
System.out.println(b.f(d));
}
}
Correction :

A et A
A et A
A et D
B et A
B et A
A et D
B et B
B et B
A et D
Les premiers trois appels se comportent d'une façon polymorphe comme on s'y
attend.
Les trois appels suivants semblent un peu « bizarres » cela dépend du fait que la
signature de la méthode est choisie à la compilation, tandis que le code à exécuter
est choisi à l'exécution. A la compilation, l'objet a2 est supposé être de type A.
Dans la classe A, la méthode f n'est pas définie pour un objet de type B. Ainsi,
l'appel a2.f(b) utilise le polymorphisme et considère b comme un objet de type A.
Donc, la signature pour cet appel exige un argument de type A. A l'exécution, a2
est un objet de type B. Le code utilisé est celui de la méthode de B qui a la même
signature, même si B pourrait avoir une méthode plus « précise ». L’appel a2.f(d)
choisit la signature de f qui exige objets de type D. A l'exécution, a2 est de type B.
La classe B n'a pas une méthode f avec la bonne signature. Donc le code de la
superclasse est utilisé.
Parmi les trois derniers appels, le plus intéressant est le dernier : B n'a pas une
méthode pour D. Est-ce que D va être vu comme un B, ou est-ce que la méthode de
la superclasse A va ê tre appelée ? En fait, l'héritage a la priorité sur le
polymorphisme.

-5/17-
Exercice 8 (Champs de classe)
Qu'affiche le programme suivant ?
class A {
int i;
int f(){ return i; }
static String g(){ return ("A"); }
String h(){ return g(); }
}
class B extends A {
int i=2;
int f(){ return –i; }
static String g(){ return ("B"); }
String h(){ return g(); }
}
class test {
public static void main(String [] args) {
B b = new B();
System.out.println(b.i);
System.out.println(b.f());
System.out.println(b.g());
System.out.println(b.h());
A a = b;
System.out.println(a.i);
System.out.println(a.f());
System.out.println(a.g());
System.out.println(a.h());
}
}
Correction :

2
-2
BB0
-2
AB
La « surprise » est en ligne 5, où l'on s'attend à lire 2 (comportement des
méthodes). En réalité, vu qu'il n'y a pas de dynamisme pour l'accès aux champs, le
type de l'objet est déterminé à la compilation (ici A). Donc c'est bien le champ de
la « structure » A auquel on accède, alors même que l'objet est dynamiquement un
B.
Exercice 9
Dans cet exercice, on veut écrire une classe EnsembleDEntiers fournissant des
méthodes permettant d'ajouter ou enlever un entier de l'ensemble et d'afficher cet
ensemble :
1. donnez la liste des prototypes des constructeurs et méthodes de la classe
EnsembleDEntiers,
2. implémentez cette classe,
3. on veut maintenant étendre cette classe en EnsembleOrdonneDEntiers dans
laquelle l'ensemble apparaîtra comme toujours ordonné (ses é léments seront
visiblement ordonnés).
Correction :
import java.util.Random;
-6/17-
class EnsembleDEntiers{
private int [] elements;
private int nElements;
private void retaille(){
if (nElements<elements.length) return;
int [] tmp = new int[elements.length+10];
for (int i=0; i<nElements; i++)
tmp[i] = elements[i];
elements = tmp;
}
public EnsembleDEntiers(){
elements = new int[10];
nElements = 0;
}
public EnsembleDEntiers(EnsembleDEntiers e){
this();
for(int i=0; i<e.nombreDElements();i++)
ajoute(e.element(i));
}
public void ajoute(int element) {
retaille() ;
elements[nElements++] = element ;
}
private int cherche(int element) {
for (int i=0; i<nombreDElements(); i++)
if (element(i)==element) return i;
return -1;
}
public int element(int indice) {
return elements[indice];
}
public void enleve(int element) {
int indice = cherche(element);
if (indice==-1) return;
for (int i=indice+1; i<nombreDElements(); i++)
elements[i-1] = elements[i];
nElements--;
}
public int nombreDElements() {
return nElements;
}
public String toString() {
StringBuffer tmp = new StringBuffer("{");
if (nombreDElements()>O) {
for (int i=O; i<nombreDElements()-1; i++)
tmp.append(element(i) + ",");
tmp.append(element(nombreDElements()-1));
}
tmp.append("}");
return tmp.toString();
}
public static void main(String [] argv){
EnsembleDEntiers e = new EnsembleOrdonneDEntiers();
Random r = new Random();
for (int i=O; i<23; i++) {
e.ajoute(r.nextlnt(1OO));
}
-7/17-
 System.out.println(e);
}
protected void modifie(int indice,int valeur) {
elements[indice] = valeur ;
}
}
class EnsembleOrdonneDEntiers extends EnsembleDEntiers{
private int cherchePremierPlusGrandOuEgal(int element){
for (int i=O; i<nombreDElements()-1; i++)
if (element(i)>=element) return i;
return nombreDElements()-1;
}
public void ajoute(int element) {
super.ajoute(element) ;
int ppg = cherchePremierPlusGrandOuEgal(element);
int valeur = element(nombreDElements()-1);
for (int i=nombreDElements()-1; i>ppg; i--)
modifie(i,element(i-1)) ;
modifie(ppg,valeur) ;
}
}
class EnsembleFaineantOrdonneDEntiers extends
EnsembleDEntiers {
private boolean ordonne;
public void ajoute(int element) {
ordonne = false;
super.ajoute(element);
}
public String toString() {
if (!ordonne)trie();
return super.toString();
}
public int element(int indice) {
if (!ordonne) trie() ;
return super.element(indice) ;
}

private void trie() {

if (ordonne) return ;
// tri quelconque du tableau...
ordonne = true ;
}
}
Exercice 10 : Analyse d’un programme Java
Objectifs : hiérarchie de classes, héritage
Considérons le programme Java suivant :

package exo10 ;
class Livre{
// les attributs
protected string titre, auteur, proprietaire ;
protected int nbPages ;
double prix ;
-8/17-
//les méthodes
public Livre(String t, String a, double p, int nb){
titre=t ;auteur = a ; prix=p ;
proprietaire= "";nbPages=nb;
}
public void afficher(){
System.out.println("Titre : "+titre);
System.out.println("Auteur : "+auteur);
System.out.println("Prix : "+prix);
System.out.println("Nombre de pages : "+nbPages);
If(this.estNeuf()){
System.out.println("Aucun proprietaire");

}else {
System.out.println("Proprietaire : "+proprietaire);

}
System.out.println();
}
Public boolean estNeuf(){

if(proprietaire=="")return true;
else return false;
}
public void acheter (String nom){
proprietaire=nom ;
}
}
class BD extend Livre {
private boolean encouleur ;
public BD(String t, String a, double p, int nb, boolean
c){super(t,a,p,nb) ;
encouleur=c
}
}
class Album extends Livre{
boolean pageColoriee[] ;
public Album(String t, String a, double p, int
n){ super(t,a,p,n) ;
pageColoriee=new boolean[n] ;
for(int i=0 ;i<100 ;i++)
pageColoriee[i]=false ;
}
public void colorie(int numPage){
if(pageColoriee[numPage]==false)&&!estNeuf()
{pageColoriee[numPage]=true ;}
else { System.out.println("page déjà coloriee : ");
}
}
}
// La classe principale d’appel
public class Test{
public static void main (String[] args){
Livre l1= new Livre("le petit prince","st Exupéry",
10.40,50);
Livre l2= new Livre("Contes","Grim", 14.40,254);
L1.afficher();
L1.acheter("moi");
-9/17-
 L1.afficher();
L1.prix=0.0;
L2.acheter("lui");
L2.afficher();
BD b1=new BD("Lucky Luke","Morris", 10.40,45, true);
BD b2=new BD("Tintin","Herge", 200.40,45, false);
b1.acheter("moi");
b1.afficher();
b2.afficher();
Album a1= new Album("Dora","Dora", 300,3.5);
a1.afficher();
a1.afficher(23);
a1.acheter("moi");
a1.colorie(23);
}
}

Questions :
1) Expliquer les informations que le programme va afficher lors de son
exécution.
2) Dans la classe Livre, l’attribut prix a été défini sans règle
d’encapsulation (public, private, …) Comment Java va-t-il
l’interpréter ? comment pouvez-vous le tester ou comment est-il testé
dans le programme ?
3) Expliquer comment on teste dans ce programme si un livre est neuf ou
non.
4) Décrivez la hiérarchie de classe décrite dans ce programme et
expliquer le processus d’appel entre les constructeurs.
5) Expliquer comment ce programme gère le fait de colorier une page
d’un album à colorier.
6) Découvrez les erreurs de frappe présentes dans le code. Corriger-les en
codant et en commentant ces quelques lignes sous Eclipse.

Réponse ;
1) Expliquer les informations que le programme va afficher lors de son
exécution.

Titre : Lucky Luke

Auteur : Morris
Titre : Le petit prince Prix : 10.4
Auteur : St Exupéry Nombre de pages : 45
Prix : 10.4 Proprietaire : moi
Nombre de pages : 50
Aucun proprietaire

Auteur : Herge
Titre : Le petit prince Titre : Tintin
Auteur : St Exupéry Prix : 200.4
Prix 10.4 Nombre Pages : 45
Nombre de pages : 50 Aucun proprietaire
Proprietaire : moi

Titre : Dora
Titrea : Contes Auteur : Dora
Auteur : Grimm Prix : 3.5
Prix : 14.4 Nombre de pages : 300
Nombre de pages : 254 Aucun proprietaire
Proprietaire : lui
-10/17-
 Page 23 déjà coloriee
2) Dans la classe Livre, l’attribut prix a été défini sans règle
d’encapsulation (public, private, …) Comment Java va –t-il
l’interpréter ? Comment pouvez-vous le tester ou comment est-il testé
dans le programme ?
Java l’interprète comme un attribut public. On y accède dans la classe Test
directement dans l’instruction l1.prix=0.0.
3) Expliquer comment on teste dans ce programme si un livre est neuf ou
non.
En fait, un livre est neuf s’il n’a pas de propriétaire. D’où l’intérêt du
constructeur qui initialise l’attribut proprietaire à une chaine de caractères
vide. Il faut initialiser toutes les variables ! Sinon le test risque de ne pas
fonctionner systématiquement.
4) Décrivez la hiérarchie décrite dans ce programme et expliquer le
processus d’appel entre les constructeurs.
Trois classes : Livre, BD et album, les deux dernières héritant de propriétés
de la première. La classe Livre ayant un constructeur (paramètres titre,
auteur, prix et nombre de page), les sous-classes doivent avoir leur propre
constructeur qui appelle (méthode super) le constructeur de la classe Livre.
La classe BD possède un attribut de type booléen (en couleur) qui spécifie
si la bande dessinée est ou non en couleur.
5) Expliquer comment ce programme gère le fait de colorier une page d’un
album à colorier.
Un tableau de booléan permet de conserver l’information qu’une page a été
coloriée. Ce tableau est initialisé à faux dans le constructeur de la classe
Album. Chaque appel à la méthode de coloriage teste si la page a ou non
été coloriée.
6) Découvrez les erreurs de frappe présentes dans le code. Corriger-les en
codant et en commentant ces quelques lignes sous Eclipse.
Cinq erreurs figurent dans le texte. Elles sont en rouge dans le code source
ci-dessus.
Voici la correction :
package exo10Corrige ;
class Livre{
// les attributs
protected string titre, auteur, proprietaire ;
protected int nbPages ;
double prix ;
//les méthodes
public Livre(String t, String a, double p, int nb){
titre=t ;auteur = a ; prix=p ;
proprietaire= "";nbPages=nb;
}
public void afficher(){
System.out.println("Titre : "+titre);
System.out.println("Auteur : "+auteur);
System.out.println("Prix : "+prix);
System.out.println("Nombre de pages : "+nbPages);
If(this.estNeuf()){
System.out.println("Aucun proprietaire");

}else {
System.out.println("Proprietaire : "+proprietaire);
}
System.out.println();
}
-11/17-
 Public boolean estNeuf(){
if(proprietaire=="")return true;
else return false;
}
public void acheter (String nom){
proprietaire=nom ;
}
}
class BD extend Livre {
private boolean encouleur ;
public BD(String t, String a, double p, int nb, boolean
c){super(t,a,p,nb) ;
encouleur=c
}
}
class Album extends Livre{
boolean pageColoriee[] ;
public Album(String t, String a, double p, int
n){ super(t,a,p,n) ;
pageColoriee=new boolean[n] ;
for(int i=0 ;i<100 ;i++)
pageColoriee[i]=false ;
}
public void colorie(int numPage){
if(pageColoriee[numPage]==false)&&!estNeuf()
{pageColoriee[numPage]=true ;}
else { System.out.println("page"+numPage+ "déjà
coloriee : ");
}
}
}
// La classe principale d’appel
public class Test{
public static void main (String[] args){
Livre l1= new Livre("le petit prince","st Exupéry",
10.40,50);
Livre l2= new Livre("Contes","Grimm", 14.40,254);
L1.afficher();
L1.acheter("moi");
L1.afficher();
L1.prix=0.0;
L2.acheter("lui");
L2.afficher();
BD b1=new BD("Lucky Luke","Morris", 10.40,45, true);
BD b2=new BD("Tintin","Herge", 200.40,45, false);
b1.acheter("moi");
b1.afficher();
b2.afficher();
Album a1= new Album("Dora","Dora", 3.5,300);
a1.afficher();
a1.colorie(23);
a1.acheter("moi");
a1.colorie(23);
}
}
Exercice 11 : Héritage de classe et constructeurs
1) Un site internet est spécialisé dans la vente de livres pour enfant. Ces livres
-12/17-
 sont soit des bandes dessinées, soit des albums à colorier. Un livre est
défini par son titre, son auteur, son prix et son nombre de pages. Les bades
dessinées sont soit en couleur soit en noir et blanc alors l’utilisateur a la
possibilité de colorier une page d’un album présenté. Proposer et
implémenter et tester sous Eclipse une solution à ce problème.
Réponse : C’est volontairement l’énoncé de l’exercice 10.
2) Le site web veut donner la possibilité aux utilisateurs de revendre un livre
et de s’échanger deux bandes dessinées si elles ont un prix équivalent.
Modifier le programme précédent pour prendre en compte ces fonctions
supplémentaires.
Réponse : la méthode suivante est ajoutée dans la classe Livre.
public void revendre(String acheteur, double prixOccas){
propritaire=acheteur ;
prix= prixOccas ;
}
Nous avons fait le choix de revendre un livre à un nouveau propriétaire et à un
nouveau prix d’occasion (les deux paramètres de la méthode) mais on aurait
pu choisir d’autres paramètres comme rien n’est clairement spécifié.
La méthode suivante est à ajouter dans la classe BD
public void echanger(BD b){
if(this.prix==b.prix){
System.out.println("Prix égaux : échange possible") ;
String proTmp=this.proprietaire ;
this.proprietaire=b.proprietaire ;
b.acheter(propTmp) ;
}else //ne pas échanger les BD
System.out.println("Prix différents : échange
impossible") ;

}
C’est la première fois que l’on voit une des contraintes des langages objet. La
variable b étant d’un autre type.
3) Enfin, le site web veut étendre son offre d’œuvre culturelles à des films
(DVD) qui sont définis eux aussi par un titre, un auteur et un prix mais en
plus une information sur la durée du film. Comment modifier la hiérarchie
de classe pour intégrer ces modifications ? Programmer-le.
La hiérarchie des classes doit être profondément modifiée. Livre et film
doivent héritée d’une classe « supérieure » Œuvre. Dans ce cas, les attributs
auteur, titre, proprietaire et prix « remontent dans la classe Œuvre. La classe
Livre ne conserve plus que l’attribut nbPages au même titre que la classe Film
une durée. Les deux sous-classes BD et Album de la classe Livre ne changent
pas.
package ex11 ;
//La classe Œuvre
class Oeuvre{
//les attributs
protected String titre, auteur, proprietaire ;
protected double prix ;
//le constructeur avec comme paramètre le titre, l’auteur et le prix
//l’attribut proprietaire est initialisé
public Oeuvre(String t, String a, double p){
titre=t ; auteur=a ; prix=p ; proprietaire="";
}
//une œuvre est neuve si elle n’a pas encore de proprietaire
//d’où l’intérêt de l’initialisation dans le constructeur
public boolean estNeuf(){
if (proprietaire=="")return true;
else return false;
-13/17-
 }
//affiche les informations sur l’œuvre
public void afficher(){
System.out.println("Titre : "+titre);
System.out.println("Auteur : "+auteur);
System.out.println("Prix : "+prix);
If(this.estNeuf())
System.out.println("Aucun proprietaire ");
else System.out.println("Proprietaire : "+proprietaire);
System.out.println();
}
//la méthode acheter donne un nom de proprietaire à l’objet
public void acheter(String nom){proprietaire=nom}
}
//La classe Film hérite de la classe Oeuvre
class Film extends Oeuvre{
//un seul attribut supplémentaire durée du film en mn
protected int duree ;
//le constructeur de cette classe appelle celui de la classe supérieure
//c-à-d de la classe Oeuvre
public Film(String t, String a, double p, int d){
super(t,a,p) ;
duree=d ;
}
//la méthode revente modifie simplement le proporietaire et le prix du
//livre
public void revente(String acheteur, double prixOccas){
proprietaire=acheteur ;
prix=prixOccas ;
}
public String proprietaire(){
return (proprietaire) ;
}
}
//La classe Livre hérite de la classe Œuvre
class Livre extends Oeuvre{
//un seul attribut suppl. nombre de pages du livre
protected int nbPages ;
//le constructeur de cette classe appelle celui de la classe supérieure
//c-à-d de la classe Œuvre
Public Livre(String t, String a, double p, int nb){
Super(t, a, p) ;
nbPages=nb ;
}
//la méthode revente modifie simplement le proprietaire et le prix du
//livre
public void revente(String acheteur, double prixOccas){
proprietaire=acheteur ;
prix=prixOccas ;
}
public String propriete(){
return(proprietaire) ;
}
}
//la classe BD hérite de la classe Livre
class BD extends Livre{
//un seul attribut supplémentaire : un booléen qui définit si la BD est
// en couleur ou non
-14/17-
 private boolean encouleur ;
// le constructeur qui appelle celui de la classe Livre et donc celui de
//de la classe Œuvre
public BD(String t, String a, double p, int n, boolean c){
super(t,a,p,n) ;
encouleur=c ;
}
//La méthode qui échange les noms des propriétaires si le prix des BD
// est identique
public void echanger(){
if(this.prix==b.prix){
System.out.println("Prix égaux:échange possible") ;
String proTmp=this.proprietaire ;
this.proprietaire=b.proprietaire ;
b.acheter(propTmp) ;
}else //ne pas échanger les BD
System.out.println("Prix différents:échange
impossible") ;
}
}
//La classe Album qui hérite de Livre
class Album extends Livre{
//un seul attribut supplémentaire : un tableau
//de booléen de la taille du nombre de pages
//définit si la page a été lue ou non
boolean pageColoriee[] ;
//le constructeur qui appelle celui de Livre
//Notons que la taille du tableau de booléen est
//initialisée dans ce constructeur en fonction
//des paramètres passés au constructeur
public Album(String t, String a, double p, int
nb){ super(t,a,p,nb) ;
pageColoriee=new boolean[nb] ;
for(int i=0 ;i<nb ;i++)
pageColoriee[i]=false ;
}
//la méthode qui colorie une page : mettre à
//vrai la valeur du tableau page Coloriee si ce
//n’a pas été fait
public void colorie(int numPage){
if(pageColoriee[numPage]==false)&&!estNeuf()
{pageColoriee[numPage]=true ;}
else { System.out.println("page"+numPage+ "déjà
coloriee : ");
System.out.println();
}
}
}
// La classe principale d’appel
public class Test{
public static void main (String[] args){
//céation de deux variables de type Livre
Livre l1= new Livre("le petit prince","st Exupéry",
10.40,30);
Livre l2= new Livre("Contes","Grimm", 14.40,250);
//on affiche les caractéristiques de chacun
L1.afficher();
-15/17-
 L1.acheter("moi");
L1.afficher();
L1.prix=0.0;
L2.acheter("lui");
L2.afficher();
//creation de deux variables de type BD
BD b1=new BD("Lucky Luke","Morris", 10.40,45, true);
BD b2=new BD("Tintin","Herge", 200.40,50, false);
//”moi” achete deux BD b1 et b2
b1.acheter("moi");
b1.afficher();
b2.acheter("moi");
b2.afficher();
//”moi” revend à “lui” b2
b2.revendre(“moi”,10.4);
b2.afficher();
// on teste la function d’échange de b1 et b2
b1.echanger(b2);
System.out.println("APRES ECHANGE DE"+b1.titre+" et
"+b2.titre);
b1.afficher();
b2.afficher();
//on teste si la method de coloriage d’une page
//fonctionne
Album a1= new Album("Dora","Dora", 3.5,300);
a1.afficher();
a1.colorie(23);
a1.acheter("moi");
a1.colorie(23);
//on crée un objet film
Film f=new Film(“Taxi”,”Besson”,20,90);
f.afficher();
}
}
Editions :

Titre : Le petit prince

Auteur : St Exupéry
Prix : 10.4
Aucun proprietaire
Titre : Le petit prince
Auteur : St Exupéry
Prix : 10.4
Proprietaire : moi
Titre : Contes
Auteur : Grimm
Prix : 14.4
Proprietaire : lui

Titre : Lucky Luke

Auteur : Morris
Prix : 10.4
Proprietaire : moi
Tritre : Tintin
-16/17-
Auteur : Herge
Prix : 200.4
Proprietaire : moi

Tritre : Tintin
Auteur : Herge
Prix : 200.4
Proprietaire : lui

Prix égaux : échange possible

APRES ECHANGE DE Lucky Luke et Tintin
Titre : Lucky Luke
Auteur : Morris
Prix : 10.4
Proprietaire : lui

Titre : Tintin
Auteur : Here
Prix : 10.4
Proprietaire : moi

Titre : Dora
Auteur : Dora
Prix :3.5
Aucun proprietaire
Page 23 déjà coloriee

Titre : Taxi
Auteur : Besson
Prix : 20
Aucun proprietaire

-17/17-