Travaux pratiques JAVA :

Série N° : 4

Filières : SMI, IGE: S5

Module : POO JAVA

DEVELOPPER LES EXERCICES SUIVANTS AVEC JAVA

EXERCICE 1:
Soit le type structure enreg défini ainsi :
const int NMOIS = 12 ;
struct enreg
{ int stock ;
float prix ;
int ventes [NMOIS]
}
a) Écrire une fonction nommée raz qui « met à zéro » les champs stock et ventes d’une
structure de ce type, transmise en argument. La fonction ne comportera pas de
valeur de retour.
b) Écrire un petit programme d’essai qui affecte tout d’abord des valeurs aux différents
champs d’une telle structure, avant de leur appliquer la fonction raz. On affichera
les valeurs de la structure, avant et après appel (on pourra s’aider d’une fonction
d’affichage)

EXERCICE 2 : Définition d’une classe dérivée, droits d’accès

On dispose de la classe suivante :
class Point {
public void initialise (int x, int y) { this.x = x ; this.y = y ; }
public void deplace (int dx, int dy) { x += dx ; y += dy ; }
public int getX() { return x ; }
public int getY() { return y ; }
private int x, y ;
}
a) Réaliser une classe PointA, dérivée de Point disposant d’une méthode affiche
affichant (en fenêtre console) les coordonnées d’un point. Ecrire un petit programme
utilisant les deux classes Point et PointA.
b) Que se passerait-il si la classe Point ne disposait pas des méthodes getX et getY ?

EXERCICE 3 : Définition d’une classe dérivée, droits d’accès

On dispose de la classe suivante :

class Point
{ public void setPoint (int x, int y) { this.x = x ; this.y = y ; }
2019-2020 Prof. S.KRIT Page 1
public void deplace (int dx, int dy) { x += dx ; y += dy ; }
public void affCoord ()
{ System.out.println ("Coordonnees : " + x + " " + y) ;
}
private int x, y ;
}
Réaliser une classe PointNom, dérivée de Point permettant de manipuler des points
définis par deux coordonnées (int) et un nom (caractère). On y prévoira les méthodes
suivantes :
• setPointNom pour définir les coordonnées et le nom d’un objet de type PointNom,
• setNom pour définir seulement le nom d’un tel objet,
• affCoordNom pour afficher les coordonnées et le nom d’un objet de type PointNom.
Écrire un petit programme utilisant la classe PointNom.

EXERCICE 4 : Héritage et appels de constructeurs

On dispose de la classe suivante (disposant cette fois d’un constructeur) :

class Point
{ public Point (int x, int y) { this.x = x ; this.y = y ; }
public void affCoord()
{ System.out.println ("Coordonnees : " + x + " " + y) ;
}
private int x, y ;
}
Réaliser une classe PointNom, dérivée de Point permettant de manipuler des points
définis par leurs coordonnées (entières) et un nom (caractère). On y prévoira les
méthodes suivantes :
• constructeur pour définir les coordonnées et le nom d’un objet de type PointNom,
• affCoordNom pour afficher les coordonnées et le nom d’un objet de type PointNom.
Écrire un petit programme utilisant la classe PointNom.
EXERCICE 5: Redéfinition

On dispose de la classe suivante :

class Point
{ public Point (int x, int y) { this.x = x ; this.y = y ; }
public void affiche()
{ System.out.println ("Coordonnees : " + x + " " + y) ;
}
private int x, y ;
}
Réaliser une classe PointNom, dérivée de Point permettant de manipuler des points
définis par leurs coordonnées et un nom (caractère). On y prévoira les méthodes
suivantes :
• constructeur pour définir les coordonnées et le nom d’un objet de type PointNom,
• affiche pour afficher les coordonnées et le nom d’un objet de type PointNom

2019-2020 Prof. S.KRIT Page 2

 SOLUTIONS
EXERCICE 1 :

Ici, pour que la fonction puisse modifier la valeur d’une structure reçue en argument, il est nécessaire qu’elle en reçoive, soit
la référence, soit l’adresse. Voici un exemple complet utilisant la première possibilité :
=======================================JAVA=====================================

