Exercice 1

Écrire  un programme en  JAVA  qui permet  d’afficher le message Bonjour.   (Solution)                                        

Exercice 2 

Écrire  un programme en Java permettant de saisir deux nombres et d'afficher leur produit.   (Solution)                                                                            

Exercice 3

Écrire  un programme en Java  qui  permet d'Ă©changer le contenu de deux entiers  A et B  saisis par l'utilisateur. et afficher ces entiers  après l’Ă©change.  (Solution) 


Exercice 4                                                                                     

Écrire un un programme en Java qui  permet d'afficher si un nombre  entier saisi au  clavier est pair ou impair.  (Solution) 

Exercice 5                                                                                      

Écrire un programme en Java  qui permet d'afficher le plus grand de trois entiers saisis  au clavier.  (Solution)

Exercice 6                                                                                      

Écrire un programme en Java  qui permet d'Ă©valuer une note saisi au  clavier   (si la note est supĂ©rieur Ă  10 alors il affiche validĂ© sinon non validĂ©  (NB : la note comprise entre 0 et 20 ).    (Solution)

Exercice 7                                                                                      

Écrire un programme en Java qui demande deux nombres m et n Ă  l’utilisateur et l’informe ensuite si le produit de ces deux nombres est positif ou nĂ©gatif. On inclut dans le programme le cas oĂą le produit peut ĂŞtre nul.     (Solution)

Exercice 8                                                                                     

Écrire un programme en  Java qui permet de calculer la valeur absolue d'un entier saisi  par l'utilisateur. (Solution)

Exercice 9

Écrire un programme en Java qui permet de calculer la moyenne de trois entiers saisis par l'utilisateur.   (Solution)

Exercice 10

Une boutique propose Ă  ces clients, une rĂ©duction de 15% pour les montants d’achat supĂ©rieurs Ă  200 dh. Écrire un programme en Java permettant de saisir le prix total HT et de calculer le  montant TTC en prenant en compte la rĂ©duction et la TVA=20%.   (Solution)

Exercice 11

Le centre de photocopie facture 0,25 DH  pour les 10 premières photocopies, 0,20 DH les vingt suivantes et 0,10 DH  au-delĂ . Ecrire un programme en Java qui demande Ă  l’utilisateur de saisir le nombre de photocopies effectuĂ©es et qui affiche la facture correspondante.  (Solution)   

Exercice 12

Écrire un programme en Java qui demande l'âge d'un enfant et permet d'informer de sa catĂ©gorie sachant que les catĂ©gories sont les suivantes: 
"poussin de 6 a 7 ans"   
"pupille de 8 a 9 ans "   
"minime de 10 a 11 ans "  
" cadet après 12 ans ".   (Solution)

Exercice 13

Écrire un programme en Java permettant d’afficher le mois en lettre selon le numĂ©ro saisi au clavier.  (  Si l’utilisateur tape 1 le programme affiche janvier,  si 2  affiche  fĂ©vrier , si 3 affiche mars... )  (Solution)

Exercice 14

Écrire un programme en Java qui permet  d'afficher  le message   "Bonsoir"  10 fois. Utilisant la boucle while.   (Solution)

Exercice 15

Écrire un programme en Java permettant de calculer la somme S= 1+2+3+...+ 10. Utilisant la boucle while.  (Solution)

Exercice 16

Écrire un programme en Java permettant de  calculer la somme   S=1+2+3+...+ N,  oĂą N saisi par l’utilisateur.  Utilisant la  boucle while.   (Solution)

Exercice 17

Écrire un programme en Java qui permet d'afficher  le message "bonjour" 10 fois . Utilisant la  boucle for .  (Solution)

Exercice 18

Écrire un programme en Java qui permet de  calculer  la somme  S=1+2+3+...+ 10. Utilisant la boucle for.  (Solution)

Exercice 19

