Université Tunis El-Manar

Fac. Sces de tunis

Module : Programmation.O.O
Série N° 1 : Programmation en Java

Exercice 1 : Une somme d'entiers

import java.util.*;
public class sommeWhile {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int i;
int somme;

somme = 0;
i = 1;
while (i <= 100) {
somme = somme + i;
i = i + 1;
}
System.out.println("Voila la somme des 100 premiers entiers : " + somme);
}

Exercice 2 : Une factorielle

public class Factorielle {

public static void main (String[] args)
{
int f=1;
int s=Integer.parseInt(args[0]);
if(s==0)
System.out.println("Factroielle de 0 est 1");
else

for (int i=1;i<=s;i++)

{
f=f*i;
System.out.println(f);
}
}
}

Exercice 3 : Palindrome
public class palindromeSansEspace {

static String inverse(String s){

int lenght= s.length();
char[] table = new char[lenght];
/*tc est un tableau à une dimension de char
Pour allouer l’espace nécessaire au tableau il faut utiliser new :
tc = new char [15];*/

for(int i= lenght-1,j=0; i>=0; i--, j++){

table[j]= s.charAt(i);
}
String inv = new String(table);

1
 return(inv);
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
double b= Double.parseDouble(args[0]);
String s = args[0];
String inv = inverse(s);
System.out.println("L'inverse de " + s + " est " + inv);
if(s.equals(inv))
System.out.println(s + " est un palindrome");
else
System.out.println(s + " n'est un palindrome");

}
//////////////////////////// with espace

package essai;
import java.util.Scanner;
public class palindromeWithEspace {

/**
* @param args
*/
String enleveEspaces(String s) {
int i, longueur;
StringBuffer sansEspaces = new StringBuffer();

longueur = s.length();
for (i = 0; i < longueur; i++)
if (s.charAt(i) != ' ') sansEspaces.append(s.charAt(i));
return new String(sansEspaces);
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner entree = new Scanner(System.in);
System.out.println("Indiquez la chaine de caracteres");
String chaine = entree.nextLine();
String sansEspace = enleveEspaces(chaine);
String inverse = palindromeSansEspace.inverse(sansEspace);
if (sansEspace.equals(inverse))
System.out.println("\"" + chaine + "\" est un palindrome");
else
System.out.println("\"" + chaine + "\" n'est pas un palindrome");
}

Exercice 4 : Une classe pour modéliser un segment

Il s'agit de modéliser un segment de droite dont les valeurs des deux extrémités sont entières. Si on échange les
deux extrémités, on considère qu'il s'agit encore du même segment. Les opérations que l'on souhaite faire sur ce
segment sont :

 calculer sa longueur
2
  savoir si un entier donné se trouve sur le segment (c'est-à-dire s'il est compris entre la plus petite et la plus
valeurs des extrémités du segment).

Ecrire un programme qui contient :

