Page 1 de 24
[Link] mercredi 26 avril 2023 14:22
1 package mesPoints;
2
3 import [Link];
4
5 public class Point {
6
7 private double x,y;
8
9 public double getX() {
10 return x;
11 }
12
13 public void setX(double x) {
14 this.x = x;
15 }
16
17 public double getY() {
18 return y;
19 }
20
21 public void setY(double y) {
22 this.y = y;
23 }
24
25 // Constructeur sans paramètres
26 public Point() {
27 this(0.0,0.0);
28 //this.x = 0.0;this.y = 0.
29 }
30
31 // Constructeur avec deux paramètres
32 public Point(double x, double y) {
33 this.x = x;
34 this.y = y;
35 }
36
37 // Constructeur par recopie
38 public Point(Point p) {
39 this(p.x, p.y);
40 }
41
42 @Override
43 public String toString() {
44 return "(" + x + "," + y + ")";
45 }
46
47 @Override
48 public int hashCode() {
49 return [Link](x, y);
50 }
51
52 @Override
53 public boolean equals(Object obj) {
54 if (this == obj)
55 return true;
56 if (obj == null)
57 return false;
58 if (getClass() != [Link]())
59 return false;
60 Point other = (Point) obj;
61 return [Link](x) == [Link](other.x)
62 && [Link](y) == [Link](other.y);
63 }
64
Page 1
Page 2 de 24
[Link] mercredi 26 avril 2023 14:22
65 public double calculerDistance(Point p) {
66 return [Link]([Link](this.x-p.x,2)+[Link](this.y-p.y,2));
67 }
68
69 public Point calculerMilieu (Point p) {
70 double xI =(this.x+p.x)/2;
71 double yI =(this.y+p.y)/2;
72 return new Point(xI,yI);
73 }
74
75 public void translater(double dx,double dy) {
76 this.x += dx;
77 this.y += dy;
78 }
79
80 public void homothetie(int k) {
81 this.x *= k;
82 this.y *= k;
83 }
84
85 public void symetrie() {
86 double temp = this.x;
87 this.x = this.y;
88 this.y = temp;
89 }
90
91 public void rotation () {
92 double temp = this.x;
93 this.x = - this.y;
94 this.y = temp;
95 }
96
97 }
98
Page 2
Page 3 de 24
[Link] mercredi 26 avril 2023 14:20
1 package mesPoints;
2
3 public class TroisPoints {
4
5 private Point A,B,C;
6 private double a,b,c;
7
8 public Point getA() {
9 return this.A;
10 }
11
12 public void setA(Point A) {
13 this.A = A;
14 }
15
16 public Point getB() {
17 return this.B;
18 }
19
20 public void setB(Point B) {
21 this.B = B;
22 }
23
24 public Point getC() {
25 return this.C;
26 }
27
28 public void setC(Point C) {
29 this.C = C;
30 }
31
32 public TroisPoints(Point A, Point B, Point C) {
33 this.A=A;
34 this.B=B;
35 this.C=C;
36 a=[Link](C);
37 b=[Link](C);
38 c=[Link](A);
39 }
40
41 public boolean sontAlignes() {
42 if((a==b+c)||(b==a+c)||(c==a+b)) {
43 return true;
44 }
45 else {
46 return false;
47 }
48 }
49
50 public boolean estIsocele() {
51 if ((a==c)||(b==a)||(b==c)) {
52 return true;
53 }
54 else {
55 return false;
56 }
57 }
58
59 // estEquilateral
60 public boolean estEquilateral() {
61 return ((a==b)&& (a==c) && (b==c));
62 }
63
64 // estRectangle
Page 1
Page 4 de 24
[Link] mercredi 26 avril 2023 14:20
65 public boolean estRectangle() {
66 return (([Link](a, 2)+[Link](b, 2)==[Link](c, 2))|| ([Link](a,
2)+[Link](c, 2)==[Link](b, 2))|| ([Link](b, 2)+[Link](c, 2)==[Link](a,
2)));
67 }
68
69
70 }
71
Page 2
Page 5 de 24
[Link] mercredi 26 avril 2023 14:22
1 package mesPoints;
2 import [Link];
3
4 public class Main {
5
6 public static void main(String[] args) {
7
8 Scanner scanner = new Scanner([Link]);
9
10 // Saisie des coordonnées des trois points
11 [Link]("Entrez les coordonnées du point A :");
12 double xA = [Link]();
13 double yA = [Link]();
14
15 [Link]("Entrez les coordonnées du point B :");
16 double xB = [Link]();
17 double yB = [Link]();
18
19 [Link]("Entrez les coordonnées du point C :");
20 double xC = [Link]();
21 double yC = [Link]();
22
23 // Création des objets Point correspondant à chacun des points A, B, C
24 Point A = new Point(xA, yA);
25 Point B = new Point(xB, yB);
26 Point C = new Point(xC, yC);
27
28 // Création de l'objet TroisPoints correspondant aux trois points A, B, C
29 TroisPoints triangle = new TroisPoints(A, B, C);
30
31 // Affichage des détails sur les trois points
32 [Link]("Détails des points :");
33 [Link]("Point A : " + A);
34 [Link]("Point B : " + B);
35 [Link]("Point C : " + C);
36
37 [Link]("\nle milieu de A et
C:"+([Link](C)).toString());
38 [Link]("le milieu de A et B:"+([Link](B)).toString());
39 [Link]("le milieu de B et C:"+([Link](C)).toString());
40
41 [Link]("\nla distance entre A et C est
:"+[Link](C));
42 [Link]("la distance entre A et B est :"+[Link](B));
43 [Link]("la distance entre B et C est :"+[Link](C));
44
45 // sontAlignes
46 [Link]("\nSont alignes :");
47 if([Link]())
48 [Link]("les trois points sont alignees\n");
49 else
50 [Link]("les trois points ne sont pas alignees\n");
51
52 // estIsocele
53 [Link]("Est Isocele :");
54 if([Link]())
55 [Link]("Oui,ils forment un triangle Isocele\n");
56 else
57 [Link]("Non,ils ne forment pas un triangle Isocele\n");
58
59 // estEquilateral
60 [Link]("Est Equilateral :");
61 if([Link]())
62 [Link]("Oui,ils forment un triangle Equilateral\n");
Page 1
Page 6 de 24
[Link] mercredi 26 avril 2023 14:22
63 else
64 [Link]("Non,ils ne forment pas un triangle Equilateral\n");
65
66 // estRectangle
67 [Link]("Est Rectangle :");
68 if([Link]())
69 [Link]("Oui,ils forment un triangle Rectangle\n");
70 else
71 [Link]("Non,ils ne forment pas un triangle Rectangle");
72 }
73
74 }
75
Page 2
Page 7 de 24
Série 2- Exercice 2 : Nombre Complexe
Problème 1
1. Définissez une classe Complexe, dont chaque instance représente un nombre complexe immuable de
l’ensemble ℂ. Un objet complexe aura deux attributs, une partie réelle et une partie imaginaire: re+i im.
public class Complexe {
// les attributs - la partie réelle et la partie imaginaire
//Une fois le nombre complexe créé, sa valeur ne change pas.)
private final double re;
private final double im;
}
2. La classe Complexe comportera un constructeur par défaut qui initialisera les deux attributs à zéro, ainsi
qu’un constructeur qui initialisera un nombre complexe à partir de deux paramètres réels, et un troisième
constructeur par recopie.
// les constructeurs
// constructeur sans paramètre
public Complexe(){
re = im = 0.0;
}
// constructeur avec deux paramètres
public Complexe(double re, double im){
[Link] = re;
[Link] = im;
}
// constructeur par copie
public Complexe(Complexe x){
this([Link],[Link]);
}
3. Redéfinir la méthode toString(). La méthode toString permet la conversion d’un objet de type complexe en
une chaîne de caractères.
@Override
public String toString(){
if (im == 0) return re + "";
if (re == 0) return im + "i";
if (im < 0) return re + " - " + (-im) + "i";
return re + " + " + im + "i";
}
4. Ecrire les accesseurs de la classe (Les getters).
//Les accesseurs
public double getRe() {
return re;
}
public double getIm() {
return im;
}
5. Complétez la classe Complexe avec les opérations arithmétiques: addition, soustraction, multiplication, et
division.
// méthode d'addition
public Complexe addition(Complexe z){
return new Complexe([Link]+[Link],[Link]+[Link]);
Page 8 de 24
}
// méthode de soustraction
public Complexe soustraction(Complexe z){
return new Complexe([Link],[Link]);
}
// méthode de multiplication
public Complexe multiplication(Complexe z){
return new Complexe([Link]*[Link]*[Link],[Link]*[Link]+[Link]*[Link]);
}
//méthode 1 de division
public Complexe division(Complexe c) {
float reD = (float)((re*[Link]+im*[Link])/([Link]([Link],2)+([Link]([Link],2))));
float imD = (float)(([Link]*im-re*[Link])/([Link]([Link],2)+([Link]([Link],2))));
return new Complexe(reD, imD);
}
//méthode 2 de division
public Complexe division2(Complexe z){
return new Complexe([Link]([Link]()));
}
6. Ajoutez à la classe Complexe une méthode statique Complexe additionner(Complexe a,Complexe b).
//méthode statique addition (
public static Complexe additionner(Complexe a, Complexe b) {
return new Complexe([Link]+[Link],[Link]+[Link]);
}
7. Ecrire une méthode qui permet de calculer le module ainsi que l’argument d’un nombre complexe.
// Le module
public double module() {
return [Link](re*re+im*im);
}
// L'argument ou angle thêta tan x =im/re angle x=artang (im/re)
public double argument() {
return [Link](im/re); //Math.atan2(re, im);
}
8. Ecrire une méthode qui permet de multiplier un nombre complexe par un scalaire.
// multiplier un nombre complexe par un scalaire
public Complexe multiplierParScalaire(double scal) {
return new Complexe(scal * re, scal * im);
}
9. Ecrire les méthodes Inverse, conjugue qui permettent de retourner l’inverse et le conjugué d’un nombre
complexe.
// la méthode Inverse
public Complexe inverse () {
return new Complexe(re/(re*re+im*im), -im /(re*re+im*im));
}
//la méthode conjugué
Page 9 de 24
public Complexe conjugue() {
return new Complexe(re, -im);
}
10. Ecrire une méthode exponentielle qui calcule l’exponentielle d’un Complexe.
//La méthode exponentielle e^z=e^re*cos(im)+e^re*sin(im) i
public Complexe exponentielle() {
return new Complexe([Link](re)*[Link](im),[Link](re)*[Link](im));
}
11. Redéfinir la méthode equals() pour comparer et vérifier si deux nombres complexes sont égaux ou non.
@Override
public boolean equals(Object x) {
if (x == null) return false;
if ([Link]() != [Link]()) return false;
Complexe autre = (Complexe) x;
return ([Link] == [Link]) && ([Link] == [Link]);
}
12. Ajoutez une méthode main faisant quelques tests élémentaires des complexes et leurs opérations.
public class Main {
public static void main(String[] args) {
Complexe a=new Complexe();
Complexe b=new Complexe(2,4);
Complexe c= new Complexe(2,4);
[Link](a);
[Link](b);
[Link](c);
[Link]("(("+c+") + ("+b+"))="+[Link](b));
[Link]("(("+c+") + ("+b+"))="+[Link](c,b));
[Link]("(("+c+") - ("+b+"))="+[Link](b));
[Link]("(("+c+") x ("+b+"))="+[Link](b));
[Link]("(("+c+") / ("+b+"))="+[Link](b));
[Link]("Argument de "+b+"="+[Link]());
[Link]("Module "+b+"="+ [Link]());
[Link]("Exponentielle " +b+"="+ [Link]());
[Link](b+" égualité "+c+" : "+[Link](c));
}
}
Problème 2
En utilisant les principes de la POO résoudre une équation du second degré de la forme : ax2+ bx+ c=0 dans ℂ. (a, b
et c les coefficients du polynôme).
1. Définir une classe Equation.
public class Equation {
private double a,b,c;
Page 10 de 24
2. Ecrire un constructeur à trois paramètres réels a, b et c qui correspondent aux coefficients du polynôme à
résoudre. Ce constructeur affectera les valeurs passées en paramètre aux attributs a, b et c et calculera la
valeur du discriminant delta.
public class Equation {
private double a,b,c,delta;
private Complexe z1, z2;
public Equation(double a,double b,double c) {
this.a=a;
this.b=b;
this.c=c;
delta=b*b-4*a*c;
}
}
3. Ecrire une méthode afficherDiscriminant() qui affiche la valeur du discriminant.
public void afficherDiscriminant() {
[Link]("le Discriminant de l'equation est : " + delta);
}
4. Ecrire une méthode résoudre() qui résout l’équation dans ℂ. (Utilisez la classe Complexe afin de représenter
les racines de l’équation du second degré).
public class Equation {
private double a,b,c,delta;
private Complexe z1, z2;
…
public void resoudre(){
// si le discriminant est positif, les solutions sont réelles
if (delta==0) z2=z1=new Complexe((-b)/(2*a),0);
else
if (delta > 0.0){
z1 = new Complexe((-b - [Link](delta)) /(2*a),0);
z2 = new Complexe((-b + [Link](delta))/(2*a),0);
}
else {
// si le discriminant est négatif les solutions sont complexes
z1 = new Complexe(-b/(2*a),[Link](-delta)/(2*a));
z2 = new Complexe(-b/(2*a),([Link](-delta)/(2*a))*-1);
}
}
}
5. Ecrire une méthode afficherSolutions() qui affiche les solutions de l’équation.
public void afficherSolutions(){
if (delta == 0)
[Link]("La racine est " + z1);
else
if (delta > 0) {
// on affiche les racines réelles
[Link]("La première racine est " + z1);
[Link]("La deuxième racine est " + z2);
}
Page 11 de 24
else {
// on affiche les solutions complexes
[Link]("La première racine est = "+z1);
[Link]("La deuxième racine est = "+z2);
}
}
6. Tester votre classe.
public class Main {
public static void main(String[] args) {
Scanner sc=new Scanner([Link]);
[Link]("Equation deuxième degré");
[Link]("Donner les coefficients de l'équation:");
[Link]("a=");
double a=[Link]();
[Link]("b=");
double b=[Link]();
[Link]("c=");
double c=[Link]();
Equation equation = new Equation(a,b,c);
[Link]("Votre equation est ( "+a+"x^2+"+b+"x+"+c+"= 0 )");
[Link]();
[Link]("Solution de l'equation est :");
[Link]();
[Link]();
}
}
Page 12 de 24
[Link] jeudi 19 mai 2022 10:45
1 package Strag;
2
3 public class Stragaire {
4 private String nom;
5 private float[] notes;
6 public String getNom() {
7 return nom;
8 }
9 public void setNom(String nom) {
10 [Link] = nom;
11 }
12 public float[] getNotes() {
13 return notes;
14 }
15 public void setNotes(float[] notes) {
16 [Link] = notes;
17 }
18 public Stragaire(String nom, float[] notes) {
19 super();
20 [Link] = nom;
21 [Link] = notes;
22 }
23 public float calculerMoyenne()
24 {
25 float somme=0;
26 for(float elt : [Link]){
27 somme=somme+elt;
28 }
29 return (somme/[Link]);
30 }
31 public float trouverMax()
32 {
33 float max=[Link][0];
34 for(int i=1;i<[Link];i++) {
35 if(max < [Link][i])
36 max = [Link][i];
37 }
Page 1
Page 13 de 24
[Link] jeudi 19 mai 2022 10:45
38 return max;
39 }
40 public float trouverMin()
41 {
42 float max=[Link][0];
43 for(int i=1;i<[Link];i++) {
44 if(max < [Link][i])
45 max = [Link][i];
46 }
47 return max;
48 }
49
50
51 }
52
Page 2
Page 14 de 24
[Link] jeudi 19 mai 2022 10:45
1 package Strag;
2
3 //import [Link];
4
5 public class Formation {
6 private String intitule;
7 private int nbrJours ;
8 private Stragaire[] stagiaires;
9
10 public String getIntitule() {
11 return intitule;
12 }
13 public void setIntitule(String intitule) {
14 [Link] = intitule;
15 }
16 public int getNbrJours() {
17 return nbrJours;
18 }
19 public void setNbrJours(int nbrJours) {
20 [Link] = nbrJours;
21 }
22 public Stragaire[] getStagiaires() {
23 return stagiaires;
24 }
25 public void setStagiaires(Stragaire[] stagiaires) {
26 [Link] = stagiaires;
27 }
28 public Formation(String intitule, int nbrJours,
Stragaire[] stagiaires) {
29 super();
30 [Link] = intitule;
31 [Link] = nbrJours;
32 [Link] = stagiaires;
33 }
34
35 public float calculerMoyenneFormation()
36 {
Page 1
Page 15 de 24
[Link] jeudi 19 mai 2022 10:45
37 float somme=0;int nbrStag=0;
38 for(Stragaire elt : [Link]){
39 somme =somme+ [Link]();
40 nbrStag++;
41 }
42 return (somme/[Link]);
43 }
44 public int getIndexMax()
45 {
46 int indice,i;
47 float max= [Link][0].calculerMoyenne();
48 indice=0;
49 for(i=1;i<[Link];i++) {
50 if(max < [Link][i].calculerMoyenne
()) {
51 max = [Link][i].calculerMoyenne
();
52 indice=i;
53 }
54 }
55 return indice;
56 }
57 public String nomMax()
58 {
59 int indice;
60 indice = getIndexMax();
61 return [Link][indice].getNom();
62 }
63 ////////question 11
64 public float minMax()
65 {
66 float minNote;
67 minNote= [Link][0].trouverMin();
68 for(int i=1;i<[Link];i++) {
69 if(minNote > [Link][i].trouverMin())
70 minNote= [Link][i].trouverMin();
71 }
Page 2
Page 16 de 24
[Link] jeudi 19 mai 2022 10:45
72 return minNote;
73 }
74 /// Question 12
75 public float trouverMoyenneParNom(String nom)
76 {
77 String nomN;
78 float moyMax=0;
79 for(int i=0;i<[Link];i++)
80 {
81 nomN=[Link][i].getNom();
82 if([Link](nom)) {
83
moyMax=[Link][i].calculerMoyenne();
84 for(int j=i+1;i<[Link]
;j++) {
85 nomN=[Link][j].getNom();
86 if([Link](nom)) {
87 if(moyMax <
[Link][j].calculerMoyenne());
88
moyMax=[Link][j].calculerMoyenne();
89 }
90 }
91 i=[Link];
92 }
93 }
94
95 return moyMax;
96 }
97 }
98
99
Page 3
Page 17 de 24
[Link] jeudi 19 mai 2022 10:46
1 package Strag;
2
3 public class Main {
4
5 public static void main(String[] args) {
6 // TODO Auto-generated method stub
7 float[] tabNote1=new float[]
{15,12,9,20};//moy=14
8 float[] tabNote2=new float[]
{15,14,7,11};//moy=11.7
9 float[] tabNote3=new float[]
{17,14,10,19};//moy=15
10 Stragaire stg1=new Stragaire("amin",tabNote1);
11 Stragaire stg2=new Stragaire("karim",tabNote2);
12 Stragaire stg3=new Stragaire("amin",tabNote3);
13 Stragaire[] TabStg=new Stragaire[]
{stg1,stg2,stg3};
14 Formation form=new Formation
("informatique",100,TabStg);
15 ///pour tester la fonction de Question 9
16 [Link](" la meilleure moyenne de
formation "+[Link]()+" est de stagaire
"+TabStg[[Link]()].getNom());
17 ///pour tester la fonction de Question 10
18 [Link](" la meilleure moyenne de
formation "+[Link]()+" est de stagaire
"+[Link]());
19 ///pour tester la fonction de Question 11
20 [Link](" la note minimale du premier
stagiaire ayant la meilleure moyenne de formation
"+[Link]()+" est "+[Link]());
21 ///pour tester la fonction de Question 12
22 [Link]("la moyenne du premier
stagiaire est "+[Link]("amin"));
23 }
24
25
Page 1
Page 18 de 24
[Link] jeudi 19 mai 2022 10:46
26 }
27
Page 2
Page 19 de 24
[Link] vendredi 10 juin 2022 15:44
1 /***@author Amine***/
2 package compte;
3 import [Link];
4 import [Link];
5
6 public final class Client {
7
8 private long CIN;
9 private String nom;
10 private String prenom;
11 private List<Compte> compte=new ArrayList<Compte>();
12
13 public Client(long CIN, String nom, String prenom) {
14 [Link] = CIN;
15 [Link] = nom;
16 [Link] = prenom;
17
18 }
19 public Client(long CIN, String nom, String prenom, Compte compte) {
20 [Link] = CIN;
21 [Link] = nom;
22 [Link] = prenom;
23 [Link](compte);
24 }
25 public void AfficherInfoCompte(long numCompte)
26 {
27 for (Compte cmpt:compte)
28 {
29 if(numCompte==[Link]())
30 [Link]("Client :\n CIN : "+CIN+"\n Nom : "+nom+"\n Prenom :
"+prenom+"\n Numero de compte : "+[Link]()+"\n Solde : " + [Link]()
+"Dh");
31 }
32 }
33 public void AfficherInfoCompte()
34 {
35 for (Compte cmpt:compte)
36 {
37
38 [Link]("Client :\n CIN : "+CIN+"\n Nom : "+nom+"\n Prenom :
"+prenom+"\n Numero de compte : "+[Link]()+"\n Solde : " + [Link]()
+"Dh");
39 }
40 }
41 public long getCIN() {
42 return CIN;
43 }
44 public void setCIN(long CIN) {
45 [Link] = CIN;
46 }
47 public String getNom() {
48 return nom;
49 }
50 public void setNom(String nom) {
51 [Link] = nom;
52 }
53 public String getPrenom() {
54 return prenom;
55 }
56 public void setPrenom(String prenom) {
57 [Link] = prenom;
58 }
Page 1
Page 20 de 24
[Link] vendredi 10 juin 2022 15:44
59 public List<Compte> getCompte() {
60 return compte;
61 }
62 public void setCompte(Compte compte) {
63 [Link](compte);
64 }
65
66 }
67 /***@author Amine***/
68
Page 2
Page 21 de 24
[Link] vendredi 10 juin 2022 15:45
1 /***@author Amine***/
2 package compte;
3
4 public class Compte {
5
6 private static long Compteur=1000;
7 private double solde=0;
8 private final long numCompte;
9 private double decouvert;
10 private double debit;
11 private double decouvertMax=800;
12 private double debitMax=1000;
13 private Client client;
14 private boolean situation;
15
16
17 public Compte(double solde,double debit, double decouvertMax, double debitMax,Client
client) {
18 [Link] = solde;
19
20 [Link]=Compteur++;
21 if(solde>=0 )
22 {
23 decouvert=0;
24 situation=false;
25 }else {
26 decouvert=[Link](solde);
27 situation=true;
28 }
29 [Link] = decouvert;
30 [Link] = decouvertMax;
31 [Link] = debitMax;
32 [Link] = client;
33 [Link](this);
34
35 }
36
37 public long getNumCompte() {
38 return numCompte;
39 }
40 public double getSolde() {
41 return solde;
42 }
43 public void setSolde(double solde) {
44 if(solde >[Link](decouvertMax))
45 {
46 [Link]("Solde inferieur au solde minimum pour ce compte,veuillez
entrer une valeur correcte");
47
48 }else {
49 [Link] = solde;
50 }
51
52
53 }
54 public void Crediter(double credit)
55 {
56 double temp;
57 if(credit>0)
58 {
59 temp=credit-decouvert;
60 decouvert-=credit;
Page 1
Page 22 de 24
[Link] vendredi 10 juin 2022 15:45
61
62 [Link]+=temp;
63 }
64 }
65 public void Debit(double debit)
66 {
67 if(debit>0)
68 {
69 if(solde-debit>=decouvertMax)
70 solde-=debit;
71 }else {
72 [Link]("Op�ration impossible, vous ne pouvez pas d�passer le
montant maximum des d�bits autoris�");
73 }
74 }
75 public void Retrait(double montant)
76 {
77 if(montant<debitMax)
78 Debit(montant);
79 }
80 public void Virement(Compte c,double montant)
81 {
82 [Link](montant);
83 [Link](montant);
84 }
85
86 public static long getCompteur() {
87 return Compteur;
88 }
89 public static void setCompteur(long compteur) {
90 Compteur = compteur;
91 }
92 public double getDecouvert() {
93 return decouvert;
94 }
95 public void setDecouvert(double decouvert) {
96 [Link] = decouvert;
97 }
98 public double getDecouvertMax() {
99 return decouvertMax;
100 }
101 public void setDecouvertMax(double decouvertMax) {
102 [Link] = decouvertMax;
103 }
104 public double getDebitMax() {
105 return debitMax;
106 }
107 public void setDebitMax(double debitMax) {
108 [Link] = debitMax;
109 }
110 public Client getClient() {
111 return client;
112 }
113 public void setClient(Client client) {
114 [Link] = client;
115 }
116 public long getNumcompte()
117 {
118 return numCompte;
119 }
120 public double getDebit()
121 {
Page 2
Page 23 de 24
[Link] vendredi 10 juin 2022 15:45
122 return debit;
123 }
124 public void setDebit(double debit)
125 {
126 [Link]=debit;
127 }
128 public boolean getSituation()
129 {
130 if(situation)
131 {
132 [Link]("Ce compte est a decouvert");
133 return true;
134
135 }else
136 {
137 [Link]("Ce compte n'est pas a decouvert");
138 return false;
139 }
140 }
141 public void AfficheInfoCompte()
142 {
143 [Link]("Numero du compte : "+getNumcompte()+ "\n Nom : " + [Link]()
+ " \n Prenom : "+ [Link]() +" \n Montant decouvert maximal : "
144 + getDecouvertMax() +" \n Montant debit maximal : "+ getDebitMax() + " \n
Situation du compte : "+ getSituation() +" \n Montant du debit autoris� : "+getDebit());
145 }
146
147 }
148 /***@author Amine***/
149
Page 3
Page 24 de 24
[Link] vendredi 10 juin 2022 15:45
1 /***@author Amine***/
2 package compte;
3
4 public class CompteBancaire {
5
6 public static void main(String[] args) {
7
8 Client client1=new Client(18337415,"Amine","Mohammed");
9 Client client2=new Client(18337415,"Samir","Mohammed");
10 Compte compte1=new Compte(20000,4000,5000,8000,client1);
11 Compte compte2=new Compte(300000,90000,5000,8000,client2);
12 [Link]();
13 [Link]();
14
15 }
16
17 }
18 /***@author Amine***/
19
Page 1