C098f-Java Solutions TD

er
Université Hassan 1
Faculté des Sciences et Techniques
Département Mathématiques et Informatique
Filière : GI 2014/2015
Programmation Orientée Objet en Java
SOLUTIONS DES TRAVAUX DIREGES
Filière : Cycle d’ingénieur
Génie Informatique
Professeur BALOUKI Youssef
1
er
Programmation Orientée Objet en Java
Solution : TD n° 1
EXERCICE 1 Priorités des opérateurs arithmétiques et parenthèses

Éliminer les parenthèses superflues dans les expressions suivantes (l’ordre des calculs devant rester le même) :
(a + b) - (2 * c) ; (2 * x) / (y * z) ; (x + 3) * (n%p) ; (-a) / (-(b + c)) ; (x/y)%(-z) ; x/(y%(-z)) ;

a = (x+5) ; a = (x=y)+ 2 ; a = (x = (y+2)) ; (a<b) && (c<d) ; (i++) * (n+p) ; x += (n%p) ;
Solution :
a + b - 2 * c // expression 1
2 * x / (y * z) // expression 2
On pourrait aussi écrire cette expression 2*x/y/z mais l’ordre des calculs sera différent, ce qui
peut avoir une légère incidence sur le résultat.
(x + 3) * (n%p) // expression 3
Ici aucune parenthèse ne peut être supprimée car * et % sont de même priorité ; la suppression
de la seconde paire de parenthèses conduirait à une expression équivalent à : ((x+3)*n)%p.
-a / -(b + c) // expression 4
Ne pas oublier que l’opérateur unaire - est prioritaire sur tous les opérateurs arithmétiques à
deux opérandes.
x/y%-z // expression 5
x/(y%-z) // expression 6
EXERCICE 2 Conversions implicites