Écrire un programme en Java qui permet de calculer la somme   S=1+2+3+4+….+ N. oĂą N saisi au clavier par l'utilisateur.Utilisant la boucle for .   (Solution)

Exercice 20

Écrire un programme en Java qui permet d'afficher la table de multiplication de 5. Utilisant la boucle For.   (Solution)

Exercice 21

Écrire un programme en Java qui permet d'afficher la table de multiplication d’un entier saisie par l’utilisateur,  Utilisant la boucle For.  (Solution)

Exercice 22

Écrire un programme en Java  qui permet d'afficher "Bonjour" 10 fois. utilisant la boucle Do While.   (Solution)

Exercice 23

Écrire un programme en Java qui calcule la somme  S= 1+2+3+…+ 10. Utilisant la boucle  Do While.   (Solution)

Exercice 24

Écrire un programme en Java qui affiche la table de multiplication de 8. Utilisant la boucle  Do While.   (Solution)

Exercice 25

Écrire un programme en Java permettant de saisir 10 entiers et de les stocker dans un tableau nommĂ© Tableau, puis les afficher.   (Solution)

Exercice 26

Écrire un programme en Java  permettant de saisir 10 notes et qui affiche la moyenne de ces notes.   (Solution)

Exercice 27

Écrire un programme en Java permettant de saisir 10 entiers et qui affiche le maximum de ces entiers.   (Solution)

Exercice 28

Écrire un programme en Java  permettant de saisir 10 entiers dans un tableau, et de calculer le nombre d'occurrences d'un Ă©lĂ©ment N  dans ce tableau. OĂą N saisi par l’utilisateur.    (Solution)

Exercice 29

Écrire un programme en Java  permettant de saisir 10  entiers dans un tableau et de  trier ce tableau par ordre croissante. puis affiche ce tableau après le tri.   (Solution)

Exercice 30

Écrire un programme en Java permettant de calculer le factoriel d'un entier saisi par l'utilisateur. par exemple N = 7  le factoriel de 7 Ă©gal Ă   1*2*3*4*5*6*7 =5040.    (Solution)


Exercice 31

Écrire un programme en Java permettant d'afficher les nombres paires compris entre 0 et N, oĂą N saisi par l'utilisateur.  (Solution)

Exercice 32

Écrire  un programme en Java qui permet de calculer la somme d'entiers  impaires de 1 jusqu'Ă  un entier N saisi par l'utilisateur.   Exemple N=8   Somme = 1 +3+5+7= 16   (Solution)

Exercice 33

Écrire un programme en Java qui permet de calculer le plus grand diviseur commun entre deux entiers saisis par l'utilisateur.  Par exemple:  M= 15  et N=10   PGCD (15 , 10) =  5      (Solution)

Exercice 34

Ecrire un programme en Java qui permet d'afficher  un  triangle  d'entiers, selon un entier saisi par l'utilisateur. Exemple   N=4

1

22

333

4444  

  (Solution)


Exercice 35

Écrire un programme en Java qui permet de calculer le nombre de chiffres d'un entier N saisi  par l'utilisateur.  Exemple  N = 10843

le nombre de chiffres est : 5               (Solution)

Exercice 36

Écrire un programme en Java qui permet d'inverser les chiffres d'un entier N saisi par l'utilisateur.   par exemple  N=35672  le rĂ©sultat affichĂ© doit ĂŞtre   27653     (Solution)

Exercice 37

Écrire un programme en Java  qui permet de saisir un entier N et d'afficher le triangle d'Ă©toiles. par exemple  N = 4

          1110111
          1100011 
          1000001
          0000000

(Solution)


Exercice 38

Écrire un programme en Java qui  permet de saisir 10 entiers dans un tableau. puis compter combien y a-t-il  d'Ă©lĂ©ments pairs et  impairs.  (Solution)

Exercice 39

Écrire un programme en Java qui affiche si un nombre  entier N  saisi au clavier est Premier ou non.   (Solution)

