TD_N°5_Solution_Java_S5_2012_2013

SMI – S5 Solution du TD-5 POO - Java, 2012-2013 1
Université Mohammed Premier Année universitaire 2012-2013
Faculté des Sciences Filière : SMI
Département de Mathématiques Module : POO Java
et d’Informatique Semestre : S5
Responsable du cours : El Mostafa DAOUDI
Solution TD: Série Numéro 5
Exercice 1 :
1. Définir une méthode, nommée « memeClasse() », pour tester si 2 objets passés en argument
appartiennent ou non à la même classe.
2. Redéfinir la méthode « memeClasse() » pour tester si un objet « objO » est de la même classe que
l'objet courant ( l’objet qui appelle la méthode « memeClasse() »).
Solution :
class TestObjet {
// question 1
public static boolean memeClasse(Object o1, Object o2) {
if ((o1 != null && o2 != null) && (o1.getClass() == o2.getClass())){
return true;
}
else
return false;
}
// question 2
public boolean memeClasse(Object o) {
if ((o != null) && (o.getClass() == this.getClass())){
return true;
}
else
return false;
}
}
/* Pour les tests, on suppose qu’on a trois classes ClassA, ClassB et ClassC, puis on compare
des instances de ces trois classes */
public class TestMemeClass {
public static void main(String[] args) {
Object objA = new ClassA();
Object objB = new ClassB();
Object objC = new ClassC();
Object objAA = new ClassA();
boolean b1 = TestObjet.memeClasse(objA, objB); // b1=false
boolean b2 = TestObjet.memeClasse(objA, objAA); // b2=true
boolean b3 = TestObjet.memeClasse(objB, objC); // b3=false
System.out.println("b1= "+b1+" b2= "+b2+" b3= "+b3);
}
}
Exercice 2 :