A) Soit ces déclarations :
byte b1 = 10, b2 = 20 ;short p = 200 ; int n = 500 ; long q = 100 ; float x = 2.5f ; double y = 5.25 ;
Donner le type et la valeur des expressions arithmétiques suivantes :
b1+b2; p+b1 ; b1*b2 ; q+p*(b1+b2); x+q*n ; b1*q/x ; b1*q*2./x ; b1*q*2.f/x ;
Solution :
b1+b2 = 30 // 1
L’opérateur + soumet les valeurs de b1 et b2 à la promotion numérique de byte en int. Le
résutat est de type int.
p+b1 = 210 // 2
L’opérateur + soumet ses opérandes à des promotions numériques : de short en int pour p et de
byte en int pour b1. Le résultat est de type int.
b1*b2 = 200 // 3
Là encore, avant d’effectuer le produit, les valeurs de b1 et de b2 sont soumises à la promotion
numérique de byte en int. Le résultat est de type int.
q+p*(b1+b2) = 6100 // 4
On évalue tout d’abord la somme s=b1+b2, en soumettant les valeurs des deux opérandes aux
promotions numériques de byte en int. La valeur de s est de type int. Puis on effectue la somme
q+p en soumettant le second opérande à une conversion d’ajustement de type de short en long
(type de q). Le résultat est de type long. Il faut maintenant le multiplier par s, ce qui se fait en
soumettant la valeur de s à une conversion d’ajustement de type de int en long. Le résultat final
est de type long.
x+q*n =50002.5 // 5
On évalue tout d’abord le produit q*n en soumettant la valeur de n à une conversion d’ajustement
de type de int en long. Le résultat est de type long. Pour pouvoir l’ajouter à la valeur de
x, on le soumet à une conversion d’ajustement de type de long en float. Le résultat est de type
float.
b1*q/x=400.0 // 6
On évalue tout d’abord le quotient q/x en soumettant la valeur de q à une conversion d’ajustement
de type de long en float. Le résultat est de type float. Pour pouvoir lui ajouter la valeur de
2
er
b1, on soumet cette dernière à une conversion d’ajustement de type de byte en float (ou, ce qui
revient au même, d’abord à une promotion numérique de byte en int, puis à une conversion
d’ajustement de type de int en float). Le résultat est de type float.
b1*q*2./x=800.0 // 7
On évalue tout d’abord le produit q*2., en soumettant la valeur de q à une conversion d’ajustement
de type de long en double (attention, la constante 2. est de type double et non de type
float). Le résultat est de type double. Il est divisé par la valeur obtenue par conversion d’ajustement
de type de x de float en double. Le résultat, de type double est alors multiplié par la
valeur obtenue par conversion d’ajustement de type de b1 en double. Le résultat est de type
double.
b1*q*2.f/x=800.0 // 8
Il s’agit de l’expression précédente, dans laquelle la constante 2. (de type double) est
remplacée par 2.f de type float. La même démarche s’applique, en substituant le type float au
type double. Le résultat final est de type float.
-------
B) Soit ces déclarations :
char c = 60, ce = 'e', cg = 'g' ; byte b = 10 ;
Donner le type et la valeur des expressions suivantes :
c+1; 2*c; cg – ce ; b*c;
Solution :
c + 1 = 61
L’opérateur + soumet ici son premier opérande à la promotion numérique de char en int, ce
qui fournit la valeur 601. Le résultat est de type int.
2 * c = 120
L’opérateur * soumet ici son second opérande à la promotion numérique de char en int, ce qui
fournit la valeur 602. Le résultat est de type int.
cg - ce = 2
L’opérateur - soumet ici ses deux opérandes à la promotion numérique de char en int. On
obtient un résultat de type int qui représente l’écart entre les codes des caractères g et e (dans
le code Unicode, les lettres consécutives d’une même casse ont des codes consécutifs).
b * c = 600
L’opérateur * soumet ici ses deux opérandes aux promotions numériques : de byte en int pour
le premier, de char en int pour le second. On notera qu’aucun problème de dépassement de
capacité n’apparaît puisque le produit est bien effectué dans le type int (il en irait différemment
s’il était effectué dans le type byte puisque 600 n’est pas représentable dans ce type).
C) Soit ces déclarations :
byte b ; short p ; int n ; long q ;final int N=10 ; float x ; double y ;
Parmi les expressions suivantes, lesquelles sont incorrectes et pourquoi ? Lorsque l’expression est correcte, citer
les conversions éventuellement mises en jeu.
b=n; b = 25 ; b = 500 ; x = 2*q ; y = b*b ; p = b*b ; b = b+5 ; p = 5*N-3 ;
Solution :
b = n ; // 1 Erreur
La conversion de int en byte n’est pas autorisée par affectation.
b = 25 ; // 2 OK
D’une manière générale, la conversion de int en byte n’est pas acceptée par affectation. Mais
une exception a lieu pour les expressions constantes (calculables à la compilation), à condition
que leur valeur soit représentable dans le type d’arrivée, ce qui est manifestement le cas ici.
b = 500 ; // 3 Erreur
On est dans la même situation que précédemment, avec cette différence que la valeur 500 n’est
pas représentable dans le type byte.
x = 2*q ; // 4 OK
Ici, l’expression 2*q est évaluée en effectuant la conversion d’ajustement de type de 2 en long.
3
er
Puis le résultat, de type long, est converti dans le type float avant d’être affecté à x.
y = b*b ; // 5 OK
La valeur de l’expression b*b est évaluée en effectuant la promotion numérique de b en int. Le
résultat, de type int, est converti dans le type double avant d’être affecté à y.
p = b*b ; // 6 Erreur
Là encore, la valeur de l’expression b*b est de type int. La conversion de int en short est illégale
par affectation.
b = b+5 ; // 7 Erreur
La valeur de l’expression b+5 est de type int. La conversion de int en short est illégale par
affectation.
p = 5*N-3 ; // 8 OK
L’expression 5*N-3 est de type int. Mais comme il s’agit d’une expression constante (calculable
à la compilation), sa conversion en short est légale par affectation pour peu que sa valeur
soit représentable dans ce type, ce qui est le cas ici.
Exercice 3
Quels résultats fournit ce programme ?
public class CourCir
{ public static void main (String args[])
{ int i=10, j=5 ;
if (i<5 && j++<10) System.out.println ("&&1 vrai") ;

else System.out.println ("&&1 faux") ;
System.out.println ("i = " + i + " j = " + j) ;
if (i<5 & j++<10) System.out.println ("& vrai") ;

else System.out.println ("& faux") ;
if (i<15 && j++<10) System.out.println ("&&2 vrai") ;

else System.out.println ("&&2 faux") ;
if (i<15 || j++<10) System.out.println ("|| vrai") ;

else System.out.println ("|| faux") ;
int n=10, p=5, q=10 ;

n=p=q=5;
n += p += q ;
System.out.println ("A : n = " + n + " p = " + p + " q = " + q) ;
q = n < p ? n++ : p++ ;
System.out.println ("B : n = " + n + " p = " + p + " q = " + q) ;
q = n > p ? n++ : p++ ;
System.out.println ("C : n = " + n + " p = " + p + " q = " + q) ;
}
}
Solution :
&&1 faux
i = 10 j = 5
& faux
i = 10 j = 6
&&2 vrai
i = 10 j = 7
|| vrai
i = 10 j = 7
Il faut simplement tenir compte de la proprité particulière dont bénéficient les opérateurs &&
et || dits à court-circuit. Ils n’évaluent leur second opérande que lorsque cela est nécessaire.
----
A : n = 15 p = 10 q = 5
B : n = 15 p = 11 q = 10
C : n = 16 p = 11 q = 15
4
er
Solution : TD n° 2
EXERCICE 1 : Ecrire une classe implantant une pile d’éléments. On considère