Exercice 40

Ecrire  un programme en Java qui demande la saisie d'un tableau T de 10 entiers, et de mettre les Ă©lĂ©ments pairs dans  un tableau T1 et les Ă©lĂ©ments impaires dans un tableau T2. Puis afficher T1  et  T2      (Solution)

 



Exercice 41: classe Rectangle 


Écrire en JAVA une classe «Rectangle» ayant deux variables « a » et « b » et une fonction membre « surface() » qui retournera la surface du rectangle.

                              CorrigĂ©

class Rectangle {
   private
   int a,b;
   Rectangle() {a=0; b=0;}
   Rectangle (int a, int b){  this.a=a;  this.b=b; }
   int surface(){
     return a*b;
   }
};

class Main {
public static void main(String[] args){
Rectangle r1 = new Rectangle ();
Rectangle r2 = new Rectangle (5,4);
System.out.println("la surface est:"+r1.surface());
System.out.println("la surface est:"+r2.surface());
    }
}


Exercice 42 : classe Somme 


Écrire en JAVA une classe « Somme » ayant deux variables « n1 » et « n2 » et une fonction membre « som() » qui calcule la somme. Dans la mĂ©thode principale main demandez Ă  l’utilisateur d’entrez deux entiers et passez-les au constructeur par dĂ©faut de la classe « Somme » et afficher le rĂ©sultat de l’addition des deux nombres.

                              CorrigĂ©


import java.util.Scanner;
class Somme{
   public
   int n1, n2;
   Somme(int nbr1, int nbr2){
      n1=nbr1;
      n2=nbr2;
   }

   int som(){
      return n1 + n2;
   }
};

class Main {
public static void main(String[] args){
int n1, n2;
Scanner sc = new Scanner (System.in);
System.out.println("Entrer N1:");
n1 =sc.nextInt();
System.out.println("Entrer N2:");
n2 = 
sc.nextInt();
Somme obj= new Somme(n1,n2);
System.out.println("Le resultat de l'addition est :"+obj.som());

    }
}


Exercice 43 : classe Etudiant 

Écrire classe JAVA appelĂ©e « Etudiant » avec les membres suivant :
nom : (de type char),
note1, note2 : (de type float)
calc_moy() : calcule la note moyenne.
afficher () : affiche le nom et la note moyenne.
Le programme principal (main) demande Ă  l’utilisateur d’entrer le nom et les notes d'un Ă©tudiant. et affiche leur nom et la note moyenne.

                                            CorrigĂ©

import java.util.Scanner;
class Etudiant {
  public
  String nom;
  float note1, note2;

Etudiant(String _nom, float _note1, float _note2){
    nom = _nom;
    note1 = _note1;
    note2 = _note2;
  }

  float calc_moy(){
    return (note1 + note2)/2;
  }
 
  void afficher (){
    System.out.println("Etudiant: "+ nom +" \n moyenne: "+ calc_moy());
  }
};

class Main {
public static void main(String[] args){
  String nom;
  int note1, note2;
  Scanner sc = new Scanner (System.in);
   System.out.println("Entrer le nom:");
  nom = sc.nextLine();
   System.out.print("Entrez note 1:");
note1= sc.nextInt();
   System.out.print("Entrez note 2: ");
note2 = sc.nextInt();
Etudiant E = new Etudiant (nom, note1, note2);
E.afficher();
    }
}

Exercice 44 : classe point

RĂ©aliser en JAVA  une classe point permettant de manipuler un point d'un plan.on prĂ©voira :

1) un point est définit par ses coordonnées x et y (des membres privés)

2) les constructeurs 

3) une fonction membre déplace effectuant une translation définie par ses deux arguments dx et dy (double)

4)une fonction membre affiche se contentant d'afficher les coordonnées cartésiennes du point.

5)une fonction membre saisir se contentant de saisir les coordonnées cartésiennes du point.

