Java Déclaration des classes

1
Java
Déclaration des classes
2
DECLARATION D'UNE CLASSE
Syntaxe de la déclaration d'une classe :
public class NomDeLaClasse {
// attributs éventuels
// méthodes éventuelles
}
Le mot-clé public est facultatif. Cela permet de rendre la classe
visible pour toutes les autres classes du programme java.
• Le fichier portera le même nom que la classe (extension .java).
• Un nom de classe commence par une lettre Majuscule.
3
fichier "Humain.java"
DECLARATION D'UNE CLASSE
Exemple :
public class Humain {
// attributs
private String nom;
private Date dateNais;
private boolean estHomme;
//méthodes
public String presenteToi( ) {
return "Je m'apelle " + nom +" suis un homme : " + estHomme ;
}
public int calculAge( ) {
int age = (new Date( )).getYear() - dateNais.getYear( ) ;
return age ;
}
}
"private" et "public" :
modificateurs d'accès.
Présentés plus loin
Point
x
y
translater( )
Humain
nom
dateNais
estHomme
presenteToi()
calculAge()
4
DECLARATION D'UNE CLASSE
Syntaxe des attributs :
<modificateurs d'accès> <type> <nom> ;
private String nom;
private Date dateNais;
private boolean estHomme;
Exemples:
La notation <type> signifie à remplacer par un type
"String", "Date" :
types "classe"
"boolean" :
type primitif
5
DECLARATION D'UNE CLASSE
Syntaxe des méthodes :
<modificateurs d'accès> <type retourné> <nom> (<args>) {
<corps de la méthode>
}
public String presenteToi( ) {
return "Je m'apelle "+ nom + " suis un homme : " + estHomme ;
}
public int calculAge( ) {
int age = dateNais.getYear() - (new Date()).getYear();
return age ;
}
Exemples:
6
Utilisation des classes
Syntaxe de la déclaration d'une variable (une "référence") :
NomClasse nomObjet;
Exemple :
Humain h1;
Humain h2;
Construction d'un objet (création d'une instance), l'opérateur new :
new <constructeur de classe>
Exemple :
h1 = new Humain();
h2 = new Humain("Dupont");
h1 et h2 sont des "références" vers des Humains.
h1 et h2 sont des "télécommandes" 
(des références) vers des Humains