qu’un élément de pile encapsule une valeur entière.
1. Définir la classe ElementPile qui représente un élément d’une pile. Les

attributs de cette classe seront privés. Définir les constructeurs et les
accesseurs de cette classe.
2. Comment représenter la pile vide ?
3. Définir la classe Pile. Le constructeur de cette classe construira la pile vide.
4. Définir une méthode permettant de tester si une pile est vide.
5. Définir la méthode empile(ajoute un élément au sommet de la pile)
6. Définir la méthode depile (retourne le sommet et le retire de la pile)
7. Définir la méthode sommet (retourne le sommet de la pile sans le retirer).
8. Définir dans la classe Pile la méthode affiche qui affiche le contenu d’une
pile, sans le modifier.
Tester la création d’une pile et sa manipulation en empilant puis dépilant divers

éléments.
Solution :
------------------------ Classe Pile.java ---------------------------------

public class Pile {
private int pos; // position dans le tableau
private ElementPile [] p;
public Pile () { // creation d’une pile vide de taille 10
p = new ElementPile[10];
pos = 0;
}
public Pile (int taille) { // creation d’un pile vide de taille donnee
p = new ElementPile[taille];
}
public void empile (ElementPile e) {
if (pos == p.length) { // plus d’espace
ElementPile[] tmp = new ElementPile[p.length+10];
for (int i = 0; i < p.length; i++) tmp[i] = p[i];
p = tmp;
}
p[pos++] = e;
}
public ElementPile depile () {
5
er
return p[--pos];
}
public ElementPile sommet () {

return p[pos-1];
}
public boolean estVide () {
return pos == 0;
}
public void affiche () {
System.out.print("Pile: [");
for (int i = pos-1; i >= 0; i--) p[i].affiche ();
System.out.println (" ]");
}
}
------------------------------Classe Pile.java ------------------------

------------------------------Classe ElementPile.java--------------
public class ElementPile {
private int valeur;
public ElementPile () {
this.valeur = 0;
}
public ElementPile (int valeur) {
this.valeur = valeur;
}
public int getValue () {
return valeur;
}
public void affiche () {
System.out.print (" "+valeur);
}
}
-----------------------------------Fin Classe ElementPile.java --------------------------
EXERCICE 2 : Ecrivez une classe Point avec les attributs suivants:
 x: abscisse du point,
 y: ordonnée du point.
La classe Point doit disposer des constructeurs suivants:
 Point(): constructeur par défaut
6
er
 Point(x, y),
 Point(Point).
La classe Point doit contenir des accesseurs et mutateurs pour les différents
attributs. Elle doit aussi contenir les méthodes:
 distance(x, y),
 distance(Point),
 distance(x1, y1, x2, y2): version statique,
 deplacer(x, y),
 translater(dx, dy),
 toString(): donne une représentation d'un point.
Ecrivez aussi une classe testPoint afin de tester la classe Point.

Solution :
Spécifiez l’interface publique d’un objet Point :

public double getX()
public double getY()
public void setX(double newX)
public void setY(double newY)
public void translater(double dx,double dy)
.
Spécifiez les profiles des constructeurs de la classe Point
public Point() // construit l’origine
public Point(double someX, double someY)
public Point(Point p) // copy-constructor
Implémentez la classe Point en écrivant le corps des méthodes de l’interface publique