6)une fonction membre distance effectuant calculant la distance entre deux point.

7)une fonction membre milieu donnant le milieu d'un segment.

8)un petit programme d'essai (main) gérant la classe point.

                            CorrigĂ©

import java.util.*;
class point {
double x;
double y;
public
point() { x=0; y=0; }
point(double a,double b) { x=a; y=b; }
point(point p) {
set_x(p.get_x());
set_y(p.get_y());
}

double get_x() {return x; }
double get_y() { return y;}

void set_x(double a) { x=a;  }

void set_y(double a) { y=a;  }

point deplace(double dx,double dy) {
set_x(get_x()+dx);
set_y(get_y()+dy);
return this;
}

void affiche(){
System.out.println("les coordonnees sont:");
System.out.println("x="+get_x());
System.out.println("y="+get_y());
}

void saisir(){
Scanner sc = new Scanner (System.in);
System.out.println("donnee les coordonnees:");
System.out.println("x =");
x = sc.nextInt();
System.out.println("y =");
y = sc.nextInt();
}

double distance (point p) {
double p1,x1,x2;
x1=(get_x()-p.get_x())*(get_x()-p.get_x());

x2=(get_y()-p.get_y())*(get_y()-p.get_y());

p1=Math.sqrt(x1+x2);
return p1;

}

point milieu(point p){
point p1 = new point();
p1.x=(get_x()+p.get_x())/2;
p1.y=(get_y()+p.get_y())/2;
return p1;
}

};


class Main {
public static void main(String[] args){
point p = new point(1,1);
point x = new point(5,5);
point c;
p.affiche();
p.deplace(5,5);
p.affiche();
System.out.println("la distance est : "+p.distance(x));
c=p.milieu(x);
c.affiche();
    }
}


Exercice 45 : classe Compte 

Écrire un programme en JAVA qui simule la gestion d’un simple compte bancaire. Le compte est crĂ©Ă© avec un solde initial. Il est possible de dĂ©poser et de retirer des fonds, d’ajouter des intĂ©rĂŞts et de connaĂ®tre le solde actuel. Cela devrait ĂŞtre implĂ©mentĂ© dans une classe nommĂ©e Account qui comprend:


1) Un constructeur par défaut qui met le solde initial à zéro.
2) Un constructeur qui accepte une balance initial comme paramètre.
3) Une fonction getBalance qui renvoie le solde actuel.
4) Une méthode deposer pour déposer un montant spécifié.
5) Une méthode retirer pour retirer un montant spécifié.
6) Une mĂ©thode ajouter_Interet pour ajouter de l’intĂ©rĂŞt au compte.
La mĂ©thode  ajouter_Interet  prend le taux d’intĂ©rĂŞt comme paramètre et modifie le solde du compte en solde * (1 + taux d’intĂ©rĂŞt).

                          CorrigĂ©

class Compte {
private
  double balance = 0;
public
Compte() {balance =0; }
Compte(double initial_balance)   {balance = initial_balance ; }
double getBalance()  { return balance; }
void deposer(double amount) { balance += amount; }
void retirer (double amount) { balance -= amount; }
void  ajouter_Interet (double rate) { balance = balance*(1 + rate); }
};

class Main {
    public static void main(String[] args) {
  Compte compte1 = new Compte();
  Compte compte2 = new Compte(3000);    compte1.deposer(100);
  compte2.retirer(1000);
   compte1.ajouter_Interet
 (0.3);
   System.out.println(compte1.getBalance());
   System.out.println(compte2.getBalance());      
    }
}

Exercice 46:  Classe temps 


CrĂ©er en JAVA une classe appelĂ©e Temps, qui a des membres de type int tels que heures, minutes et secondes.(rendez-les private)
1) Un constructeur doit initialiser ces données à 0
2) Un autre constructeur devrait l’initialiser Ă  des valeurs fixes.
3) Une fonction membre devrait l’afficher, au format 17h 59min 59s.
4) Une autre fonction pour renvoyer les données de chaque membre nommez-les getheurs, getMin et getSec
5) Une fonction membre doit ajouter deux objets de type Temps passĂ© en arguments.


                             
Corrigé