 une classe Segment comportant

o deux attributs de type int, extr1 et extr2, représentant les coordonnées (entières) des extrémités
d'un segment sur un axe
o un constructeur de ce segment recevant en argument les deux valeurs entières des extrémités du
segment que l'on veut construire
o une méthode nommée ordonne échangeant éventuellement les valeurs des extrémités du segment
de telle sorte que la valeur de extr1 soit au plus égale à la valeur de extr2.
o une méthode retournant la longueur du segment
o une méthode dont le prototype est : boolean appartient(int x); indiquant si le point de
coordonnée x appartient ou non au segment
o une méthode redéfinissant la méthode : public String toString() :Celle-ci décrira une
instance de Segment sous la forme d'une chaîne de caractères (par exemple, le segment
d'extrémités -35 et 44 pourra être transformé en la chaîne de caractères : "segment [-35, 44]")
(la plus petite extrémité est toujours indiquée à gauche). La méthode "retournera" (return...)
cette chaîne.
 une classe EssaiSegment testant la classe Segment et comportant une méthode main à laquelle on devra
fournir trois paramètres entiers par la ligne de commande : origine et extrémité d'un segment et coordonnée
d'un point dont on voudra savoir s'il appartient ou non au segment. On utilisera nécessairement la méthode
toString lorsqu'on voudra écrire le segment sur la sortie standard (l'écran).

Exemple d'exécution souhaitée pour la méthode main

Pour la commande :

java EssaiSegment 44 -35 8 :

Longueur du segment [-35, 44] : 79
8 appartient au segment [-35, 44]

Pour la commande :

java EssaiSegment -35 44 100

Longueur du segment [-35, 44] : 79
100 n'appartient pas au segment [-35, 44]

Indication

1. Si la méthode toString est définie comme indiqué ci-dessus, l'instruction :

System.out.println("le " + new Segment(1, 3));

donnera sur la sortie standard (l'écran) : le segment [1, 3].

package segment;

public class Segment {

/**
* @param args
*/
private int extr1, extr2;

public Segment(int e1, int e2) {

extr1 = e1;
3
 extr2 = e2;
ordonne();
}

private void ordonne() {

if (extr1 > extr2){
int tampon;

tampon = extr1;
extr1 = extr2;
extr2 = tampon;
}
}

public void setExtr1(int a) {

extr1 = a;
ordonne();
}

public int getExtr1() {

return extr1;
}

public void setExtr2(int a) {

extr2 = a;
ordonne();
}

public int getExtr2() {

return extr2;
}

public int longueur() {

return extr2 - extr1;
}

public boolean appartient(int x) {

return (x >= extr1) && (x <= extr2) ;
}

public String toString() {

return "segment [" + extr1 + ", " + extr2 + "]";
}
}

package segment;

public class TestSegment {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Segment s = new Segment(Integer.parseInt(args[0]),
Integer.parseInt(args[1]));
int point;
System.out.println("Longueur du " + s + " : " + s.longueur());
point = Integer.parseInt(args[2]);
if (s.appartient(point))
System.out.println(point + " appartient au " + s);
else
System.out.println(point + " n'appartient pas au " + s);
}

4
}

Version avec des attributs privés Dans une seconde écriture de la classe

Segment, on souhaite assurer que extr1 soit toujours plus petit que extr2 ; pour cela, on déclare les attributs
extr1 et extr2 comme privés (avec le modificateur private) ; on permettra alors, bien que ces attributs soient
privés, leur consultation et leur modification, en définissant quatre méthodes (nommées généralement accesseurs)
supplémentaires dans la classe Segment:

