Catgories de variables Le modificateur static

Nos variables jusqu maintenant :

1. Variables dinstance (= attributs)
I Dcrivent les attributs dun objet I Sutilise pour les variables et les mthodes
2. Variables locales
I Si on ajoute static la dclaration dune variable :
I Dclares lintrieur dune mthode
I La valeur de la variable est partage entre
3. Paramtres
toutes les instances de la classe
I Pour envoyer des valeurs une mthode
I Sutilisent comme des variables locales I Pas possible pour les variables locales

Nouveaut : I Si on ajoute static une mthode:

4. Variables statiques = variables de classe I On peut appeler la mthode sans construire dobjet
I Indiques par le modificateur static I Diverses restrictions sur le contenu de la mthode statique
I Ressemblent aux variables dinstance
I Dclares en dehors des mthodes
I Visibles partout dans la classe
I Hrites par les sous-classes

Variables dinstance et de classe Variable statique : exemple

class Abc {
public static void main(String[] args) {
I Variable dinstance: A.c++;
A v1;
I Rservation dune zone pour chaque objet construit avec new v1 = new A();
I Rsultat : chaque objet a sa propre zone/valeur pour la variable dinstance v1.modifier();
}
I Variable de classe (statique) : }
I Dclaration prcde par static class A {
I Rservation dune zone lors du chargement de la classe int b = 1; // variable d'instance
I Aucune zone rserve quand un objet est construit avec new static int c = 10; // variable de classe
void modifier() {
I Rsultat : tous les objets se rfrent la mme zone/valeur pour la variable de
b++;
classe c++;
}
}
Pourquoi utiliser static? Valeur commune

1. Modification dune variable dinstance :

I La valeur change seulement
pour lobjet actuel
Exercice : intgrons une classe Employe le fait que
2. Modification dune variable de classe : 65 ans est lge officiel de dpart la retraite
I La valeur change pour tous
les objets de la classe Considrons les deux versions suivantes :

A quoi sert une variable statique ? I avec une variable dinstance ageRetraite
I avec une variable statique ageRetraite
1. Bonne raison dutiliser une variable statique :
I Reprsentation dune valeur qui est commune tous les objets de la classe

2. Mauvaise raison dutiliser une variable statique :

I Programmer de manire non oriente objet en Java

Classe Employe1 Utilisation de Employe1

I Version avec une variable dinstance pour lge officel de la retraite :
I Version avec une variable dinstance pour lge de la retraite :
class Entreprise {
public static void main(String[] args) {
class Employe1 {
private String nom; Employe1[] employes = new Employe1[350];
private int ageRetraite; employes[0] = new Employe1("Albus", 65);
// ... employes[1] = new Employe1("Oz", 65);
public Employe1(String unNom, int unAgeRetraite) { // ...
nom = unNom;
ageRetraite = unAgeRetraite; // La modification de l'ge de la retraite
// ... reste des initialisations // ncessite un parcours du tableau car chaque
} // employ a sa propre version de la variable :
// ... for (int i = 0; i < employes.length; ++i) {
} employes1[i].ageRetraite = 67;
}
}
}
Classe Employe2 Constantes : final et static
I Version avec une variable statique pour lge officiel de dpart la retraite Pour les constantes communes toutes les instances dune classe :
class Employe2 { I inutile de stocker une valeur pour chaque objet de la classe
// ...
// Seule modification, ageRetraite devient static: I les dclarer en final static
static int ageRetraite;
class Planete {
// ...
// G = constante gravitationnelle
}
// Une variable G pour chaque plante :
class Entreprise {
// Possible
public static void main (String[] args) {
private final double G = 6.674E-8;
// ...
// Remplissage du tableau comme avant.
// Une variable G pour toutes les plantes :
// Modification de l'ge de la retraite :
// BEAUCOUP MIEUX !
// aucun parcours du tableau ncessaire
private final static double G = 6.674E-8;
Employe2.ageRetraite = 67;
employes[0].ageRetraite = 67; // alternative
// ...
employes[250].ageRetraite = 67; // alternative
}
}
}

Levons le voile... System.out.println()