class Temps {
  private
     int heures;
     int minutes;
     int seconds;
 
  public
    Temps() { setTemps(0, 0, 0); }
    Temps(int h, int m, int s) { setTemps(h, m, s); }
  
void setTemps(int h, int m, int s) {
heures = h; minutes = m; seconds = s;
}
  
void getTemps() {
System.out.println(heures+"h "+minutes +"min "+seconds+"s");     
}

int getHours() { return heures; }
int getMin()  { return minutes; }
int getSec() { return seconds; }

void ajouterTemps(Temps t1, Temps t2) {
this.secondst1.seconds + t2.seconds;
this.minutes = t1.minutes + t2.minutes + (this.seconds/60);
this.heures = t1.heures + t2.heures + (this.minutes/60);
      this.minutes %= 60;
      this.seconds %= 60;
    }
};

class Main {
    public static void main(String[] args) {
Temps t1 = new Temps(4,43, 59);
Temps t2 = new Temps(1, 20, 32);
Temps t3 = new Temps();

    t1.getTemps();
    t2.getTemps();
    t3.ajouterTemps(t1, t2);
    t3.getTemps();
    }
}


Exercice 47: Classe rectangle

Écrire en JAVA un programme utilisant une classe rectangle dont le constructeur prend deux paramètres, largeur et hauteur et qui offre les fonctions suivantes :

1) calcul du périmètre

2) calcul de la surface

3)  affichage

ainsi que les accesseurs et mutateurs triviaux (lecture et modification de la largeur et de la hauteur).

                                  CorrigĂ©


import java.util.Scanner;


class Rectangle {
private
int largeur;
int hauteur;
public
Rectangle(){largeur = 0; hauteur = 0;}


Rectangle(int initLargeur,int initHauteur){
largeur = initLargeur;
hauteur = initHauteur;}


int getLargeur()  {return largeur; };


int getHauteur()  {return hauteur; };


int perimetre()  {return 2*(largeur+hauteur); };
int surface()  { return largeur * hauteur; };


void setLargeur(int newLargeur) { largeur = newLargeur; };


void setHauteur(int newHauteur) { hauteur = newHauteur; };

void afficher() {
for( int i=0; i < hauteur; i++)
{
System.out.print("\n");
for(int j=0; j < largeur; j++)
System.out.print("*");
}
System.out.print("\n");
}
};

class Main {
public static void main(String[] args) {
Rectangle R= new Rectangle (4,5);
R.afficher();
System.out.println("la surface est "+R.surface());
System.out.println("le perimetre est "+R.perimetre());
    }
}


Exercice 48 : L'hĂ©ritage 

Écrivez un programme en JAVA qui dĂ©finit une classe appelĂ©e Forme avec un constructeur qui donne de la valeur Ă  la largeur(x) et Ă  la hauteur(y). DĂ©finir la mĂ©thode aire() dans les deux sous-classes Triangle et Rectangle, qui calculent l’aire. Dans la mĂ©thode principale main, dĂ©finissez deux variables, un triangle et un rectangle, puis appelez la fonction aire() dans ces deux variables.

Notez que:

 l’aire du triangle est = largeur * hauteur / 2 

l’aire du rectangle est = largeur * hauteur.

                       CorrigĂ©

class Forme {
protected
  float x, y;
public
  Forme() { x=0; y=0; }
  Forme(float  x, float y)
  {
    this.x =  x;
    this.y =  y;
  }
};

class Rectangle extends Forme
{
public
Rectangle (){ super();}
Rectangle (int x,int y){ super (x,y);}

  float aire()
  {
    return (x * y);
  }
};

