POO : TP01

EXO 2.1
package TP1poo;
import [Link];
public class MaClasseTP1 {
public static void main(String[] args) {
// TODO Auto-generated method stub
int a, b, s;
// Création d'un objet Scanner pour lire les entrées de l'utilisateur
Scanner valeur = new Scanner([Link]);
// Demande de saisie pour la variable a
[Link]("Entrez la première valeur (a) : ");
a = [Link]();
// Demande de saisie pour la variable b
[Link]("Entrez la deuxième valeur (b) : ");
b = [Link]();
// Calcul de la somme
s = a + b;
// Affichage du résultat
[Link]("La somme de a et b est : " + s);
// Fermeture du scanner (recommandé)
[Link]();
}
}
EXO 2.2
package TP1poo;
import [Link]; // Importation de la classe Scanner pour la saisie utilisateur
public class MaClasseTP1 {
public static void main(String[] args) {
// Création d'un objet Scanner pour lire l'entrée utilisateur
Scanner valeur = new Scanner([Link]);
// Demande à l'utilisateur d'entrer une température en Celsius
[Link]("Entrez la température en degrés Celsius : ");
double celsius = [Link]();
// Conversion en Fahrenheit
double fahrenheit = celsius * 9.0 / 5.0 + 32;
// Affichage du résultat
[Link]("température en Fahrenheit est : " + fahrenheit + "°F");
// Fermeture du Scanner
[Link]();
}
}
EXO 2.3
package TP1poo;
import [Link]; // Import pour la saisie utilisateur
public class MaClasseTP1 {
public static void main(String[] args) {
final double TVA = 20.0; // Constante pour le taux de TVA
// Création de l'objet Scanner
Scanner valeur = new Scanner([Link]);
// Demande du prix hors taxe (HT)
[Link]("Entrez le prix HT : ");
double prixHT = [Link]();
// Calcul du prix TTC
double prixTTC = prixHT + (prixHT * TVA / 100);
// Affichage du résultat
[Link]("Le prix TTC est : " + prixTTC + " D.A");
// Fermeture du Scanner
[Link]();
}
}
EXO 2.4
a = (b+5); = a = b+5;
a = (b=s) + 2; <> a = b = s + 2;
boolean n = (a==b); = boolean n = (a==b);
a = (a++)*(b+s); = a = a++ * (b+s); = a = a*(b+s);
a = a++ <> a++
a = b++ = a=b ; b++ ;

Exercice 2.5:
Déduire d’une manière théorique (sur un papier) le résultat du code suivant. Comparer
ensuite
votre réponse au résultat issu de sa compilation et exécution.
int i, j, n ;
i = 0 ; n = i++ ;
// n reçoit la valeur actuelle de i soit 0 n=0 // i est incrémenté i=1
[Link]("A : i=" + i + " n=" + n ) ; i = 1, n = 0
i = 10 ; n = ++ i ;
// i est incrémenté i=11 // n reçoit la nouvelle valeur de i n=11
[Link]("B : i=" + i + " n=" + n ); // i = 11, n = 11
i = 20 ; j = 5 ; n = i++ * ++ j ;
// utilisation de la valeur actuelle de i pour le calcul i=20
// i est incrémenté i=21 // j est incrémenté j=6
// utilisation de la nouvelle valeur de j pour le calcul j=6 // n = 20 * 6 = 120
[Link]("C : i=" + i + " j=" + j + " n=" + n ) ; // i = 21, j = 6, n = 120
i = 15 ; n = i += 3 ;
// i+=3 équivalant à i= i + 3 // i = 15 +3 // i = 18 ;
// n reçoit la nouvelle valeur de i // n = 18 ;
[Link]("D : i=" + i + " n=" + n ) ; // i = 18, n = 18
i = 3 ; j = 5 ; n = i *= --j ;
// --j décrémente j de 1 doc j reçoit la valeur j=4 ;
// i*=j-- ; équivaut à i=i*(--j) ; i devient i=3*4=12 ;
// la valeur de i est affectée a n // n=12 ;
[Link]( "E : i=" + i + " j=" + j + " n=" + n ) ; // i = 12, j = 4, n = 12