Analysons System.out.println() :
I System : classe prdfinie de Java
I out :
I Variable statique de la classe System
I Il doit sagir dun objet car suivi dun point
Nous sommes maintenant capables de comprendre le format bizarre de certaines
instructions :
I println : mthode de lobjet out
class System {
I System.out.println() par exemple!
//...
static PrintStream out = new PrintStream(...);
//...
}
class PrintStream {
void println (...)
{...}
//..
}
Mthodes statiques Restrictions sur les mthodes statiques
Similairement, si lon ajoute static une mthode Puisquune mthode statique peut tre
on peut alors y accder sans aucun objet appele avec ou sans objet :
class A { I Le compilateur ne peut pas tre sr
static void methode1() {
System.out.println("Mthode 1");
que lobjet this existe pendant
} lexcution de la mthode
void methode2() { I Il ne peut donc pas admettre laccs
System.out.println("Mthode 2");
}
aux variables/mthodes dinstance
} (car elles dpendent de this)
class ExempleMethodeStatique {
public static void main(String[] args) { Conclusion pour les accs dans la mme
A.methode1(); // OK classe :
A.methode2(); // Non !
A v = new A();
I Une mthode statique peut
v.methode1(); // OK, alternative seulement accder dautres
v.methode2(); // OK (comme d'habitude) mthodes statiques et des
} variables statiques
}

Restrictions sur les mthodes statiques (2) Utilit des mthodes statiques

class A {
int i; + Mthodes qui ne sont pas lies un objet
static int j;
void methode1() { Exemple :
System.out.println(i); // OK
System.out.println(j); // OK I Classe mettant disposition des utilitaires mathmatiques divers
methode2(); // OK
}
I La cration dun objet de type MathUtils est artificielle
static void methode2() { I La classe sert seulement stocker des mthodes utilitaires
System.out.println(i); // Faux
System.out.println(j); // OK
methode1(); // Faux class MathUtils {
methode2(); // OK (sauf recursion infinie) public final static double PI = 3.14159265358979323846;
A v = new A(); public static double auCube(double d) {
v.methode1(); // OK return d*d*d;
} }
} }
Utilit des mthodes statiques (2) Mthodes et variables statiques
Eviter la prolifration de static !
On lutilise seulement dans des situations trs particulires :
Utilisation de la classe MathUtils : I dfinition dune constante : attribut final static
I Calculer y = x 3 pour x = 5.7; (situation trs courante)
I On peut accder aux variables/mthodes statiques sans construire dobjet I utilisation dune valeur commune : attribut static
(plus rare)
class Calcul {
public static void main(String[] args) { I mthodes utilitaires quil est artificiel de lier un objet :
double x = 5.7; mthode static, invocable sans objet
double y = MathUtils.PI * MathUtils.auCube(x); (plus rare aussi)
System.out.println(y);
}
} Exemples de mthodes statiques :
I Math.sqrt
I la mthode main

Mthodes auxiliaires de main

Nous comprennons maintenant pourquoi
les mthodes auxiliaires de la mthode
main sont statiques
(mais pas les mthodes dans les classes)

La mthode main a un en-tte fixe :

public static void main(String[] args)
Puisque la mthode main est obligatoirement statique :
I elle ne peut pas accder lobjet this
I elle ne peut pas accder des variables/mthodes dinstance
I elle peut seulement accder des variables/mthodes statiques
En dehors de cela, la classe de la mthode main est comme nimporte quelle
classe.
Elle peut avoir des constructeurs, des mthodes et des variables
Encore un jeu . . . Premire bauche de conception (1)

Supposons que lon souhaite programmer

un jeu mettant en scne les entits class Entite
suivantes :
void evolue(...)
1. Balle
2. Raquette
3. Filet
4. Joueur
Chaque entit sera principalement dote class Balle class Raquette class Filet class Joueur
dune mthode evolue, grant lvolution
de lentit dans le jeu.

Premire bauche de conception (2) Jeu vido impossible

Idalement, il nous faudrait mettre en place une hirarchie de classes telle que
celle-ci :
Si lon analyse de plus prs les besoins du jeu, on ralise que :
class Entite class Interactif
I certaines entits doivent avoir une reprsentation graphique void gestionClic()
void evolue(...)
(Balle, Raquette, Filet)
I . . . et dautres non (Joueur)

I certaines entits doivent tre interactives