public class Point {
private double x;
private double y;
public Point() {
this.x = 0.;
this.y = 0.;
}
public Point(double someX, double someY) {
this.x = someX;
this.y = someY;
}
public Point(Point p) {
this.x = p.x;
this.y = p.y;
}
public double getX() {
return this.x;
7
er
}
public double getY() {
return this.y;
}
public void setX(double newX) {

this.x = newX;
}
public void setY(double newY) {
this.y = newY;
}
public void translater(double dx, double dy) {
this.x += dx;
this.y += dy;
}
}
La classe de test TestPoint de la classe Point
public class TestPoint {
public static void main(String[] args) {
Point p = new Point();
double expected = 0.;
double value = p.getX();
value = p.getY();
p = new Point(3.,2.);
Point p2 = new Point(p);
p.setX(4.);
expected = 4.;
value = p.getX();
p = new Point(2.,3.);
p.translater(4.,7.);
double exp1 = 2.+4.;
double exp2 = 3.+7.;
double v1 = p.getX();
double v2 = p.getY();
}
}
Solution : TD n° 3
EXERCICE 1 :
import java.io.* ;
public class Console {
public static void printString(String myStr){
System.out.println(myStr) ;
8
er
}
public static String readString() throws IOException {
String myStr = null ;
BufferedReader inputStream = new BufferedReader(new
InputStreamReader(System.in)) ;
myStr = inputStream.readLine() ;
return myStr ;
}
public static void printInt(int myInt){
System.out.println(myInt) ;
}
public static int readInt() throws IOException , NumberFormatException {
int n = Integer.parseInt(readString()) ;
return n ;
}
1. Ecrire dans une classe séparée un programme principal permettant de tester ces
méthodes.
// fichier TestConsole.java
public class TestConsole {
public static void main(String[] argv){
try{
Console.printString("Saisissez une chaine") ;
String myStr = Console.readString() ;
Console.printString("Vous avez saisi : "+ myStr ) ;
Console.printString("Saisissez un nombre") ;
int n = Console.readInt() ;
Console.printString("Vous avez saisi : "+ n ) ;
}
catch(Exception e){
// affichage sur la sortie d'erreur standard.
// on peut aussi utiliser System.out.println
System.err.println(e) ;
}
}
}
2. Définir deux nouvelles classes d'exceptions, ReadStringException et ReadIntException

qui étendent la classe Exception, et modifiez les méthodes readString et readInt afin de les
utiliser.
Le message de ces exceptions doit décrire la raison pour laquelle la méthode échoue.
// fichier ReadIntException.java
public class ReadIntException extends Exception {
public ReadIntException(String message) {
super(message);
// TODO Auto-generated constructor stub
}
}
// fichier ReadStringException.java
public class ReadStringException extends Exception {
public ReadStringException(String message) {
super(message);
9
er
// TODO Auto-generated constructor stub

}
}
/**
* Lit une chaine sur l'entree standard.
* @throws IOException si l'opération de lecture echoue.
*/
public static String readString() throws ReadStringException {
String myStr = null ;
BufferedReader inputStream = new BufferedReader(new InputStreamReader(System.in)) ;
try{
myStr = inputStream.readLine() ;
}
catch(IOException e){
throw new ReadStringException("La lecture a échoué") ;
}
return myStr ;
}
/**
/**
* Lit un entier sur l'entree standard.
* @throws IOException si l'opération de lecture echoue.
* @throws NumberFormatException si la suite de caracteres lus ne correspond pas a un entier.
*/
public static int readInt() throws ReadIntException {
int n = 0 ;
try{
n = Integer.parseInt(readString()) ;
}
// exception eventuellement levee par readString()
catch(ReadStringException e){
throw new ReadIntException("La lecture a ¶echou¶e") ;
}
// exception eventuellement levee par Integer.parseInt
catch(NumberFormatException e){
throw new ReadIntException("Ce n'est pas un nombre entier") ;
}
return n ;
}
----------------
Exercice 2
Expliquer le comportement des programmes.
Programme 1:
class Essai1Exception extends Exception{
Essai1Exception(String s){
super(s) ;}
}
class Essai2Exception extends Essai1Exception{
super(s) ;}
}
public class Exn{
static void throwEssais(int i) throws Exception {
switch (i){
case 1:
10
er
System.out.println("Lancement de Essai1Exception") ;
throw new Essai1Exception ("Essai1Exception de throwEssais") ;
case 2:
default:
System.out.println("Lancement de Exception") ;
throw new Exception("Exception de throwEssais") ;
}}
public static void main(String[] args){
for (int i = 1 ; i <=3 ; i++){
try {
Exn.throwEssais(i) ;
}
catch (Essai2Exception e){ System.out.println("Catch Essai2: " + e.getMessage()) ;
}
catch (Essai1Exception e){ System.out.println("Catch Essai1: " + e.getMessage()) ;
}
catch (Exception e){ System.out.println("Catch Exception : " + e.getMessage()) ;
}
finally { System.out.println("Finally de main.") ;
}
}
}
}
Programme 2:

