Cours de JAVA Classes et Variables d`instance

Cours de JAVA
Classes et Variables d'instance
Une classe est un modèle qui permet de créer des objets. Un objet ou bien une instance d'une classe est créée
suivant le modèle définit par la classe.
Ex: vous (objet ou instance) de la classe personne.
Classe Personne, Point2D, Trinôme, Cylindre ...
Une classe comporte - des données appelées variables d'instances (qui définissent l'état de l'objet)
- des méthodes appelées méthode d'instance (qui définissent le comportement)
Diagramme de Classe :
Une classe est représentée par un diagramme de la forme :
NomClass
Variables d'instance
Méthodes d'instance
Ex: Classe Personne Classe Cylindre
Personne Cylindre
Nom
Prenom
Rayon
Hauteur
Poids saisir
saisir
afficher
afficher
retourner volume
retourner surface
Début d'une classe :
Déclaration dans un fichier qui porte le nom : NomClasse.java
//NomClass.java
public class nomClass {
...
}
Déclaration de variable d'instance :
On indique le type + le nom
UT Béthune - Département R&T Année 2005-2006 by Demoutiez Philippe

NomClass
T1 Varhost1
T2 Varhost2, Varhost3
Ex:
//NomClass.java
public class nomClass {
T1 Varhost1;
T2 Varhost2, Varhost3;
}
//Personne.java
public class Personne {
String nom;
int age;
double poids;
...
}
//Cylindre.java
public class Cylindre {
double rayon;
double hauteur;
...
}
//Point2D.java
public class Point2D {
double x;
double y;
...
}
Compilation du fichier NomClass.java :
javac NomClass.java
Création d'une instance , appel du constructeur par défaut :
new NomClass( );
Cet appel réserve une zone mémoire aux variables
ex: new Cylindre( );
Référencement d'une instance :
NomClass refObj = new NomClass( );
Cylindre c = newCylindre( );
Il est possible de créer plusieurs instances :
Cylindre c1 = newCylindre( );
Cylindre c2 = newCylindre( );
On a donc deux instances de la classe Cylindre référencées respectivement par c1 et c2.
Différence entre: - déclaration d'une référence : NomClass refObj; et
–construction d'une instance, puis affectation d'une référence: refObj = nomClass( );
–
Accès aux variables d'instance :
L'opérateur: .
Il permet d'accéder aux variables d'instances
//TestCylindre.java
UT Béthune - Département R&T Année 2005-2006 by Demoutiez Philippe
refObj
refObj.varInst1
refObj.varInst3
refObj.varInst2

public class TestCylindre{
public static void main (String [] args){
Cylindre c = new Cylindre;
c.rayon=2;
c.hauteur=10;
//calcul du volume
double vol = 2*Math.PI+c.rayon*c.hauteur;
System.out.println("Volume =" + vol);
}
}
//Point2D.java
public class Point2D{
double x;
double y;
}
//TestPoint2D.java
public class TestPoint2D{
public static vois main (String [] args){
Point2D p = new Point2D;
p.x=5;
p.y=7;
System.out.println("("+p.x+ "," +p.y+")");
}
}
Classes et Méthodes d'instance
Une méthode d'instance comporte :
●une entête
●un corps
L'entête (prototype) donne :
●le type de la valeur retournée par la méthode
●le nom de la méthode
●les types et noms des paramètres de la méthode
T method (T1 pf1, T2 pf2, ... Tn pfn)
Si une méthode ne retourne rien, la valeur T = « void »
//Cylindre.java
public class Cylindre{
double rayon;
double hauteur;
void saisir(){
rayon = readDouble("rayon: ");
hauteur = readDouble("hauteur: ");
}
void afficher(){
System.out.println("rayon: "+rayon+"hauteur :"+hauteur);
double v=4*Math.PI*rayon*rayon*hauteur;
return v;
}
}
Appel d'une méthode :
Il faut donner une méthode:
●référence de l'objet sur lequel est appliquée la méthode
●l'opérateur « »
●la liste des paramètres passés à la méthode
UT Béthune - Département R&T Année 2005-2006 by Demoutiez Philippe

refObj.method(pe 1, ... pen) paramètres effectifs
La valeur retournée par une méthode doit être utilisée :
●soit en l'affectant à une autre variable
●soit en l'affichant à l'ecran
●soit en le passant comme caractère à une autre méthode
Méthode qui ne retourne pas de valeur :
c.saisir();
Méthode qui retourne une valeur :
vol = c.volume(); ou
System.out.println( c.volume() );
//TestCylindre.java
public class TestCylindre{
public static void main(Sting [] args){
c.rayon=2;
c.hauteur=10;
double v1 = c.volume();
System.out.println("vol :"+v1);
System.out.println("masse :"+c.masse(1.5e3));
//augmentation de 10%
c.rayon=1.1*c.rayon;
c.hauteur=1.1*c.hauteur;
c.affcher();
double v2=c.volume();
System.out.println("vol :"+v2);
double d=v2-v1;
System.out.println("augmentation :"+d);
}
}
Principe d'encapsulation :
Les variables d'instances d'une classe ne doivent être accessible qu' aux Méthodes de la classe.
Le contrôle de leurs valeurs peut être centralisé au niveau de la classe.
Pour cela, on les déclare avec le modificateur d'accès « privé ». Au contraire, les Méthodes d'une classe sont accessibles
à l'extérieur de la classe, elles sont donc déclarées d'accès public.
Comme les variables sont devenues privées, il faut prévoir des Méthodes supplémentaires d'instance qui vont permettre:
●d'obtenir la valeur d'une variable d'instance
●ou de modifier la valeur d'une variable d'instance
Ces Méthodes particulières sont appelées « accesseurs » en lecture ou en écriture.
UT Béthune - Département R&T Année 2005-2006 by Demoutiez Philippe
Variables
d'instances
set get
methodes
ecrire
lire

Cylindre
- double rayon
- double hauteur
+ void saisir( )
+ void afficher( )
+ double volume( )
+ double masse (double rho)
+ double getRayon( )
+ double getHauteur( )
+ void setRayon(double r)
+ void setHauteur( double h)
//Cylindre.java
public class Cylindre{
private double rayon;
private double hauteur;
public void saisir(){ ... }
public void afficher(){ ... }
public double volume(){ ... }
public double getRayon(){
return rayon;
}
public double getHauteur(){
return hauteur;
}
public void setRayon(double r){
rayon = r;
}
public void setHauteur(double h){
hauteur = h;
}
}
//TestCylindre.java
public class TestCylindre{
public static void main(String[]args){
Cylindre c = new Cylindre();
c.setHauteur(2);
c.setRayon(3);
double v = c.volume();
System.out.println("masse"+c.masse(1.5e3));
//on augmente le rayon
c.setRayon(1.1*c.getRayon());
c.setHauteur(1.1*c.getRayon());
c.afficher();
double v2 = c.volume();
System.out.println("volume :"+v2);
double d = v2-v;
System.out.println("augmentation vol:"+d);
}
}
Constructeurs :
Utilité d'un constructeur:
//TestCylindre.java
public class TestCylindre{
public static void main(String[]args){
Cylindre c = new Cylindre();
double v = c.volume();
System.out.println("volume :"+v);
}
}
Ce programme peut être compilé, puis exécuté mais on obtient la valeur 0 car la hauteur et le rayon du cylindre n'ont pas
été initialisés. La version correcte du programme.
Cylindre c = new Cylindre();
double v = c.volume();
System.out.println("vol"+v);
UT Béthune - Département R&T Année 2005-2006 by Demoutiez Philippe