Vous êtes sur la page 1sur 25

Université Sidi Mohammed Ben Abdallah

Faculté des Sciences – Dhar El Mehrez – Fès

1
Pr. MAHRAZ Med Adnane
ANNÉE UNIVERSITAIRE: 2016 - 2017
 Classe: moule pour fabriquer des objets
 Objet: élément concret produit par le moule
 Définition de classe:
class NomClasse { class Personne {
Attributs; String nom;
Méthodes; int AnneeNaissance;
} public int age() {…}
}

 Une classe regroupe un ensemble d’objets


(instances)
2
 Structure à deux parties:
 Référence
 Corps

 Les étapes
 Déclaration de la classe (e.g. Personne)
 À l’endroit où on utilise:
 Déclarer une référence du type de la classe
 Créer une instance d’objet (new)
 Manipuler l’objet

3
public class Personne {
public String nom;
public int anneeNaissance;
public int age() {return 2016 - anneeNaissance; }
} Déclaration de référence
class Utilisation {
public static void main(String[] args) { Création d’une instance
Personne qui;
Manipulation de l’instance
qui = new Personne();
référée par la référence
qui.nom = "Ali";
qui.anneeNaissance = 1990; qui
System.out.println(qui.age());
} nom: "Ali"
} 26 anneeNaissance: 1990 4
class Circle {
public double x, y; // coordonnées du centre ‘r’ est inaccessible de
private double r; // rayon du cercle l’extérieur de la classe
public Circle(double r) {
this.r = r;
constructeur
}
public double area() {
return 3.14159 * r * r;
} Math.PI
}
public class MonPremierProgramme {
public static void main(String[] args) {
Circle c; // c est une référence sur un objet de type Circle, pas encore un objet
c = new Circle(5.0); // c référence maintenant un objet alloué en mémoire
c.x = c.y = 10; // ces valeurs sont stockées dans le corps de l’objet
System.out.println("Aire de c :" + c.area());
}
} 5
 Un constructeur est une façon de fabriquer une
instance
 Une classe peut posséder plusieurs constructeurs
 Si aucun constructeur n’est déclaré par le
programmeur, alors on a la version par défaut:
NomClasse()
 Plusieurs versions d’une méthode: surcharge
(overloading)

6
class Circle {
public double x, y; // coordonnées du centre
private double r; // rayon du cercle
public Circle(double r) {
this: réfère à l’objet courant
this.r = r;
}
public Circle(double a, double b, double c) {
x = a; y = b; r = c;
}
} Le constructeur
public class Personne {
Personne() est
déclaré par défaut
public String nom;
public int anneeNaissance;
public int age() { return 2008 - anneeNaissance; }
7
}
class Circle {
public double x, y; // coordonnées du centre Que faire du premier objet?
public double r; // rayon du cercle • Aucune référence ne pointe vers lui.
public Circle(double r) {
L’objet est perdu et inutilisable. La
Ramasse miette (garbage collector) va
this.r = r; } récupérer l’espace occupé par l’objet
public Circle(double a, double b, double c) { Comparaison des références (c1 == c2):
x = a; y = b; r = c; } • Est-ce que c1 et c2 pointent vers le même
objet?
}
// Dans une méthode, par exemple, main:
Circle c1, c2;
c1 = new Circle(2.0, 3.0, 4.0);
c2 = c1; // c2 et c1 pointent vers le même objet
c2.r = c2.r – 1; // l’objet a le rayon réduit
c1 = new Circle(2.0); // c1 point vers un autre objet, mais c2 ne change pas
c1.x = 2.0; // on modifie le deuxième objet
8
c2 = c1; // maintenant, c2 pointe vers le 2ième objet aussi
c1 x: 2.0
1. Cercle c1, c2; null c1 y: 3.0
r: 3.0
c2 5. c1 = new Cercle(2.0);
c2
x: 0.0
x: 2.0 y: 0.0
c1 y: 3.0 r: 2.0
2. c1 = new Cercle(2.0, 3.0, 4.0); r: 4.0
c2
null x: 2.0
x: 2.0 c1 y: 3.0
c1 y: 3.0 r: 3.0
r: 4.0 6. c1.x = 2.0;
3. c2 = c1; c2
c2 x: 2.0
null y: 0.0
r: 2.0

x: 2.0 x: 2.0
c1 y: 3.0 c1 y: 3.0
4. c2.r = c2.r – 1; r: 3.0
7. c2 = c1; r: 3.0
c2 c2
null x: 2.0
y: 0.0 9
r: 2.0
 Forme générale
référence.attribut: réfère à un attribut de l’objet
référence.méthode( ): réfère à une méthode de l’objet
 static: associé à une classe
 Attribut (variable) statique: si on le change, ça change