7
Par la suite :
h2 = h1;
Utilisation des classes
Remarques : les objets sont manipulés par des références
une variable est une référence (sauf pour les types primitifs).
par défaut une variable contient la référence vide : null .
déclarer une variable ne crée pas un objet : il faut faire new !!!
Exemple :
Humain h1 = new Humain();
Humain h2;
objet Humain
variable h1 variable h1
null
variable h1 variable h2
objet Humain
variable h1 variable h1
null
objet Humain
variable h1 variable h2
encore des analogies avec la
télécommande" 
8
Autre exemple : déclaration de la classe Cercle
fichier "Cercle.java"
public class Cercle {
// attributs
private double x ;
private double y ;
private double rayon ;
// méthodes
public double circonference() {
return 2 * Math.PI * rayon ;
}
public double surface() {
return Math.PI * rayon * rayon ;
}
public void affiche() {
System.out.println("Le cercle a pour centre : (" + x + " , " +
y + " )" + " et rayon : "+ rayon);
}
} // fin classe Cercle
Point
x
y
translater( )
Cercle
x
y
rayon
circonference()
surface()
affiche()
type de la valeur
retournée
"void" :- acune
valeur retournée
9
Utilisation d'une classe. Exemple Cercle
Déclaration d'une variable et instantiation. Deux possibilités
équivalentes :
Constructeur
Toute classe contient une méthode appelée constructeur
Cette méthode porte le même nom que la classe
L'objet retourné est implicitement une instance de la classe
Cercle c;
c = new Cercle( );
Cercle c = new Cercle( );
Opérateur new suivi de l'appel
au constructeur Cercle( )
10
Les constructeurs
• "Méthodes" chargées d'allouer de l'espace mémoire à l'objet
et de l'initialiser.
• Pour créer un objet, on fait appel obligatoirement à un
constructeur.
• Attention message d'erreur :
NullPointerException
• Le constructeur a le même nom que la classe et ne retourne
aucun type (on n'utilise même pas void lors de la déclaration)
11
Les constructeurs
Deux cas peuvent se présenter :
• Le programmeur ne défini aucun constructeur.
Alors, le système utilise le constructeur par défaut.
Il s'appelle pareille que la classe et n'a pas de paramètres.
• Le programmeur défini un ou plusieurs constructeurs
(surcharge). Le compilateur utilisera le constructeur adéquat
en fonction des arguments.
Ces constructeurs sont chargés d'initialiser différemment les
objets.
Dès qu'un constructeur est défini, alors le
constructeur par défaut n'existe plus.
12
Différents constructeurs pour la classe Cercle
public class Cercle {
// attributs
private double x, y ;
private double rayon;
// définition de différents constructeurs
public Cercle() { // remplace le constructeur par défaut
rayon =1 ;
}
// les autres méthodes …
} // fin classe Cercle
Le mot réservé this représente, au
moment de l'exécution, l'objet courant
public Cercle(double xo, double yo , double r) {
x = xo ; y = yo ; rayon = r ;
}
public Cercle(double rayon) {
this.rayon = rayon ;
}
Même nom que la classe.
On n'indique aucun type de retour.

13
Instantiation de la classe Cercle
Cercle c1 = new Cercle(); // construction d'un Cercle
Cercle c2 = new Cercle (3.0, 5.5, 9.4);
Cercle c3 = new Cercle (8.0);
Appel au constructeur
Cercle sans paramètres
les constructeurs servent à
initialiser les objets
c1
c1 : Cercle
x = 0.0
y = 0.0
rayon=
1.0
c2
c2 : Cercle
x = 3.0
y = 5.5
rayon=
9.4
c3
c3 : Cercle
x = 0.0
y = 0.0
rayon=
8.0
"surcharge des méthodes" :
méthodes portant le nom mais
avec des d'arguments différents.
14
// construction d'un Cercle de rayon 6.5
Cercle monCercle = new Cercle(6.5);
monCercle.x = 1.0;
monCercle.y = 1.0;
Exemple :
Utilisation des objets
Accès aux attributs
Syntaxe :
nomObjet.nomAttribut
Le point marque la séparation entre le nom de l'objet et le nom de
l'attribut de cet objet
Attention, erreur !!
Référence erronée car
l'attribut x est private
C'est un "bouton" de la "télécommande" 
15
Utilisation des objets
Accès aux méthodes
Syntaxe :
nomObjet.maMéthode(paramètres)
Le point marque la séparation entre le nom de l'objet et le nom de
la méthode de cet objet
Cercle c = new Cercle(-4.0,1.0,5.5);
c.affiche() ;
double s = c.surface();
Exemple :
Références correcte car
les méthodes affiche() et
surface() sont public
Notez dans l'exemple qu'il
n'y a pas des arguments
Une méthode opère implicitement
sur une instance de la classe.
C'est un "envoi de message"
16
Encapsulation
• Protection qui permet de contrôler la visibilité d'un attribut ou
d'une méthode.
• Quatre niveaux de protection : public, private, protected et
package.
• L'encapsulation permet de protéger l'objet de toute malveillance
externe. Pour cela, la plupart du temps, il faut interdire l'accès
direct aux attributs et passer par les méthodes qui modifient
éventuellement les attributs.
Ainsi dans l'exemple de la classe Cercle les
attributs sont private et les méthodes public.
Point
x
y
translater( )
Cercle
-x
-y
-rayon
+circonference()
+surface()
+affiche()
attribut privé
méthode publique
17
Encapsulation
Modificateur
d'accès Visibilité des attributs et méthodes
public Accessible par tous et n'importe où. Il s'agit du
niveau le plus bas de protection.
private Accessible uniquement dans les méthodes de la
classe. Niveau le plus fort de protection. Les attributs
sont généralement déclarées comme privées.
protected accessible dans les méthodes de la classe et des ses
sous-classes (celles qui héritent).
Visibilité par défaut : accessible par les classes du
même package. Aucun des mot clé modificateur n'est
utilisé.
18
Encapsulation
Exemple "Cercle"
Imaginez que nous souhaitons d'accéder, en consultation
seulement, à l'attribut rayon. Comment faire ?
Cercle figureUn = new Cercle();
double diametre = figureUn.rayon * 2;
Erreur !!
rayon est
private
Solution
Cercle figureUn = new Cercle();
double diametre = figureUn.getRayon() * 2;
méthode publique pour
obtenir le rayon d'un cercle

19
Encapsulation
public class Cercle {
// attributs
private double x, y ;
private double rayon;
// constructeurs . . .
// méthodes
public double getRayon() {
return rayon ;
}
// autres méthodes . . .
} // fin classe Cercle
Déclaration dans Cercle
Méthode publique.
C'est un "getteur"
20
Démarrage d'un programme java
Deux cas sont possibles :
1) Utilisation d'une Applet :
• L'applet est dans une page Web
• Le navigateur
–crée une instance de l'applet,
–l'initialise,
–puis la démarre
2) Programme Java standard :
• Une des classes possède une méthode main
• On appelle la machine virtuelle java en lui donnant la
classe qui porte la méthode main à utiliser.
21
Démarrage d'un pg via la méthode main
•Une des classes possède une méthode main :
public static void main(String args[ ])
où args : contient la liste des paramètres passés lors du
lancement
•On appelle la machine virtuelle java en lui indiquant la
classe qui porte la méthode main à utilise.
•Plusieurs classes peuvent définir une méthode main :
le choix de la méthode à utiliser se fait en fonction de la
classe passée à la machine virtuelle java
Modificateur "static"
présenté plus loin
22
Démarrage d'un pg via la méthode main
fichier "Cercle.java"
public class Cercle {
. . .
} // fin classe Cercle
fichier "Test.java"
public class Test {
public static void main(String args[ ]) {
Cercle c = new Cercle(-4.0,1.0,5.5);
c.affiche() ;
}
} // fin classe Test
Résultat à
l'exécution
23
Récapitulatif de la syntaxe d'une classe
public class Point {
private double x;
private double y;
public Point(){
x = 0;
y = 0;
}
public double norme(){
return Math.sqrt(x*x+y*y);
}
public void translater(double dx, double dy){
x = x + dx;
y = y + dy;
}
}
Exemple fichier "Point.java"
public class <nom> {
<modificateurs> <type> <nom attribut>;
<modificateurs> <type> <nom attribut>;
. . .
<modificateur> <nom classe>(<args>) {
<corps du constructeur>
}
….
<modificateurs> <type><nom>(<args>) {
<corps de la méthode>
}
….
}
Syntaxe déclaration d'une classe
24
Style de programmation
Majuscule la première lettre des noms de classes.
public class Voiture { . . . }
Pour pratiquement tout le reste (méthodes, attributs, variables) la
première lettre est une minuscule.
Si le nom d'un identificateur est composé de plusieurs mots, ils sont
accolés et la première lettre de chaque mot est mise en majuscule.
Exemples : class ToutesLesCouleurs {. . . }
int unEntierNegatif ;
void calculDePortance(Avion a330) { . . . }
public class voiture { . . . }