 int getExtr1(void);
 void setExtr1(int a);.
 int getExtr2(void);
 void setExtr2(int a);

Dans le main défini dans EssaiSegment, on ajoutera quelques instructions au choix pour tester ces méthodes
supplémentaires.

1/Compléter la squelette de la classe suivante :

class ManipTableau
{private int[] tab ;
ManipTableau(int n){…}// alloue un tableau de dimension n
void remplir (){…}// remplit le tableau par des valeurs générés
aléatoirement entre 0 et 100.
float moyenne (){…}// calcule la moyenne du tableau
int somme (){…} calcule la somme des éléments du tableau
int max(){…} //retourne la valeur maximale
int min(){…} //retourne la valeur minimale
int rechercher( int e){} recherche l’indice de l’élément e sinon elle
retourne -1
void affcihe(String separateur){…}// affiche les éléments du tableau
séparés par le « séparateur »
2/ écrire la classe EssaiManipTableau contenant une méthode main pour tester les méthodes précédemment
définies
3/Faites le nécessaire pour ajouter une méthode maxMin, à la classe ManipTableau, qui retourne à la fois la
valeur min et la valeur max du tableau.

import java.util.Random ;
public class ManipTableau {

/**
* @param args
*/
private int[] tab ;
ManipTableau(int n)
{
tab = new int[n];
}// alloue un tableau de dimension n
static int randomInt (int a,int b) //renvoie un int entre a et b inclus
{ double random1=Math.random();
int temp=(int)((Math.abs((a-b-1))*random1)+a);
return(temp);
}
void remplir ()
{
for(int i=0;i<tab.length;i++)
tab[i]= randomInt(0,100);

5
 }// remplit le tableau par des valeurs générés aléatoirement entre 0 et 100.
float moyenne ()
{
int som = 0;
float moy;
for(int i=0;i<tab.length;i++)
som+=tab[i];
moy = som/tab.length;
return moy;

}// calcule la moyenne du tableau

int somme ()
{
int som = 0;
float moy;
for(int i=0;i<tab.length;i++)
som+=tab[i];
return som;
} //calcule la somme des éléments du tableau
int max()
{
int max = tab[0];
for(int i=1;i<tab.length;i++)
if(tab[i] > max)
max=tab[i];
return max;
} //retourne la valeur maximale
int min()
{
int min = tab[0];
for(int i=1;i<tab.length;i++)
if(tab[i] > min)
min=tab[i];
return min;

} //retourne la valeur minimale

int rechercher( int e)
{
int min = tab[0];
for(int i=0;i<tab.length;i++)
if(tab[i] == min)
return i;
return -1;

} //recherche l’indice de l’élément e sinon elle retourne -1

void affiche(String separateur)
{
for(int i=0;i<tab.length;i++)
System.out.println(tab[i] + separateur) ;
}// affiche les éléments du tableau séparés par le « séparateur »

/*String maxMin(){
String s;

}*/
void minmax(Integer a, Integer b){
a= max();
b=min();
}
void minmax2(int []tt){
tt[0]= max();
tt[1]=min();
}
public static void main(String[] args) {

6
 // TODO Auto-generated method stub

Exercice 1 : Qu'affiche le programme suivant :

1. public class Ex1a {
2. static int f1(int a, int b) {
3. a++ ; b++ ;
4. System.out.println(a+" "+b) ;
5. a=a+b ;
6. return a ;
7. }
8. public static void main(String[] args) {
9. int a=2, b=3 ;
10. System.out.println(a+" "+b) ;
11. f1(b,a) ;
12. System.out.println(a+" "+b) ;
13. b = f1(b,a) ;
14. System.out.println(a+" "+b) ;
15. }
16. }
Exercice 2 : Qu'affiche le programme suivant :
1. public class Ex2a {
2. static void f(int[] a,int i,int k) {a[i] = k ;
3. }
4. public static void printtab(int[] tab) {
5. for(int i=0;i<tab.length;i++)
6. System.out.print(tab[i]+" ") ;
7. System.out.println() ;
8. }
9. public static void main(String[] args) {
10. int[] t = {1,2,3,4,5,6} ;
11. int[] u ;
12. int[] v ;
13. printtab(t) ;
14. f(t,2,12) ;
15. printtab(t) ;
16. u = t ;
17. f(u,1,0) ;
18. printtab(u) ;
19. printtab(t) ;
20. v = (int [])t.clone() ;
21. f(v,0,0) ;
22. printtab(v) ;
23. printtab(t) ;
24.
25. }
26. }

Exercice 5 : Une classe pour modéliser un vecteur

Il s'agit de modéliser un vecteur de Z2 dont l'origine est en (0, 0) (un tel vecteur est donc caractérisé par deux
nombres entiers relatifs). Les opérations que l'on souhaite faire sur ce segment sont :

7
  calculer sa longueur, par une méthode d'instance sans paramètre, nommée longueur, et qui retourne cette
longueur sous forme d'un double
 savoir si le vecteur concerné est ou non plus petit qu'un autre un autre vecteur donné ; on écrira pour cela
une méthode d'instance nommée plusPetitQue qui recevra en paramètre l'autre vecteur et qui retournera
une variable de type boolean
 additionner au vecteur concerné un autre vecteur ; on écrira pour cela une méthode d'instance nommée
addition qui recevra en paramètre l'autre vecteur et qui ne retournera rien
 additionner deux vecteurs donnés ; on écrira pour cela une méthode statique nommée aussi addition (en
utilisant ainsi la possibilité de la surcharge) qui recevra en paramètres les deux vecteurs à additionner et
qui retournera le résultat sous forme d'un objet de type Vecteur
 une méthode redéfinissant la méthode : public String toString()Celle-ci décrira une instance de
Vecteur sous la forme d'une chaîne de caractères (par exemple, le vecteur de composantes 1 et 2 pourra
être décrit par la chaîne de caractères : "vecteur (1, 2)"). La méthode retournera cette chaîne.

On écrira une méthode main pour tester cette classe Vecteur, méthode que l'on écrira à l'intérieur d'une classe
nommée EssaiVecteur. Les composantes des vecteurs à traiter dans les tests pourront être indiquées sur la ligne
de commande. Un exemple d'exécution de ce main peut être :

> java EssaiVecteur 1 2 5 -3

v1 : vecteur (1, 2)
Longueur de vecteur (1, 2) : 2.23606797749979
v2 : vecteur (5, -3)
le vecteur (1, 2) est plus petit que le vecteur (5, -3)
v1 après addition de v2 : vecteur (6, -1)
v3 = v1 + v2 : vecteur (11, -4)

Indications

1. Si la méthode toString est définie comme indiqué ci-dessus et si on a :

Vecteur v = new Vecteur(1, 2);

l'instruction System.out.println(v); donnera sur la sortie standard (l'écran) : vecteur (1, 2) et
l'instruction System.out.println("le joli " + v); donnera sur la sortie standard : le joli
vecteur (1, 2)

Exercice 6 : Les complexes

1- On souhaite manipuler les nombres complexes en java. Ecrire la classe Complexe suivante :
Class Complexe {
Private double pReel ;
Private double pIm ;
public Complexe (double pReel, double pIm) ;
public Complexe (double pReel) ;
public Complexe () ;
public double getRe () ;
public double getIm () ;
public void setRe (double) ;
public void setIm (double) ;
public double module () ;
public double argument () ;
public Complexe oppose () ;
public Comlexe conjuge () ;
public Complexe inverse () ;
public Complexe plus( Complexe c) ;
public Complexe moins ( Complexe c) ;
public Complexe multiplier ( Complexe c) ;
public Complexe diviser ( Complexe c) ;
public static Complexe creerC (double pReel, double pIm) ;
public static Complexe plus (Complexe c1, Complexe c2) ;
public static Complexe moins (Complexe c1, Complexe c2) ;
public static Complexe multiplier (Complexe c1, Complexe c2) ;

8
public static Complexe diviser (Complexe c1, Complexe c2) ;
public String toString() ;
}
2- Ecrire une classe EssaiComplexe qui met en œuvre les différentes méthodes de la classe Complexe.

Exercice 7 : manipuler des tableaux

1/Compléter la squelette de la classe suivante :
class ManipTableau
{private int[] tab ;
ManipTableau(int n)
{…}// alloue un tableau de dimension n
void remplir ()
{…}// remplit le tableau par des valeurs générés aléatoirement entre 0 et 100.
float moyenne ()
{…}// calcule la moyenne du tableau
int somme ()
{…} calcule la somme des éléments du tableau
int max()
{…} //retourne la valeur maximale
int min()
{…} //retourne la valeur minimale
int rechercher( int e)
{} recherche l’indice de l’élément e sinon elle retourne -1
void affcihe(String separateur)
{…}// affiche les éléments du tableau séparés par le « séparateur »
}

2/ écrire la classe EssaiManipTableau contenant une méthode main pour tester les méthodes précédemment
définies

3/Faites le nécessaire pour ajouter une méthode maxMin, à la classe ManipTableau, qui retourne à la fois la
valeur min et la valeur max du tableau.

Exercice 8 : Gérer une pile d'entiers

1/ Il s'agit de définir une classe modélisant une pile d'entiers. Nécessairement, tous les attributs de cette classe
auront le modificateur private, ce qui signifie qu'on ne peut pas les utiliser directement de l'extérieur de la classe
(on dit encore qu'ils ne sont visibles que de leur propre classe). Cette classe possèdera les méthodes suivantes (il
faudra reprendre exactement les en-têtes indiquées) :