(on veut par exemple pouvoir les contrler avec la souris) : class Balle class Raquette class Filet class Joueur

Balle, Raquette
I . . . et dautres non : Joueur, Filet
class Graphique

+ Comment organiser tout cela ?

void dessiner()

Mais . . . Java ne permet que lhritage simple : chaque sous-classe ne peut avoir
quune seule classe parente directe !
Hritage simple/multiple Analyse

I Pourquoi pas dhritage multiple en Java ?
I Parfois difficile comprendre (quel sens donner ?), y compris pour le compilateur
(par exemple si une sous-sous-classe hrite dune super-super-classe par
diffrents chemins)
I Si une variable/mthode est dclare dans plusieurs super-classes
I Ambigut : laquelle utiliser, comment y accder ?
Mais en fait, que souhaitait-on utiliser de lhritage multiple dans le cas de notre
exemple de jeu vido ?
+ Le fait dimposer certaines classes de mettre en oeuvre des mthodes
communes
Par exemple :
I Balle et Raquette doivent avoir une mthode gestionClic;
I mais gestionClic ne peut tre une mthode de leur super-classe (car na pas
de sens pour un Joueur par exemple).

+ Imposer un contenu commun des sous-classes en dehors dune relation

dhritage est le rle jou par la notion dinterface en Java.

Alternative possible de jeu vido Interfaces (1)

class Entite interface Interactif
void evolue(...) void gestionClic() Syntaxe :
interface UneInterface { constantes ou mthodes abstraites }

Exemple :
class Balle class Raquette class Filet class Joueur
interface Graphique {
void dessiner();
}
interface Interactif {
interface Graphique
void gestionClic();
void dessiner()
}

Il ne peut y avoir de constructeur dans une interface

I Interface 6= Classe + Impossible de faire new !
I Une interface permet dimposer certaines classes davoir un contenu
particulier sans que ce contenu ne fasse partie dune classe.
Interfaces (2) Variable de type interface

Attribution dune interface une classe : Une interface attribue un type supplmentaire une classe dobjets, on peut donc :
Syntaxe :
I Dclarer une variable de type interface
class UneClasse implements Interface1, . . . , InterfaceN
{ ... }
I Y affecter un objet dune classe qui implmente linterface
I (ventuellement, faire un transtypage explicite vers linterface)

Exemple : Graphique graphique;

Balle balle = new Balle(..);
class Filet extends Entite implements Graphique { graphique = balle;
public void dessiner() { ... } Entite entite = new Balle(..);
} graphique = (Graphique) entite; // transtypage indispensable !

Plusieurs interfaces Interface Rsum (1)

Une interface est un moyen dattribuer des composants communs des classes
Une classe peut implmenter plusieurs interfaces (mais tendre une seule classe) non-lies par une relation dhritage :
I Sparer les interfaces par des virgules
+ Ses composants seront disponibles dans chaque classe qui limplmente
Exemple :
Composants possibles :
class Balle extends Entite implements Graphique, Interactif {
// code de la classe 1. Variables statiques finales (assez rare)
}
+ Ambigut possible, nom unique exig
On peut dclarer une hirarchie dinterfaces :
2. Mthodes abstraites (courant)
I Mot-cl extends
+ Chaque classe qui implmente linterface sera oblige dimplmenter chaque
I La classe qui implmente une interface reoit aussi le type des super-interfaces mthode abstraite dclare dans linterface si elle veut pouvoir tre instancie
interface Interactif { ..} + Une faon de garantir que certaines classes ont certaines mthodes, sans passer
interface GerableParSouris extends Interactif { ... } par des classes abstraites
interface GerableParClavier extends Interactif { ... }
+ Aucune ambigut car sans instructions
Interface Rsum (2)

Nous avons vu que lhritage permet de mettre en place une relation de type
est-un entre deux classes.

Lorsquune classe a pour attribut un objet dune autre classe, il stablit entre les
deux classes une relation de type a-un moins forte que lhritage (on parle de
dlgation).

Une interface permet dassurer quune classe se conforme un certain protocole.

Elle met en place une relation de type se-comporte-comme : une Balle

est-une entit du jeu, elle se-comporte-comme un objet graphique et
comme un objet interactif.