package serie3;
import java.util.*;

publicclass enreg {
inti;
intNMOIS=12;
intstock;
floatprix;
intventes[]=newint[NMOIS];

void raz(enreg n)
{
n.stock=0;
for(i=0;i<4;i++)
n.ventes[i]=0;
return;
}
void affiche(enreg n)
{
System.out.println("stock: "+n.stock);
System.out.println("prix: "+prix);
for(i=0;i<4;i++)
{
System.out.println("ventes["+i+"]=" +n.ventes[i]);

}}

publicstaticvoid main(String[] args) {

Scanner sc=new Scanner(System.in);
int i = 0;
enreg e1=new enreg();

System.out.println("entrer le stock: ");

e1.stock= sc.nextInt();

System.out.println("entrer le prix: ");

e1.prix=sc.nextFloat();

for(i=0;i<4;i++)
{
System.out.println("entrer les ventes Num:"+i);
e1.ventes[i]=sc.nextInt();
}
System.out.println("===Avant Remise a zero=== ");
e1.affiche(e1);
System.out.println("===Apres Remise a zero=== ");
e1.raz(e1);
2019-2020 Prof. S.KRIT Page 3
 e1.affiche(e1);
}}
===============================C++==================================
#include <iostream>
using namespace std ;
const int NMOIS = 12 ;
struct enreg
{ int stock ;
float prix ;
int ventes [NMOIS] ;
};
void raz (enreg & s)
{ s.stock = 0 ;
for (int i=0 ; i<NMOIS ; i++)
s.ventes[i] = 0 ;
return ;
}
void affiche (enreg s) // transmission par valeur ici
{ cout << "stock : " << s.stock << "\n" ;
cout << "prix : " << s.prix << "\n" ;
cout << "ventes : " ;
for (int i = 0 ; i<NMOIS ; i++) cout << s.ventes[i] << " " ;
cout << "\n" ;
}
main()
{ void raz (enreg &) ;
enreg e = {12, 5.25, {10, 23, 4, 8, 4, 9, 5, 12, 17, 2, 8, 7} } ;
cout << "contenu avant raz :\n" ;
affiche (e) ;
raz (e) ;
cout << "contenu apres raz :\n" ;
affiche (e) ;}
=============================
Voici un exemple d’exécution de ce programme :
contenu avant raz :
stock : 12
prix : 5.25
ventes : 12 23 4 8 4 9 5 2 7 2 8 7
contenu apres raz :
stock : 0
prix : 5.25
ventes : 0 0 0 0 0 0 0 0 0 0 0 0*/

À titre indicatif, voici ce que serait notre fonction raz, avec une transmission par pointeur :

void raz (enreg * ads)

{ ads->stock = 0 ;
for (int i=0 ; i<NMOIS ; i++)
ads->ventes[i] = 0 ;
return ;}
Dans la fonction main, sa déclaration et son appel deviendraient :
2019-2020 Prof. S.KRIT Page 4
void raz (enreg *) ;
raz (&e)
EXERCICE 2 :

=============================JAVA=========================================
Il suffit de définir une classe dérivée en utilisant le mot clé extends. La méthode affiche, comme toute méthode d’une classe
dérivée a accès à tous les membres publics de la classe de base, donc en particulier à getX et getY.
class PointA extends Point{
void affiche()
{ System.out.println ("Coordonnees : " + getX() + " " + getY()) ;
}
}
On peut alors créer des objets de type PointA et leur appliquer aussi bien les méthodes publiques de PointA que celles de Point
comme dans ce programme accompagné d’un exemple d’exécution :