Exercice 2.6:
Voir le code suivant, même tâche à faire que celle de l’exercice précédent :
int n=10, p=5, q=10, r;
r = (int) (p = q) ;
// p reçoit la valeur de q // p=10
// La nouvelle valeur de p (10) est castée en type INT (changement de type) // r= 10
[Link]("A:n=" + n + " p=" + p + " q=" + q+ " r=" + r );//n=10 p=10 q=10 r=10
n = p = q = 5 ;
n += p += q ;
// L'expression n=p=q=5; affecte 5 à q, puis à p, puis à n // n=5 p=5 q=5
// L’opérateur d'affectation composés (+=) s'évalue de droite à gauche.
// D'abord, on calcule p+=q // p+=q équivaut à p=p+q ; // p = 5 + 5 = 10
// L'expression p+=q retourne 10 (la nouvelle valeur de p)
// Ensuite, on effectue n+= (p += q) // n+=10 équivaut à n=n+10 // n=5+10=15 ;
[Link]( "B : n=" + n + " p=" + p + " q=" + q ); // n=15 p=10 q=5
q = n < p ? n++ : p++ ;
// Opérateur ternaire n<p ? n++ : p++ // Equivaut à FONCTION IF ELSE
// La condition n<p est évaluée : Est-ce que 15 < 10 ? Faux.
// On prend donc la branche else qui exécute p++
// (q=) La valeur actuelle de p (10) est utilisée pour l'affectation à q // q=10
// (p++) Ensuite, p est incrémenté de 1 et devient p=11.
[Link]("C : n=" + n + " p=" + p + "q= " + q ) ; // n=15 p=11 q= 10
q = n > p ? n++ : p++ ;
// La condition n > p est évaluée : Est-ce que 15 > 11 ? Vrai
// On prend la branche then qui exécute n++
// (q=) La valeur actuelle de n (15) est utilisée pour l'affectation à q // q=15
// (n++) Ensuite, n est incrémenté de 1 et devient n=16
[Link]( "D : n="+ n + " p=" + p + " q=" + q ) ; // n=16 p=11 q=15
Exercice 2.7:
Compiler le code suivant, observer et expliquer le résultat.
int n, p, q ; boolean k;
n = 5 ; p = 2 ;
k= n++ > p || p++ != 3 ;
// n++ le post-incrémente de n (5) est utilisée dans l'expression, puis n est incrémenté.
// Comparaison : 5 > 2 vrai // Après cette évaluation, n devient 6.
// || ou logique et court-circuit .coté gauche vrai , le coté droit ne va pas êtes évalué
// ainsi l’expression p++ != 3 n'est pas exécutée et p reste 2.
// k devient true
[Link]( "A : n = " + n + " p = " + p + " k = " + k ) ; //n = 6 p = 2 k = true
n = 5 ; p = 2 ;
k = n++ <p || p++ != 3 ;
// n++ retourne 5 (puis n passe à 6). // Comparaison : 5 < 2 faux.
// Puisque le côté gauche est faux, l'opérateur || évalue le côté droit.
// Côté droit p++ != 3 // p++ retourne 2 (puis p devient 3) // Comparaison : 2 != 3 vrai.
// k=true
[Link]( "B : n = " + n + " p = " + p + " k = " + k ); // n = 6 p = 3 k = true
n = 5 ; p = 2 ;
k = ++n == 3 && ++p == 3 ;
// ++n est le pré-incrément : n passe de 5 à 6, puis cette valeur est utilisée.
// Comparaison : 6 == 3 faux.
// && (ET logique) et court-circuit.
// Étant donné que le côté gauche est faux, le côté droit (++p == 3) n'est pas évalué.
// Donc, p reste 2 // k=false
[Link]( "C : n = " + n + " p = " + p + " k = " + k ) ;//n = 6 p = 2 k = false
n = 5 ; p = 2 ;
k = ++n == 6 && ++p == 3 ;
// ++n incrémente n de 5 à 6 et retourne 6 // Comparaison : 6 == 6 vrai.
// Puisque le côté gauche de && est vrai, le côté droit est évalué
// ++p incrémente p de 2 à 3 et retourne 3
// Comparaison : 3 == 3 vrai // true && true, donne true doc k=true
[Link]( "D : n = " +n + " p = " + p + " k = " + k ) ; // n = 6 p = 3 k = true