SMI – S5 Solution du TD-5 POO - Java, 2012-2013 2
Ecrire une classe qui a deux méthodes:
- Une méthode qui prend en paramètre une chaine « s » de type String et un caractère « ch » et qui
retourne le nombre de caractères « ch » présents dans la chaine « s » en utilisant la méthode indexOf().
- La méthode main() dans laquelle on récupère les paramètres « s » et « ch » sur la ligne de commande.
- Réécrire la méthode main() dans afin que les paramètres soient lus au clavier.
Solution1:
/* Dans cette solution, on suppose que la chaîne « s » à traiter et le caractère « ch » à
chercher dans la chaine « s », sont obtenus sur la ligne de commande. */
import java.io.*;
public class TestIndexOf {
public static int nbCaracteres(String s, char ch) {
int cp=0;
int n;
while((n=s.indexOf(ch))!=-1) {
cp++;
s=s.substring (n+1);
}
return cp;
}
public static void main(String[] args) throws IOException {
try {
String s = args[0];
char ch= args[1].charAt(0);
int cp = nbCaracteres(s, ch);
System.out.println("cp= "+cp );
} catch (ArrayIndexOutOfBoundsException exc) {
System.out.println("Nombre d'arguments doit être égal à 2");
}
}
}
Solution2
/*Dans cette solution, on suppose que la chaîne « s » à traiter et le caractère «ch» à chercher
dans la chaine « s », sont lus au clavier (on peut aussi utiliser la classe «Scanner»). */
import java.io.*;
public class TestIndexOf {
public static int nbCaracteres(String s, char ch) {
int cp=0;
int n;
while((n=s.indexOf(ch))!=-1) {
cp++;
s=s.substring (n+1);
}
return cp;
}
public static void main(String[] args) throws IOException {
InputStreamReader in = null;
BufferedReader tampon = null;
try {
/* ouverture du flux de caractères : la source de données à connecter au flux est
le clavier représenté par le nom de fichier logique « System.in » */
in = new InputStreamReader(System.in);
// Connecte le flux avec le tampon
tampon = new BufferedReader(in);
/* Remarque : les deux instructions peuvent être écrites en une seule instruction

SMI – S5 Solution du TD-5 POO - Java, 2012-2013 3
BufferedReader tampon = new BufferedReader(new InputStreamReader(System.in)); */
System.out.print("Entrez Une chaine:");
String s = tampon.readLine();
System.out.print("Entrez un caractère :");
int n = tampon.read();
char ch=(char)n;
int cp = nbCaracteres(s, ch);
System.out.println("cp= "+cp ); // affiche n=3
} catch (IOException ioe) {
System.out.print("Erreure de lecture au clavier :");
//System.err.println(ioe);
}
finally {
try {
tampon.close();
in.close();
} catch (IOException exception1) {
System.out.print("Erreure de fermeture des flux :");
exception1.printStackTrace();
}
}
}
}
Exercice 3:
Le but est de définir une classe qui calcule et affiche xn où x est un réel et n étant un entier strictement
positif.
1. Dans ce premier cas, on ne se préoccupe pas des cas d'erreurs qui peuvent se produire. Ecrire une
classe nommée CalcPuissance qui a deux méthodes:
- Une méthode non récursive nommée « puiss()» qui prend « x » et « n » en paramètres et qui
retourne xn.
- Une méthode récursive nommée « puissIter()» qui prend « x » et « n » en paramètres et qui
retourne xn.
- La méthode main(). Pour les tests, on suppose que x et n sont fournis en ligne de commande.
2. Dans le deuxième cas on s’intéresse aux erreurs qui peuvent se produire, en particulier:
- Si le nombre d’arguments est < 2, le programme affiche le message suivant : « Le nombre
d’arguments est <2 : Donner sur la ligne de commande un réel suivi d’un entier».
- Si les arguments fournis ne correspondent pas à un double suivi d’un entier (puissance), le
programme affiche le message suivant : «Mauvais format des arguments : Donner sur la ligne
de commande un réel suivi d’un entier ».
- Si n est négatif, le programme affiche le message suivant : «La puissance n doit être un entier
strictement positif ».
- Si la puissance n est trop grande (le résultat retourné est erroné), le programme affiche le
message suivant : « La puissance n est trop grande »
Solution
Question 1
public class CalcPuissance {
public static double puiss(double x, int n){
if (n==1)
return x;
else {
return x*puiss(x, n-1);
}
}
public static double puissIter(double x, int n){

SMI – S5 Solution du TD-5 POO - Java, 2012-2013 4
double p=1;
for(int i=1;i<=n;i++)
p=p*x;
return p;
}
public static void main(String[] args) {
double x=Double.parseDouble(args[0]);
int n=Integer.parseInt(args[1]);
double r=puiss(x,n);
System.out.println("r recurssive = "+r);
double ri=puissIter(x,n);
System.out.println("r itératif = "+ri);
}
}
Question 2 :
class ExceptionNegatif extends Exception {}
class ExceptionGrand extends Exception {}
public class Exercice2 {
public static double puiss(double x, int n)throws ExceptionNegatif, ExceptionGrand {
if (n<0) throw new ExceptionNegatif();
if (n==1)
return x;
else {
double r1=puiss(x, n-1);
double r=x*r1;
if (r/r1!=x) throw new ExceptionGrand();
return x*puissExcp(x, n-1);
}
}
public static double puissIter(double x, int n)throws ExceptionNegatif, ExceptionGrand {
if (n<0) throw new ExceptionNegatif();
double p=1, p1=1;
for(int i=1;i<=n;i++){
p=p*x;
if (p/p1!=x) throw new ExceptionGrand();
p1=p;
}
return p;
}
public static void main(String[] args) {
try {
double x=Double.parseDouble(args[0]);
int n=Integer.parseInt(args[1]);
double r=puiss(x,n);
System.out.println("puissance recurssive = "+r);
double ri=puissIter(x,n);
System.out.println("la puissance itérative = "+ri);
}
catch(ArrayIndexOutOfBoundsException exc){
System.out.println("Nb arguments est <2: Donner un réel suivi d’un entier. ");
}
catch (NumberFormatException e){
System.out.println(" Mauvais format: Donner un réel suivi d’un entier ");
}

SMI – S5 Solution du TD-5 POO - Java, 2012-2013 5
catch (ExceptionNegatif e){
System.out.println(" La puissance n doit être un entier strictement positif ");
}
catch (ExceptionGrand e){
System.out.println(" La puissance n est trop grande ");
}
}
}
Exercice 4 :
Ecrie une classe nommée « Copie » tel que si la commande
> java Copie fichier1 fichier2
Copie le fichier « fichier1 » dans « fichier2 ».
Solution 1 :
/* En utilisant les flux d’Octets */
import java.io.*;
public class TestEntreeSortie {
public static void main(String[] args) throws IOException {
FileInputStream in = null;
FileOutputStream out = null;
try {
String fich1=args[0];
String fich2=args[1];
in = new FileInputStream(fich1);
out = new FileOutputStream(fich2);
int c;
while ((c = in.read()) != -1)
out.write(c);
}
catch (IOException e) {
System.out.println("Problème d'ouverture de fichier ");
}
finally {
try {
in.close();
out.close();
}
catch(IOException e){
System.out.println("Problème de fermeture de fichier ");
}
}
}
}
Solution 2 :
/* En utilisant les flux à tampon d’Octets */
import java.io.*;
public class TestEntreeSortie {
public static void main(String[] args) throws IOException {
FileInputStream in = null;
FileOutputStream out = null;
BufferedInputStream tamponIn = null;
BufferedOutputStream tamponOut=null;
try {