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
public class sommeWhile {
public static void main(String[] args) {
int i;
int somme;
somme = 0;
i = 1;
while (i <= 100) {
somme = somme + i;
i = i + 1;
}
[Link]("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=[Link](args[0]);
if(s==0)
[Link]("Factroielle de 0 est 1");
else
for (int i=1;i<=s;i++)
{
f=f*i;
[Link]("Fatorielle de "+i+" est "+f);
}
Exercice 3 : Palindrome
package essai;
public class palindromeSansEspace {
static String inverse(String s){
int lenght= [Link]();
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]= [Link](i);
}
1
String inv = new String(table);
return(inv);
}
public static void main(String[] args) {
double b= [Link](args[0]);
String s = args[0];
String inv = inverse(s);
[Link]("L'inverse de " + s + " est " + inv);
if([Link](inv))
[Link](s + " est un palindrome");
else
[Link](s + " n'est un palindrome");
}
//////////////////////////// with espace
package essai;
import [Link];
public class palindromeWithEspace {
String enleveEspaces(String s) {
int i, longueur;
StringBuffer sansEspaces = new StringBuffer();
longueur = [Link]();
for (i = 0; i < longueur; i++)
if ([Link](i) != ' ') [Link]([Link](i));
return new String(sansEspaces);
}
public static void main(String[] args) {
Scanner entree = new Scanner([Link]);
[Link]("Indiquez la chaine de caracteres");
String chaine = [Link]();
String sansEspace = enleveEspaces(chaine);
String inverse = [Link](sansEspace);
if ([Link](inverse))
[Link]("\"" + chaine + "\" est un palindrome");
else
[Link]("\"" + chaine + "\" n'est pas un palindrome");
}
Exercice 4 : Une classe pour modéliser un segment
package segment;
public class Segment {
private int extr1, extr2;
public Segment(int e1, int e2) {
extr1 = e1;
extr2 = e2;
ordonne();
}
2
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 + "]";
}
}
////////////Deuxième class TestSegment
package segment;
public class TestSegment {
public static void main(String[] args) {
Segment s = new Segment([Link](args[0]),
[Link](args[1]));
int point;
[Link]("Longueur du " + s + " : " + [Link]());
point = [Link](args[2]);
if ([Link](point))
[Link](point + " appartient au " + s);
else
[Link](point + " n'appartient pas au " + s);
}
3
Exercice 5 : Une classe pour modéliser un vecteur
package veteur;
public class Vecteur {
private int x;
private int y;
// Constructeur
public Vecteur(int x, int y) {
this.x = x;
this.y = y;
}
// Méthode d'instance pour calculer la longueur du vecteur
public double longueur() {
return [Link](x * x + y * y);
}
// Méthode d'instance pour comparer si ce vecteur est plus petit qu'un autre
public boolean plusPetitQue(Vecteur autre) {
return [Link]() < [Link]();
}
// Méthode d'instance pour additionner ce vecteur avec un autre
public void addition(Vecteur autre) {
this.x += autre.x;
this.y += autre.y;
}
// Méthode statique pour additionner deux vecteurs et retourner le résultat
public static Vecteur addition(Vecteur vecteur1, Vecteur vecteur2) {
int newX = vecteur1.x + vecteur2.x;
int newY = vecteur1.y + vecteur2.y;
return new Vecteur(newX, newY);
}
// Redéfinition de la méthode toString pour afficher le vecteur sous forme de chaîne
@Override
public String toString() {
return "vecteur (" + x + ", " + y + ")";
}
////////////Deuxième class EssaiVecteur
package veteur;
public class EssaiVecteur {
public static void main(String[] args) {
if ([Link] != 4) {
[Link]("Veuillez fournir 4 entiers pour les composantes de deux
vecteurs.");
return;
}
// Convertir les arguments en entiers
int x1 = [Link](args[0]);
int y1 = [Link](args[1]);
int x2 = [Link](args[2]);
int y2 = [Link](args[3]);
4
// Créer deux vecteurs avec les composantes fournies en ligne de commande
Vecteur vecteur1 = new Vecteur(x1, y1);
Vecteur vecteur2 = new Vecteur(x2, y2);
// Tester les opérations
[Link]("v1 : "+ vecteur1);
[Link]("Longueur de "+ vecteur1+" : " + [Link]());
[Link]("v2 : "+ vecteur2);
if([Link](vecteur2))
[Link]("Le " + vecteur1 + " est plus petit que le "+vecteur2);
else
[Link]("Le " + vecteur2 + " est plus petit que le "+vecteur1);
[Link](vecteur2);
[Link]("v1 après addition de v2 : " + vecteur1);
Vecteur resultat = [Link](vecteur1, vecteur2);
[Link]("v3 = v1 + v2 : " + resultat);
}
}
Exercice 6 : Les complexes
Exercice 7 : manipuler des tableaux
package tableau;
public class ManipTableau {
private int[] tab ;
ManipTableau(int n)
{
// alloue un tableau de dimension n
tab = new int[n];
}
static int randomInt (int a,int b)
{
//renvoie un int entre a et b inclus
double random1=[Link]();
//génère un nombre aléatoire à virgule flottante compris entre 0 (inclus) et 1
(exclus). Par exemple, [Link]() peut retourner 0.234567.
int temp=(int)(([Link]((a-b-1))*random1)+a);
return(temp);
}
void remplir ()
{
// remplit le tableau par des valeurs générés aléatoirement entre 0 et 100.
for(int i=0;i<[Link];i++)
tab[i]= randomInt(0,100);
float moyenne ()
{
5
// calcule la moyenne du tableau
float moy;
moy = (float) somme()/[Link];
return moy;
}
int somme ()
{
//calcule la somme des éléments du tableau
int som = 0;
for(int i=0;i<[Link];i++)
som+=tab[i];
return som;
}
int max()
{
//retourne la valeur maximale
int max = tab[0];
for(int i=1;i<[Link];i++)
if(tab[i] > max)
max=tab[i];
return max;
}
int min()
{
//retourne la valeur minimale
int min = tab[0];
for(int i=1;i<[Link];i++)
if(tab[i] < min)
min=tab[i];
return min;
}
int rechercher( int e)
{
//recherche l’indice de l’élément e sinon elle retourne -1
for(int i=0;i<[Link];i++)
if(tab[i] == e)
return i;
return -1;
}
void affiche(String separateur)
{
// affiche les éléments du tableau séparés par le « séparateur »
for(int i=0;i<[Link];i++)
[Link](tab[i] + separateur) ;
}
public int[] maxMin() {
int[] tt = new int[2];
tt[0]=max();
tt[1]=min();
return tt;
}
/*4 question: Créez une méthode dans la classe ManipTableau appelée minmax2
qui permet de passer des paramètres pour stocker les valeurs min et max
et qui ne renvoie aucune valeur.*/
/*void minmax(int a, int b){
a= max();
b= min();
}*/
6
/*==> solution incorrecte: Le passage des variables de type primitif comme
paramètres se fait par valeur : une modification de cette variable dans une fonction est
locale à cette dernière et non répercutée sur le programme appelant */
/*void minmax(Integer a, Integer b){
a= max();
b= min();
}*/
/*==> solution incorrecte: car les objets de type Integer sont immuables*/
void minmax(int[] tt){
tt[0]= max();
tt[1]= min();
}
/*Le passage des tableaux comme paramètres se fait par adresse (référence): On
peut accéder et modifier les valeurs du tableau passé comme paramètre.*/
//Le passage de paramètres par adresse: Envelopper le type primitif dans une classe
void minmax2(TestMM t){
[Link]= max();
[Link]= min();
}
//Deuxième class EssaiManipTableau
package tableau;
public class EssaiManipTableau {
public static void main(String[] args) {
// TODO Auto-generated method stub
ManipTableau tab = new ManipTableau(10);
[Link]();
[Link](" ; ");
[Link]("La moyenne = "+[Link]());
[Link]("La somme = "+[Link]());
//1ere méthode maxMin
[Link](" 1ere methode: Max = "+[Link]()[0]+ " Min =
"+[Link]()[1]);
//2eme méthode
int[] tt = new int[2];
[Link](tt);
[Link]("2éme methode: Max = "+ tt[0]+ " Min = "+tt[1]);
//3eme méthode
TestMM valeursMinMax = new TestMM();
tab.minmax2(valeursMinMax);
[Link]("3 eme méthode: Max = "+[Link]+ " Min =
"+[Link]);
int e= [Link](args[0]);
if([Link](e)!=-1)
[Link](e +" se trouve dans l'indice "+[Link](e));
else
[Link](e+" n'existe pas dans le tableau");
7
}
//3eme class TestMM
package tableau;
public class TestMM {
int min;
int max;
Exercice 8 : Gérer une pile d'entiers
package pile;
public class Pile {
private int[] pile; //tableau d'éléments de type entier
private int sommet; //L'indice de l'élément le plus récemment ajouté à la pile:
l'élément en haut de la pile
public Pile(int max) {
[Link] = new int[max];
[Link] = -1;
}
public Pile() {
this(100); // Par défaut, une pile de 100 entiers
}
private void erreur(String message) {
[Link]("Erreur : " + message);
}
public void empiler(int n) {
if (estPleine()) {
erreur("La pile est pleine. Impossible d'empiler.");
} else {
sommet++;
pile[sommet] = n;
}
}
public int depiler() {
if (estVide()) {
erreur("La pile est vide. Impossible de dépiler.");
return -1; // Valeur par défaut en cas d'erreur
} else {
int valeurDepilee = pile[sommet];
sommet--;
return valeurDepilee;
}
}
public boolean estVide() {
return sommet == -1;
}
public boolean estPleine() {
return sommet == [Link]- 1;
}
8
public void listerPile() {
if (estVide()) {
[Link]("La pile est vide.");
} else {
[Link]("Contenu de la pile :");
for (int i = sommet; i >= 0; i--) {
[Link](pile[i]);
}
}
}
////Deuxième class EssaiPile
package pile;
public class EssaiPile {
public static void main(String[] args) {
Pile maPile = new Pile(5);
[Link]();
[Link](10);
[Link](20);
[Link](30);
[Link]();
int valeurDepilee = [Link]();
[Link]("Valeur dépilée : " + valeurDepilee);
[Link]();
}
Exercice 9 : Manipulation de dates
package date;
public class Date {
private int jour;
private int mois;
private int an;
public Date(int j, int m, int an) {
jour = j;
mois = m;
[Link] = an;
}
public String toString() {
return jour + "/" + mois + "/" + an;
}
public boolean bissex() {
return (an % 4 == 0 && an % 100 != 0) || (an % 400 == 0);
}
9
public int nbJoursEcoules() {
int joursEcoules = 0;
for (int i = 1; i < mois; i++) {
if (i == 2) {
joursEcoules += bissex() ? 29 : 28;
/*L'opérateur ternaire ? permet d'exprimer une condition.
* Dans ce cas, la condition est le résultat de l'appel à bissex().
* Si la condition est vraie (true), le résultat de l'opération
* ternaire sera la valeur après le ?, c'est-à-dire 29.
* Si la condition est fausse (false), le résultat sera
* la valeur après les : (deux-points), c'est-à-dire 28.*/
} else if (i == 4 || i == 6 || i == 9 || i == 11) {
joursEcoules += 30;
} else {
joursEcoules += 31;
}
}
joursEcoules += jour;
return joursEcoules;
}
public int nbJoursrestants() {
int joursRestants = 0;
for (int i = mois; i <= 12; i++) {
if (i == 2) {
joursRestants += bissex() ? 29 : 28;
} else if (i == 4 || i == 6 || i == 9 || i == 11) {
joursRestants += 30;
} else {
joursRestants += 31;
}
}
joursRestants -= jour;
return joursRestants;
}
public static boolean bissex(int annee) {
return (annee % 4 == 0 && annee % 100 != 0) || (annee % 400 == 0);
}
/*la première méthode public boolean bissex() est utilisée pour vérifier
* si une année est bissextile en utilisant l'année stockée dans une instance
* spécifique de la classe Date, tandis que la seconde méthode public static
* boolean bissex(int annee) est utilisée pour effectuer la vérification
* de bissextile pour n'importe quelle année sans nécessiter d'instance
* de la classe Date. */
public static long nbJoursEntre(Date date1, Date date2) {
long joursEntre = 0;
Date start = date1;
Date end = date2;
if ([Link] > [Link] || ([Link] == [Link] && [Link] > [Link])
|| ([Link] == [Link] && [Link] == [Link] && [Link] >
[Link])) {
start = date2;
end = date1;
10
}
for (int i = [Link]; i < [Link]; i++) {
joursEntre += bissex(i) ? 366 : 365;
}
joursEntre -= [Link]();
joursEntre += [Link]();
return joursEntre;
}
//Deuxième class EssaiDate
package date;
public class EssaiDate {
public static void main(String[] args) {
[Link]("Bissextile 1900 : " + [Link](1900));
[Link]("Bissextile 1920 : " + [Link](1920));
[Link]("Bissextile 1989 : " + [Link](1989));
[Link]("Bissextile 2000 : " + [Link](2000));
[Link]("Bissextile 2003 : " + [Link](2003));
Date date = new Date(3, 2, 2003);
[Link]("Au " + [Link]());
[Link]("Nombre de jours écoulés : " + [Link]());
[Link]("Nombre de jours restants : " + [Link]());
Date date1 = new Date(1, 1, 1900);
Date date2 = new Date(1, 1, 2000);
long joursEntre = [Link](date1, date2);
[Link]("Nombre de jours écoulés entre le "+date1+" et le "+date2+" =
"+ joursEntre);
}
}
11