la valeur pour tous les objets de la classe
 Méthode statique: on la réfère à partir de la classe
 Classe.méthode
 E.g. Math.sqrt(2.6): Appel à la méthode sqrt de la classe Math
 Constante: Math.PI
 Dans une classe: static final float PI = 3.14159265358979;
 Une constante n’est pas modifiable

10
Réaliser une classe Point permettant de représenter un point sur
un axe. Chaque point sera caractérisé par un nom (de type char)
et une abscisse (de type double). On prévoira :
1. un constructeur recevant en arguments le nom et l’abscisse
d’un point,
2. une méthode affiche imprimant (en fenêtre console) le nom
du point et son abscisse,
3. une méthode translate effectuant une translation définie par
la valeur de son argument.
4. Écrire un programme utilisant cette classe pour créer un
point, en afficher les caractéristiques, le déplacer et en
afficher à nouveau les caractéristiques.
11
public class Point {
double x=0;
char c;
public Point(double x,char c){
this.x=x;
this.c=c;
}
public void affiche(){
System.out.println("le point "+ c+ " a l'abscisse "+x);
}
public void deplacer(double d){
x+=d;
}
public static void main(String[] args){
Point p=new Point(2,'A');
p.deplacer(3);
p.affiche();
}

} 12
Réaliser une classe qui permet d’attribuer un numéro unique à
chaque nouvel objet créé (1 au premier, 2 au suivant...).
On ne cherchera pas à réutiliser les numéros d’objets
éventuellement détruits. On dotera la classe uniquement:
1. d’un constructeur,
2. d’une méthode getIdent fournissant le numéro attribué à
l’objet
3. une méthode getIdentMax fournissant le numéro du dernier
objet créé.
4. Écrire un petit programme d’essai.

13
public class NObjet { public static void main(String[] args)
private static int Ident=0; {
private int Id=0; NObjet o1=new NObjet();
public NObjet(){ NObjet o2=new NObjet();
Ident++; NObjet o3=new NObjet();
Id=Ident; System.out.println(o1.getIdent());
} System.out.println(o1.maxGetIdent());
public int getIdent(){ System.out.println(o2.getIdent());
return Id; System.out.println(o2.maxGetIdent());
} System.out.println(o3.getIdent());
public static int maxGetIdent(){ System.out.println(o3.maxGetIdent());
return Ident;
}
}
}
14
 Ecrire une classe appelée cercle qui contient:
 Deux variables privée: rayon (du type double) et couleur (du type
chaîne de caractères), avec une valeur par défaut de 1.0 et "rouge",
respectivement.
 Deux constructeurs surchargés - un constructeur qui prend un
double comme argument pour le rayon et un autre qui prend les
deux arguments.
 Deux méthodes publiques: getRadius () et getArea (), qui renvoient
le rayon et la surface du cercle, respectivement.
 Deux méthodes publiques: setRadius () et setColor (), qui changent
la valeur du rayon et de la couleur.
 Ecrire une classe de teste qui possède une fonction main.

15
public class Cercle {
private double rayon=1.0;
private String couleur="rouge";
public Cercle(double rayon){
this.rayon=rayon;}

public Cercle(double rayon,String couleur){


this.rayon=rayon;
this.couleur=couleur;}

public double getRaduis(){


return rayon;}

public double getArea(){


return Math.PI*rayon*rayon;}

public void setRaduis(double rayon){


this.rayon=rayon;}

public void setColor(String c){


couleur=c;}
16
}
 Une classe appelée Author est conçue pour modéliser l'auteur
d'un livre. Il contient:
 Trois variables privées: nom (String), email (String) et sexe (char de
'm' ou 'f');
 Un constructeur pour initialiser le nom, le courrier électronique et
le sexe avec les valeurs données;
 Public getters / setters: getName (), getEmail (), setEmail () et
getSexe (); (Il n'y a pas de setters pour le nom et le sexe, car ces
attributs ne peuvent pas être changés.)
 Une méthode toString () qui renvoie « L’auteur [nom= ?, email = ?,
sexe=?] », Par exemple, « L’auteur [nom= Mohamed , email =
m.test@yahoo.fr, sexe=M] ».
 Écrivez également une classe de teste appelée TestAuthor
pour tester toutes les méthodes publiques.

17
public class Author {
private String nom,email;
private char sexe;
public Author(String nom,String email,char sexe){
this.nom=nom;
this.email=email;
this.sexe=sexe;}
public void setEmail(String email){
this.email=email;}
public String getName(){
return nom;}
public String getEmail(){
return email;}
public char getSexe(){
return sexe;}
public String toString(){
String texte="L’auteur [nom="+nom+" , email ="+email+",
sexe="+sexe+"]";
System.out.println(texte);
return texte;} 18

}
 Une classe appelée Book est conçue pour modéliser un livre écrit