 pubic Pile (int max)

 pubic Pile() // construire par défaut une pile de 100 entiers
 private erreur(String message)// Affiche un message d’erreur
 pubic void empiler(int n) : Cette méthode empile la valeur n reçue en paramètre.
 pubic int depiler()
 pubic boolean estVide() : Cette méthode retourne true si la pile est vide et false
dans le cas contraire.
 pubic boolean estPleine()
 pubic void listerPile()// affiche le contenu de la pile

Exercice 9 : Manipulation de dates

1/ On souhaite écrire la classe Date qui gère des dates. Les attributs jour, mois, an sont mémorisés comme
des entiers. Ecrire alors les méthodes « pubiques » suivantes :

 Date (int j, int m, int an) ;

 String toString () ;
 boolean bissex () ;// teste si l’année est bissextile
 int nbJoursEcoules() // nombre de jours écoulés depuis le début de l’année
9
  int nbJoursrestants() // nombre de jours restants dans l’année
 int static boolean bissex(int annee) ;
 static long nbJoursEntre(Date1, Date2)

2/ Ecrire la classe EssaiDate qui permet de donner les résultat de l’exécution suivants :

Bissextile 1900 : false

Bissextile 1920 : true

Bissextile 1989 : false

Bissextile 2000 : true

Bissextile 2003 : false

Au 3/2/2003

Nombre de jours écoulés : 34

Nombre de jours restants :331

Nombre de jours écoulés entre le 1/1/1900 et le 1/1/2000 = 36525

10