super(s) ;
}
}
super(s) ;
}
}
public class Exnbis{
static void throwEssais(int i) throws Exception {
switch (i){
case 1:
case 2:
new Essai2Exception ("Essai2Exception de throwEssais") ;
default:
System.out.println("Lancement de Exception") ;
throw new Exception("Exception de throwEssais") ;
}
}
public static void main(String[] args){
for (int i = 1 ; i <=3 ; i++){
11
er
try {
throwEssais(i) ;
}
catch (Essai1Exception e){ System.out.println("Catch Essai1: " +
e.getMessage()) ;
}
catch (Essai2Exception e){ System.out.println("Catch Essai2: " +
e.getMessage()) ;
}
catch (Exception e){ System.out.println("Catch Exception : " +
e.getMessage()) ;
}
finally { System.out.println("Finally de main.") ;
}
} }}
---------------------
Correction : Faites tourner le programme et regardez comment sont définis les types des
exceptions :
**dans le premier exemple, Essai2Exception est un sous type de Essai1Exception qui est un
sous type de Exception. Le premier bloc catch récupère donc à la fois les exceptions
Essai2Exception et Essai1Exception.
** dans le deuxième exemple, Essai2Exception n'est pas un sous type de Essai1Exception.

C'est donc le deuxième bloc catch qui récupère une Essai2Exception.
Regardez ce qui se passe si dans le programme principal, on déplace le troisième bloc catch
en première position.
12
er
Solution TD 4 : Calcul du coût de transport
Classe : Marchandise
public class Marchandise {

public int numero ;
public double poids ;
public double volume;
public Marchandise(){
this.numero = 0;
this.poids = 0;
this.volume =0;
}
public Marchandise(int n,double p, double v){
this.numero = n;
this.poids = p;
this.volume =v;
}
public int getNumero() {
return numero;
}
public void setNumero(int numero) {
this.numero = numero;
}
public double getPoids() {
return poids;
}
public void setPoids(double poids) {
this.poids = poids;
}
public double getVolume() {
return volume;
}
public void setVolume(double volume) {
this.volume = volume;
}
public String toString() {

return "Marchandise [numero=" + numero + ", poids=" + poids +
", volume="+ volume + "]";
}}
Classe Cargaison (Classe Abstraite)
import java.util.ArrayList;
import java.util.Iterator;
13
er
public abstract class Cargaison {

public double distance;
public ArrayList <Marchandise> vectt = new
ArrayList<Marchandise>();
public Cargaison(double distance) {

super();
this.distance = distance;
}
public void ajouter(Marchandise m){
vectt.add(m);
public void afficher(){

Iterator<Marchandise> i = vectt.iterator();
while (i.hasNext())
System.out.println(i.next().toString());
public abstract double cout();
public String retourner(int num){
Marchandise mar ;
Iterator <Marchandise> i = vectt.listIterator();
while (i.hasNext()){
mar =i.next();
if(mar.numero == num ){
return mar.toString();
}
}
return "Non Trouvée !!! ";
}}
Classe CargaisonRoutiere
public class CargaisonRoutière extends Cargaison {
public CargaisonRoutière(double distance) {
super(distance);
}
14
er
public double cout() {

double c =0;
double v = 0,p=0;
Iterator<Marchandise> it = vectt.iterator();
while(it.hasNext()){
v+=it.next().volume;
p+=it.next().poids;
}
if(v< 380000 )
{System.out.println("poid :"+p+"volume"+v);
c = 4*distance*p;}
else c = 6*distance*p;
return c;
}
}
Classe CargaisonAérienne
public class CargaisonAérienne extends Cargaison {
public CargaisonAérienne(double distance) {
super(distance);
}
public double cout() {
double c =0,v = 0,p=0;
Iterator<Marchandise> it = vectt.iterator();
while(it.hasNext()){
v+=it.next().volume;
p+=it.next().poids;
}
if(v< 80000)
c = 10*distance*p;
else c = 12*distance*p;
return c;
}
Application :
public class ApplicationCoutTransport {

public static void main(String[] args) {
//*** création des marchandises
Marchandise m = new Marchandise(1,2.0,30.01);
Marchandise m2 = new Marchandise(22,21.2,31.1);
Marchandise m3 = new Marchandise(31,32.01,33);
15
er
Marchandise m4 = new Marchandise(41,42.23,43);

//*** creation d'une cargaison routière
CargaisonRoutière cr = new CargaisonRoutière(300);
//*** ajout des marchandises à la cargaison crée
cr.ajouter(m);cr.ajouter(m2);cr.ajouter(m3); cr.ajouter(m4);
//***affichage de l'ensemble des marchandises contenues ds cette

cargaison
cr.afficher();
//*** affichage du côut de cette cargaison
System.out.println(" le côut est : "+cr.cout() + " $");
//*** recherche d'une marchandise ds une cargaison par son numéro
System.out.println(" la marchandise cherchée est :
"+cr.retourner(41));
}}
16
er
Solution : TD n° 5
17
er
18
er
19
er
20
er
1. Java est un langage

(a) Compilé
(b) Interprété
(c) compilé et interprété
(d) Ni compilé ni interprété
2. Java est un langage développé par
21
er
(a) Hewlett-Packard
(b) Sun Microsystems
(c) Microsoft
(d) Oracle
3. Combien d’instances de la classe A crée le code suivant?
A x,u,v;
x=new A();
A y=x;
A z=new A();
(a) Aucune
(b) Cinq
(c) Trois
(d) Deux
4. Pour la classe B définie comme suit:
class B {
public B() {System.out.print("Ciao");};
public B(int i) {this(); System.out.println("Bonjour "+i);};
}
Qu’affichera l’instruction suivante :
B monB = new B(2003);
(a) erreur de compilation

(b) erreur d’exécution (c)
CiaoBonjour 2003
(d) Bonjour 2003
5.
(a) Une classe peut implémenter plusieurs interfaces mais doit étendre une seule classe
(b) Une classe peut implémenter plusieurs classes mais doit étendre une seule interface
(c) Une classe peut implémenter plusieurs classes et peut étendre plusieurs interfaces
(d) Une classe doit implémenter une seule interface et étendre une seule classe
6. La liaison tardive est essentielle pour assurer
(a) l’encapsulation
(b) le polymorphisme
(c) l’héritage
(d) la marginalisation
7. Etant donné que la classe Grande étend la classe Petite, trouvez une ligne correcte
parmi les suivantes
(a) Petite y =new Petite(); Grande x= (Grande)y; Petite z=x;

(b) Grande x= new Grande(); Petite y = x; Grande z=(Grande)y;
(c) Grande x= new Grande(); Petite y = x; Grande z=y;
(d) Petite y =new Petite(); Grande x= (Grande)y; Petite z=(Petite)x;
22
er
8. Pour la classe C définie comme suit:
class C {
public static int i;
public int j;
public C() {i++; j=i; }
}
Qu’affichera le code suivant?
C x=new C(); C y=new C(); C z= x;

System.out.println(z.i + " et " + z.j);
(a) 2 et 2
(b) 1 et 1
(c) 2 et 1
(d) 1 et 3
9. Pour les classes A et B définies comme suit:
class A { class B extends A {

public int x; public B() {x++;}
public A() {x=5; } public B(int i){this(); x=x+i; }
} public B(String s){super(); x--};}
B b1=new B(); B b2 =new B(2003); B b3= new B(”Bonjour”); x=1;x=2004;x=4

System.out.println(b1.x + " et" + b2.x + " et encore " + b3.x );
(a) 6 et 2009 et encore 4

(b) 1 et 2004 et encore 4
(c) 1 et 2004 et encore 2003
(d) autre chose
10. Pour les classes Ma et B définies comme suit:
class Ma { class B extends Ma {

public int f() {return(5) ;} public int f() {return(2) ;}
public static int g() {return (6);} } public static int g() {return (4); }}
B b=new B(); Ma m =b; System.out.println(m.f()*m.g());
(a) 30 (b) 20 (c) 8 (d) 12
23

C098f-Java Solutions TD

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

C098f-Java Solutions TD

Transféré par

Droits d'auteur :

Formats disponibles

er

Programmation Orientée Objet en Java

SOLUTIONS DES TRAVAUX DIREGES

Filière : Cycle d’ingénieur

Professeur BALOUKI Youssef

Département Mathématiques et Informatique

Programmation Orientée Objet en Java

EXERCICE 1 Priorités des opérateurs arithmétiques et parenthèses

(a + b) - (2 * c) ; (2 * x) / (y * z) ; (x + 3) * (n%p) ; (-a) / (-(b + c)) ; (x/y)%(-z) ; x/(y%(-z)) ;

EXERCICE 2 Conversions implicites

b1+b2; p+b1 ; b1*b2 ; q+p*(b1+b2); x+q*n ; b1*q/x ; b1*q*2./x ; b1*q*2.f/x ;

c+1; 2*c; cg – ce ; b*c;

C) Soit ces déclarations :

byte b ; short p ; int n ; long q ;final int N=10 ; float x ; double y ;

b=n; b = 25 ; b = 500 ; x = 2*q ; y = b*b ; p = b*b ; b = b+5 ; p = 5*N-3 ;

if (i<5 && j++<10) System.out.println ("&&1 vrai") ;

if (i<5 & j++<10) System.out.println ("& vrai") ;

if (i<15 && j++<10) System.out.println ("&&2 vrai") ;

if (i<15 || j++<10) System.out.println ("|| vrai") ;

int n=10, p=5, q=10 ;

EXERCICE 1 : Ecrire une classe implantant une pile d’éléments. On considère

1. Déﬁnir la classe ElementPile qui représente un élément d’une pile. Les

Tester la création d’une pile et sa manipulation en empilant puis dépilant divers

------------------------ Classe Pile.java ---------------------------------

public ElementPile sommet () {

------------------------------Classe Pile.java ------------------------

-----------------------------------Fin Classe ElementPile.java --------------------------

EXERCICE 2 : Ecrivez une classe Point avec les attributs suivants:

Ecrivez aussi une classe testPoint afin de tester la classe Point.

Spécifiez l’interface publique d’un objet Point :

Implémentez la classe Point en écrivant le corps des méthodes de l’interface publique

public void setX(double newX) {

2. Définir deux nouvelles classes d'exceptions, ReadStringException et ReadIntException

// TODO Auto-generated constructor stub

class Essai1Exception extends Exception{

** dans le deuxième exemple, Essai2Exception n'est pas un sous type de Essai1Exception.

Solution TD 4 : Calcul du coût de transport

public class Marchandise {

public String toString() {

Classe Cargaison (Classe Abstraite)

public abstract class Cargaison {

public Cargaison(double distance) {

public void afficher(){

public abstract double cout();

public String retourner(int num){

public double cout() {

public class ApplicationCoutTransport {

Marchandise m4 = new Marchandise(41,42.23,43);

//***affichage de l'ensemble des marchandises contenues ds cette

1. Java est un langage

2. Java est un langage développé par

Qu’affichera l’instruction suivante :

B monB = new B(2003);

(a) erreur de compilation

6. La liaison tardive est essentielle pour assurer

(a) Petite y =new Petite(); Grande x= (Grande)y; Petite z=x;

8. Pour la classe C définie comme suit:

Qu’affichera le code suivant?

C x=new C(); C y=new C(); C z= x;

9. Pour les classes A et B définies comme suit:

class A { class B extends A {

Qu’affichera le code suivant?

B b1=new B(); B b2 =new B(2003); B b3= new B(”Bonjour”); x=1;x=2004;x=4

b1+b2; p+b1 ; b1b2 ; q+p(b1+b2); x+qn ; b1q/x ; b1q2./x ; b1q2.f/x ;

c+1; 2c; cg – ce ; bc;

b=n; b = 25 ; b = 500 ; x = 2q ; y = bb ; p = bb ; b = b+5 ; p = 5N-3 ;