package serie3;
publicclass Point {
publicvoid initialise (int x, int y) { this.x = x ; this.y = y ; }
publicvoid deplace (int dx, int dy) { x += dx ; y += dy ; }
publicint getX() { returnx ; }
publicint getY() { returny ; }
privateintx, y ;
}
class PointA extends Point {
void affiche()
{ System.out.println ("Coordonnees : " + getX() + " " + getY()) ;
}
publicstaticvoid main (String args[])
{ Point p = new Point () ;
p.initialise (2, 5);
System.out.println ("Coordonnees : " + p.getX() + " " + p.getY() ) ;
PointA pa = new PointA () ;
pa.initialise (1, 8) ; // on utiliselamethodeinitialisede Point
pa.affiche() ; // etlamethodeaffichede PointA
}
}
Execution :
Notez bien qu’un appel tel que p.affiche() conduirait à une erreur de compilation puisque la classe de p (Point) ne possède pas
de méthode affiche.
Si la classe Point n’avait pas disposé des méthodes d’accès getX et getY, il n’aurait pas été possible d’accéder à ses champs
privés x et y depuis la classe PointA. Il n’aurait donc pas été possible de la doter de la méthode affiche. L’héritage ne permet pas
de contourner le principe d’encapsulation.
Comme nos classes ne disposent pas de constructeur, il est possible de créer des objets sans les initialiser. Dans ce cas, leurs
champs auront simplement une valeur "nulle", c’est-à-dire ici la valeur entière 0.

=======================C++================
#include <iostream.h>
#include <conio.h>
using namespace std ;
/* Déclaration de la classe point */
class Point{ /* déclaration des membres privés */
private:
2019-2020 Prof. S.KRIT Page 5
int x ;
int y ;
/* déclaration des membres publics */
public :
void initialise (int, int) ;
void deplace (int, int) ;
void affiche () ;
};
//Définition des fonctions membres de la classe
void Point::initialise(int a, int b)
{int x = a; int y = b; }
void Point::deplace(int dx, int dy)
{ x += dx; y += dy; }
/* Déclaration et définition de la classe pointcol */
class pointA : public Point // pointcol dérive de point
{
public:
void affiche() {
cout << "je suis en x = " << x << endl;
cout << "je suis en y = " << y << endl;
}
private:
int x ;
int y ;
};
main()
{
pointA p ;
p.initialise (3,10) ;
p.affiche () ;
p.deplace (20,14) ;
p.affiche () ;
getch();
}

EXERCICE 3 :

Nous définissons une classe dérivée en utilisant le mot clé extends :

class PointNom extends Point
Dans cette classe PointNom, nous introduisons un champ (de préférence privé) destiné à
contenir le nom du point :
private char nom ;

La méthode setNom est triviale. Compte tenu de l’encapsulation des données de Point, nos
deux autres méthodes doivent absolument recourir aux méthodes publiques de Point.
En définitive, voici la définition de notre classe PoitnNom :
===========================JAVA================================
class PointNom extends Point
{ public void setPointNom (int x, int y, char nom)

2019-2020 Prof. S.KRIT Page 6

{ setPoint (x, y) ;
this.nom = nom ;
}
public void setNom(char nom)
{ this.nom = nom ;
}
public void affCoordNom()
{ System.out.print ("Point de nom " + nom + " ") ;
affCoord() ;
}
private char nom ;
}
Voici un programme d’utilisation de PointNom :
package serie3;
publicclass TsPointN {
publicvoid setPoint (int x, int y) { this.x = x ; this.y = y ; }
publicvoid deplace (int dx, int dy) { x += dx ; y += dy ; }
publicvoid affCoord ()
{ System.out.println ("Coordonnees : " + x + " " + y) ;
}
privateintx, y ;
}

class PointNom extends TsPointN {

publicvoid setPointNom (int x, int y, char nom)

{ setPoint (x, y) ;
this.nom = nom ;
}
publicvoid setNom(char nom)
{ this.nom = nom ;
}
publicvoid affCoordNom()
{ System.out.print ("Point de nom " + nom + " ") ;
affCoord() ;
}
privatecharnom ;

publicstaticvoid main (String args[])

{ TsPointN p = new TsPointN () ;
p.setPoint (2, 5) ;
p.affCoord() ;
PointNom pn1 = new PointNom() ;
pn1.setPointNom (1, 7, 'A') ; // methode de PointNom
pn1.affCoordNom() ; // methode de PointNom
pn1.deplace (9, 3) ; // methode de Point
pn1.affCoordNom() ; // methode de PointNom
PointNom pn2 = new PointNom() ;
pn2.setPoint (4, 3) ; // methode de Point
pn2.setNom ('B') ; // methode de PointNom
pn2.affCoordNom() ; // methode de PointNom
pn2.affCoord() ; // methode de Point
}
}
====================================
Coordonnees : 2 5
Point de nom A Coordonnees : 1 7
Point de nom A Coordonnees : 10 10
Point de nom B Coordonnees : 4 3
2019-2020 Prof. S.KRIT Page 7
 Coordonnees : 4 3