par un auteur. Il contient:
 Quatre variables privées: titre(String), auteur (de la classe Author que
vous venez de créer, supposer qu'un livre a un et un seul auteur),
prix(double) et quantité(int);
 Deux constructeurs:
 Public Book (titre, auteur, prix) {......}
 Public Book (titre, auteur, prix, quantité) {......}
 Les méthodes publiques: getTitle (), getAuthor (), getPrice (), setPrice
(), getQuantity (), setQuantity ().
 La méthode toString () qui renvoie « L’ouvrage[titre = ?, Auteur [nom= ?,
email = ?, sexe=?], prix= ?, quantité=?". Vous devez réutiliser toString ()
de la classe Author.
 Écrivez une classe de teste appelé TestBook pour tester toutes les
méthodes publiques dans la classe Book.
Notez que vous devez construire une instance d'Auteur avant de
pouvoir construire une instance de Livre.
19
public class Book {
private String titre; private Author auteur; private double
prix; private int quantite;
public Book(String titre,Author auteur,double prix,int
quantite){
this.titre=titre; this.auteur=auteur; this.prix=prix;
this.quantite=quantite;}
public void setName(String nom){ this.titre=nom; }
public void setAuthor(Author auteur){ this.auteur=auteur; }
public void setPrice(double prix){ this.prix=prix; }
public void setQuantity(int quantite){ this.quantite=quantite;
}
public Author getAuthor(){ return auteur; }
public double getPrice(){ return prix; }
public int getQuantity(){ return quantite; }
public String toString(){
String texte="L’ouvrage[titre = "+titre+", "+
auteur.toString()+", prix= "+prix+", quantité="+quantite;
System.out.println(texte);
return texte;}
20
}
 Ecrire une classe de gestion d’un polynôme. Cette classe
comporte les méthodes suivantes:
 Un constructeur qui accepte en argument un tableau de
coefficients.
 La méthode getCoefficients() qui retourne le tableau des
coefficients.
 La méthode getDegre() qui retourne le degré du polynôme.
 La méthode affiche() qui permet d’afficher un polynôme sous la
forme : n*Xn+(n-1)*X(n-1)………..
 La méthode Ajouter(P) qui accepte en argument un polynôme et
retourne la somme des deux polynôme.
 La méthode Soustraire(P) qui accepte en argument un polynôme et
retourne le résultat de la soustraction des deux polynôme.
 Ecrire la méthode main dans une autre classe pour le test.

21
public class Polynome {
private double coef[];
public Polynome(){
coef=new double[0];
coef[0]=0;
}
public Polynome(double[] coefficients){
coef=coefficients; Voir diapo
} n°53
public double[] getCoefficients(){
Voir diapo
return coef;
n°54
}
public Polynome Ajouter(Polynome p){}
Voir diapo
public Polynome Soustraire(Polynome p){} n°55
public void affiche(){}
}
22
public Polynome Ajouter(Polynome p){
double[] c=p.getCoefficients();
double[] c1,c2;
int l=0;
if (c.length>coef.length){
c1=c;
l=c.length;
c2=new double[l];
for(int i=0;i<coef.length;i++) c2[i]=coef[i];
for(int i=coef.length;i<l;i++) c2[i]=0;
}else{
c1=coef;
l=coef.length;
c2=new double[l];
for(int i=0;i<c.length;i++) c2[i]=c[i];
for(int i=c.length;i<l;i++) c2[i]=0;
}
double[] co=new double[l];
for(int i=0;i<l;i++) co[i]=c1[i]+c2[i];
return new Polynome(co); 23
}
public Polynome Soustraire(Polynome p){
double[] c=p.getCoefficients();
double[] c1,c2; //c1 les coefficients du polynome en cours
int l=0;
if (c.length>coef.length){
c2=c;
l=c.length;
c1=new double[l];
for(int i=0;i<coef.length;i++) c1[i]=coef[i];
for(int i=coef.length;i<l;i++) c1[i]=0;
}else{
c1=coef;
l=coef.length;
c2=new double[l];
for(int i=0;i<c.length;i++) c2[i]=c[i];
for(int i=c.length;i<l;i++) c2[i]=0;
}
double[] co=new double[l];
for(int i=0;i<l;i++) co[i]=c1[i]-c2[i];
return new Polynome(co); 24
}
public void affiche(){
String texte="";
for(int i=coef.length-1;i>=1;i--){
if(coef[i-1]>=0)
texte+=coef[i]+"*X"+i+"+";
else
texte+=coef[i]+"*X"+i;
}
texte+=coef[0];
System.out.println(texte);
}
25

Vous aimerez peut-être aussi