Protection et portée (1)

Java : notions complémentaires
(portée, protection, modificateurs, interfaces, exceptions)
Master 1ère année
Julien Velcin
http://mediamining.univ-lyon2.fr/velcin
Protection et portée (1)
utilisation de la classe
Programmeur B
définition de la classe
Programmeur A
Contre-exemple :
public class Vecteur {
public double [] tab;
}
public static void main(…) {
Vecteur v = new Vecteur() ;
v.tab = new double[5] ;
v.tab[6] = 2.5;
}
Mauvaise définition ! 2.5
v.tab
v.tab
Protection et portée (2)
• Objectifs :
o développement = travail d’équipe.
â risques d’erreurs et de mauvaise utilisation.
o contrôler l’accès aux champs.
o masquer le code interne au fonctionnement d’une classe.
• Portée : niveaux de visibilité
Mots clefs :
private (-): classe courante.
protected (#): classe courante et héritiers.
public (+): classe courante, héritiers et instances.
à insérer avant la déclaration des champs/méthodes.
Protection et portée (3)
• Démarche et mécanisme :
o empêcher l’accès direct aux champs.
accesseurs : méthodes d’accès à un champ.
mutateurs : méthodes de modification d’un champ.
o définir la porté des méthodes.
accesseur
mutateur
champs “price” caché
Exemple :
public class Vecteur {
private int price;
public void setPrice(int val) {
if (val > 0) price = val;
}
public int getPrice() {
return price;
}
}

// accesseur
Protection et portée (4)
// mutateur
// méthode interne
Exemple :
public class Vecteur {
private double[] tab ;
public void initialiser(int taille) {
tab = new double[taille];
}
private boolean controleIndice(int i) {
return (i>=0 && i<tab.length);
}
public void setTab(int i, double valeur) {
if (controleIndice(i))
tab[i] = valeur ;
}
}
Protection et portée (5)
// ne compile pas !
// accès contrôlé : pas d’erreur
Exemple (suite) :
Vecteur v = new Vecteur() ;
v.initialiser(5) ;
v.setTab(6,2.5);
v.tab[6] = 2.5;
Protection et portée (6)
Exercice:
Modifier le programme Location pour tenir compte de la protection.
Exemple :
private int km;
public int getKm() {
return …;
}
public void setKm(…) {
km = p_km;
}
Les modificateurs (1)
• Définition :
Un modificateur est un mot-clef indiquant des particularités de
classes, méthodes ou champs.
Syntaxe :
public modificateur class NomClasse {…}
public modificateur type nomFonction (int param1) {…}
public modificateur type nom_variable;

• La clause static :
Rappel, calcul du prix d'un location
• tourisme : 50 Є + 30 Є / jour + 0.50 Є / km
⎝ Champ (variable) mais
valeur identique pour tous les petits vehicules de tourisme.
Les modificateurs (2) - static
Aujourd’hui, mais demain ?
LocaTourisme
double prix_jour;
double calculPrix();
LocaTourisme client1 = new LocaTourisme();
LocaTourisme client2 = new LocaTourisme();
Contrainte :
client1.prix_jour = client2.prix_jour.
Les modificateurs (3) - static
• La clause static :
application : champs et méthodes
a) Application aux champs :
Espace mémoire unique pour toutes les instances de la classe.
l2
prix
km
nb_jours
prix_jour
charge
l1
Les modificateurs (4) - static
Exemple :
LocaTourisme l1 = new LocaTourisme ();
LocaTourisme l2 = new LocaTourisme ();
l1.prix_jour = 30;
l2.prix_jour = l2.prix_jour + 15;
public class LocaTourisme {
public static double prix_jour;
...
}
l2
prix
l1
l2
km
nb_jours
prix_jour
charge
l1
30
l2 l1
45
km
nb_jours
prix_jour
charge
km
nb_jours
prix_jour
charge
Les modificateurs (5) - static
Idiot !
b) Application aux méthodes :
Méthodes invocables sans instanciation de la classe.
Exemple :
public class LocaTourisme {
public static void changePrixJour(double p_prix_jour) {
prix_jour = p_prix_jour;
}
}
public static void main(…) {
LocaTourisme.changePrixJour(45);
LocaTourisme l = new LocaTourisme();
l.changePrixJour(45);
}

Les modificateurs (6) - abstract
Location
- double prix
- double km
- double nb_jours
+ void saisieInfos()
+ void afficherPrix()
+ double calculPrix()
LocaTourisme LocaUtilitaire
- boolean charge
+ double calculPrix()
- boolean a_velo
- double prix_jour
+ double calculPrix()
+ void changePrixJour(double p)
jamais instanciée ⇒ abstract
Les modificateurs (7) - abstract
• La clause abstract :
application : classes et méthodes
a) Application aux classes :
• objets non manipulés par le programme.
• centralise les informations.
b) Application aux méthodes :
• détermine les méthodes obligatoires des classes filles.
• pas de corps (quoique… à partir de Java 8 !)
Note :
• Une classe abstraite est non instanciable.
• Une classe redéclare les méthodes abstraites héritées.
Les modificateurs (8) - abstract
public abstract class Location
{
public abstract double calculPrix();
}
public class LocaTourisme extends Location
{
public double calculPrix() {
prix = 30*jours + 0,5*km;
return super.calculPrix();
}
}
...
Les modificateurs (9) - final
• La clause final :
application : classes, méthodes et champs
a) Classes :
• Étendue
b) Méthodes :
• Outrepassée
c) Champs :
• Modifiable ⇒ Cste

Interfaces (1)
Pas d’héritage multiple en Java.
è On utilise des interfaces.
• Interface = Comportements des objets.
Ex : s’écrire dans un fichier, se dessiner à l’écran …
Comportement ⇒ méthodes
• Interface = Contrat entre objets.
Ex : classe ObjectInputStream = « j accepte d écrire les objets
dans un flux SI ils signent le contrat de sérialisation.»
Interfaces (2)
jécris les objets
dans un flux
ObjectOutputStream
jaccepte dêtre
écrit dans un flux
MonObjet
Serializable
Comportement : se « sérialiser »
Interfaces (3)
• Objectifs :
Permettre à des classes sans relations d’héritage d’utiliser des
méthodes communes.
• Démarche et mécanisme :
o interface = classe abstraite.
§ méthodes: abstract & public
§ champs: public, static & final
o implémentation / différentes classes
§ définition du corps des méthodes obligatoires
(à partir de Java 8 : existence d’implémentations par défaut)
Interfaces (4)
public interface NomInterface {
type nom_variable;
type methode_un (type nom_param);
}
Syntaxe :
⇔ public static final …
public class NomClasse implements NomInterface {
type methode_un (type nom_param) {
…
}
}
NomInterface.java
Obligatoire !
⇔ abstract …