25
Modificateur : static
•Concerne les attributs, les méthodes
•Un attribut ou méthode déclaré static existe indépendamment de
toute instanciation.
• Une méthode, pour être de classe (statique), ne doit pas
manipuler d'attributs non statiques de sa classe.
public class ExempleStatique {
public static void main(String[] arg) {
System.out.println("L'ecrivain est " +
UnEcrivain.identificateur);
UnEcrivain.ecrire("bonjour");
}
}
Exemple fichier "ExempleStatique.java"
Exemple :
public class UnEcrivain {
public static String identificateur="Sophie";
public static void ecrire(String chaine) {
System.out.println(identificateur +
" vous dit " + chaine);
}
}
Exemple fichier "UnEcrivain.java"
26
Modificateur : final
•Concerne les attributs, les méthodes
•L'élément est non modifiable ( il s'agit donc d'une constante ! )
Exemple :
public class Cercle {
// attributs
private double x, y ;
private double rayon;
public final double RAYON_MAX = 100.0; // const d'instance
. . .
} // fin classe Cercle
Encore mieux une constante de classe :
public final static double RAYON_MAX = 100.0 ;
27
Les mot clé "this"
Deux cas d'utilisation :
1. Dans une Méthode
 this : désigne l'objet courant
•préfixe les attributs ou les méthodes. Permet de lever
des ambiguïtés
•permet de passer l'objet en paramètre à une autre
méthode
2. Constructeur
Représente un appel à un autre constructeur
• this : appel à un constructeur de la même classe
28
"this"
public class Point {
// structure de données
private double x; // abscisse
private double y; // ordonnée
//constructeurs
public Point(double x, double y ) {
this.x = x;
this.y = y;
}
public Point( ) {
this(0.0, 0.0); // on fait appel au constructeur précédent
}
//méthodes
public void appliquer( Transformation f) {
f.transformer(this);
}
public double getRho( ) {
return Math.sqrt( getX()*getX() + getY()*getY() ); // ou this.getY();
}
public double getX() { return x; } // ou return this.x;
public double getY() { return y; }
}
Point
x
y
Point
x
y
appliquer
getRho