1. Ici encore, comme nos classes ne disposent pas de constructeur, il est possible de créer des objets sans les initialiser. Dans ce
cas, leurs champs auront simplement une valeur "nulle", c’est-à-dire ici la valeur entière 0 pour les coordonées et le caractère de
code nul pour le nom.
2. Comme la classe Point ne dispose pas de méthodes d’accès aux coordonnées, on voit que la méthode affCoordNom n’a pas
d’autre possibilité que de recourir à la méthode affCoord de Point, ce qui impose des contraintes sur la présentation des
résultats. En particulier, il serait impossible d’afficher sur une même ligne le nom du point avant les coordonnées.
========================C++================================
#include <iostream.h>
#include <conio.h>
using namespace std ;
class TsPointN
{
private:
int x, y ;
public:
// Déclaration et définition des fonctions
void setPoint (int a, int b)
{x=a;y=b;}
void deplace (int dx, int dy) { x += dx ; y += dy ; }
void affCoord (){ cout<<"Coordonnees : " <<x <<" " <<y <<"\n" ;}
};
/* Déclaration et définition de la classe TsPointN */
class PointNom: public TsPointN
{
public:
void setPointNom (int x, int y, char nom)
{ setPoint (x, y) ;}
public:
void setNom(char nom)
{ nom = nom ;}
public:
void affCoordNom()
{ cout<<"Point de nom " <<nom <<" " ;
affCoord() ;
}
private:
char nom ;
};
main()
{
TsPointN p ;
p.setPoint (2, 5) ;
p.affCoord() ;
PointNom pn1;
pn1.setPointNom (1, 7, 'A') ; // methode de PointNom
pn1.affCoordNom() ; // methode de PointNom
2019-2020 Prof. S.KRIT Page 8
 pn1.deplace (9, 3) ; // methode de Point
pn1.affCoordNom() ; // methode de PointNom
PointNom pn2;
pn2.setPoint (4, 3) ; // methode de Point
pn2.setNom ('B') ; // methode de PointNom
pn2.affCoordNom() ; // methode de PointNom
pn2.affCoord() ; // methode de Point
getch();
}

EXERCICE 4 :

cette fois, les deux classes disposent d’un constructeur.

Celui de la classe dérivée PointNom doit prendre en charge la construction de l’intégralité de l’objet correspondant, quitte à
s’appuyer pour cela sur le constructeur de la classe de base (ce qui est indispensable ici puisque la classe Point ne dispose pas
de méthodes d’accès).
Rappelons que l’appel du constructeur de la classe de base (fait à l’aide du mot clé super) doit constituer la première instruction
du constructeur de la classe dérivée.
En définitive, voici ce que pourrait être la définition de notre classe PointNom :
========================JAVA================================
publicclass Point {
// declaration et definition des membres
public Point (int x, int y) { this.x = x ; this.y = y ; }
publicvoid deplace (int dx, int dy) { x += dx ; y += dy ; }
publicvoidaffCoord ()
{ System.out.println ("Coordonnees : " + x + " " + y) ;
}
privateintx, y ;
}
// Heritage

class PointN extends Point

