Exercice 1 : 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 2 : 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 3 : 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 4 : 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 5 : 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 6 : 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 7 : 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 8 : 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