class Triangle extends Forme
{
public
Triangle (int x ,int y) 
{super(x,y);}

  float aire()
  {
    return (x * y / 2);
  }
};

class Main {
    public static void main(String[] args) {
Rectangle R = new Rectangle (2,3);
Triangle T = new Triangle (2,3);
Rectangle R1 = new Rectangle ();
  System.out.println(R.aire());
  System.out.println(T.aire());
  System.out.println(R1.aire());
    }
}


Exercice 49: Polymorphisme 

1) Écrire en JAVA une classe Forme ayant une fonction  aire ()
2) Écrire la classe triangle qui hĂ©rite de la classe Forme et comporte les attributs 
(base et  hauteur de type rĂ©el) et les mĂ©thodes ( constructeur et  aire() ).
3) Écrire la classe Cercle qui hérite de la classe Forme et comporte l'attribut rayon
 de type rĂ©el et les mĂ©thodes ( constructeur et  aire() ).
4) Écrire la classe Rectangle qui hĂ©rite de la classe Forme et comporte les attributs 
(Longueur et largeur de type réel) et les méthodes ( constructeur et aire() ).
4) Écrire la classe Carre qui hérite de la classe Forme et comporte l'attribut
(côté de type réel) et les méthodes ( constructeur et aire() ).
6) Écrire une fonction main()  qui permet de dĂ©clarer un tableau de type Forme puis remplir ce tableau avec les  instances de types (Cercle, Rectangle, Triangle, CarrĂ©) et après afficher la surface de chaque objet.

                      CorrigĂ©

class Forme{
  public
void aire() {
    System.out.println("Forme");
}
};

class Triangle  extends Forme
{ int base;
  int hauteur ;
  public
  Triangle (int b,int h){ base=b; hauteur=h;}
  public void aire() {
   System.out.println("aire de triangle");}
};

class Cercle extends Forme
{ int rayon ;
  public
  Cercle (int r){ rayon=r;}
  public void aire() {
  System.out.println("aire de cercle");}
};

class Carre extends Forme
{ int cote;
  public
  Carre(int c){ cote=c;}
  public void aire() {
  System.out.println("aire de Carre");}
};

class Rectangle extends Forme
{ int longueur;
  int largeur;
  public
  Rectangle (int l,int L){ longueur=l; largeur=L;}
public void aire() {
  System.out.println("aire de rectangle");
     
  }
};

class Main {
    public static void main(String[] args) {
Forme[]  T = new Forme[4];
  T[0]= new Triangle(6,5);
  T[1]= new Carre(5);
  T[2]= new Cercle(6);
  T[3]= new Rectangle(3,4) ;
  T[0].aire();
  T[1].aire();
  T[2].aire();
  T[3].aire();
    }
}


Exercice 50:  Classe abstraite 

1)Écrire en JAVA une classe A abstraite ayant 3 mĂ©thodes:  deux mĂ©thodes sont des fonctions abstraites (afficher1() et afficher2() et la troisième bien dĂ©finie s'appelle afficher3().
2) Écrire une classe B qui hĂ©rite de la classe A dans cette classe  redĂ©finir les deux fonctions abstraites prĂ©cĂ©dentes.
2) Écrire une fonction main()  qui permet de dĂ©clarer un objet (b) de la classe B, puis tester les trois mĂ©thodes sur cet objet.

                          CorrigĂ©

abstract class A {
  public
    abstract void afficher1();
    abstract void afficher2();

    void afficher3()
    {
      System.out.println(" la methode afficher3 de la classe mere");
    }
};


class B extends A
{
  public
    void afficher1()
    {
     System.out.println(" la methode afficher1 de la classe fille");
    }

    void  afficher2()
    {
      System.out.println("la methode afficher2 de la classe fille");
    }
};



class Main {
    public static void main(String[] args) {
  B b= new B();
  b.afficher1();
  b.afficher2();
  b.afficher3();   
    }
}