{
public PointN (int x, int y, char nom)
{ super (x, y) ;
this.nom = nom ;}
publicvoid affCoordNom()
{ System.out.print ("Point de nom: " + nom + " ") ;
affCoord() ; }
privatecharnom ;
publicstaticvoid main(String[] args)
{
System.out.print ("pn1 Avant deplace: ") ;
PointN pn1 = new PointN(1, 7, 'A') ;
pn1.affCoordNom() ; // methodede PointNom
System.out.print ("pn1 Apres deplace: ") ;
pn1.deplace(1,1); // methodede Point
pn1.affCoordNom() ; // methodede PointNom

PointN pn2 = new PointN(4, 3, 'B') ;

System.out.print ("pn2 Avant deplace: ") ;
pn2.affCoordNom() ; // methodede PointNom
pn2.deplace(1,1); // methodede Point
2019-2020 Prof. S.KRIT Page 9
 System.out.print ("pn2 Apres deplace: ") ;
pn2.affCoordNom() ; // methodede PointNom
}
}
pn1 Avant deplace: Point de nom: A Coordonnees : 1 7
pn1 Apres deplace: Point de nom: A Coordonnees : 2 8
pn2 Avant deplace: Point de nom: B Coordonnees : 4 3
pn2 Apres deplace: Point de nom: B Coordonnees : 5 4
========================C++================================
#include <iostream.h>
#include <conio.h>
using namespace std ;
/* Déclaration de la classe point */
class Point
{ /* déclaration des membres privés */
private:
int x ;
int y ;
/* déclaration des membres publics */
public :

void setPoint (int, int) ;

char setNom(char nom);
void deplace (int, int) ;
void affCoord () { cout<<"Coordonnees : " << x << " " << y<<"\n" ; }
};
//Définition des fonctions membres de la classe
void Point::setPoint(int a, int b)
{x = a; y = b; }

void Point::deplace(int dx, int dy)

{ x += dx; y += dy; }

char Point::setNom(char nom)

{char n=nom; return n; }

/* Déclaration et définition de la classe pointcol */

class TsPointN : public Point // TsPointN dérive de Point
{
public:
void setPointNom (int x, int y, char nom)
{ setPoint (x, y), setNom (nom);} //faitappel a deux fonctions
void affCoordNom()
{ cout<<"Point de nom "<<nom << " " ;
affCoord() ;
}

private:
2019-2020 Prof. S.KRIT Page 10
 char nom ;
};
main()
{
Point p;
p.setPoint (2, 5) ; // initialisation de a et b de classe Point
p.affCoord() ; //affichage de a et b, methode de Point
cout<<"===================================="<<"\n";
TsPointN pn1;
pn1.setPointNom (1, 7, 'A') ; // methode de TsPointN
pn1.affCoordNom() ; // methode de TsPointN
pn1.deplace (9, 3) ; // methode de Point
pn1.affCoordNom() ; // methode de PointNom
TsPointN pn2;
pn2.setPoint (4, 3) ; // methode de Point
pn2.setNom ('B') ; // methode de PointNom
pn2.affCoordNom() ; // methode de PointNom
pn2.affCoord() ; // methode de Point

getch();
}
EXERCICE 5 :
Cet exercice est voisin de l’exercice 62. L’écriture du constructeur reste la même. Mais, cette fois, on doit redéfinir la méthode
affiche dans la classe dérivée. L’affichage du nom n’y pose aucun problème :
System.out.print ("Point de nom " + nom + " ") ;
En revanche, il nous faut faire appel à la méthode affiche de la classe de base. Pour ce faire,
nous employons le mot clé super :
super.affiche() ;
En définitive, voici la définition de notre classe, accompagnée d’un petit programme d’utilisation :
class PointNom extends Point
{ public PointNom (int x, int y, char Nom)
{ super (x, y) ;
this.Nom = Nom ;
}
public void affiche()
{ System.out.print ("Point de nom " + Nom + " ") ;
super.affiche() ;
}
private char Nom ;
}
public class TsPointR
{ public static void main (String args[])
{ Point p = new Point (3, 7) ;
p.affiche() ; // methode de Point
PointNom pn = new PointNom(1, 7, 'A') ;
pn.affiche() ; // methode de PointNom
}
}

Coordonnees : 3 7
Point de nom A Coordonnees : 1 7

Ici, la redéfinition de la méthode affiche dans PointNom utilise la méthode affiche de la classeascendante Point, ce qui impose
de recourir au mot clé super. Bien entendu, il n’en ira pastoujours ainsi : rien n’empêche de redéfinir entièrement une méthode
sans chercher à exploitercelle de la classe ascendante

2019-2020 Prof. S.KRIT Page 11