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
Exercice 10
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
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
11101111100011
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.seconds= t1.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());
}
}
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();
}
}
0 Commentaires