Table des matières 1 La notion de package

Plan du cours
Table des matières
1
La notion de package
1
2
Les chaînes de caractères
2
3
Retour vers les objets
4
4
Les interfaces
6
1
La notion de package
Organisation générale d’un projet Java
Pour le moment, nos applications Java sont constituées de
– un ensemble de classes
– chaque classe dans un fichier
– le nom du fichier sera exactement identique au nom de la classe, aux majuscules
près
Organisation générale d’un projet Java
Dans les projets plus grands :
– les classes peuvent être rangées dans différents répertoires et sous-répertoires
– les classes qui sont dans un même répertoire sont dans un même paquetage ou
package
– le nom d’un package est composé des noms des répertoires formant le chemin
d’accès à ses classes, séparés par un .
– les noms des répertoires commencent par une minuscule.
Déclaration de package
La définition des classes commence par la désignation du package dans lequel la
classe se trouve.
Cette indication est optionnelle.
Si cette instruction est présente, elle doit être la première instruction du fichier.
package monrep.monsousrep;
Le chemin monrep.monsousrep doit indiquer la liste des sous-répertoires à
traverser pour atteindre cette classe.
Les API Java
API : Application Programming Interface
C’est l’ensemble des classes Java déjà programmées auxquelles vous avez accès.
Elles sont organisées en packages et sous-packages. En voici quelques uns :
– java.lang
– java.util
– java.awt
– java.awt.event
– javax.swing
– ...
Importation de classes
Par défaut, accès à toutes les classes définies :
– dans java.lang
– dans votre répertoire courant
Pour utiliser des classes provenant d’autres packages, on utilise l’instruction
import.
Par exemple import java.util.Date ;
Plus généralement
import rep1.rep2.UneClasse;
import rep1.rep3.*;
Cette instruction doit se trouver après l’instruction package, si elle est présente,
et avant la définition de la classe.
Utiliser les classes d’un package
Pour pouvoir utiliser une classe CCC d’un package PPP, il faut :
– que CCC soit définie public dans le package PPP ;
– que le code qui veut utiliser CCC l’indique par une instruction import PPP.CCC ;,
ou bien import PPP.* ;.
Dans un même package, les classes sont définies public ou rien. Si une classe est
déclarée public, alors elle est accessible en dehors du package auquel elle appartient.
Par défaut, (i.e. sans public), l’accès à la classe sera dit package et la classe ne sera
accessible que par les classes du même package.
La variable CLASSPATH
La variable classpath permet au compilateur javac et à l’interprète java de
savoir où se trouvent les classes utilisées.
Par défaut, classpath contient . et le chemin d’accès aux API Java.
2
Les chaînes de caractères
La classe String
– à noter : pas obligatoirement de new pour créer un objet String ;
2
– une String est implémentée comme un tableau constant de caractères ;
– ⇒ on ne modifie pas une String, on créé un nouvel objet String (la classe String
est une classe non modifiable).
La classe String
Quelques méthodes : int length() char charAt(int ind) boolean
equals(String s) int indexOf(char c) String substring(int début,int
fin) String substring(int début) String trim()
Les classes StringBuffer et StringBuilder
Les classes StringBuffer et StringBuilder implémentent les chaînes de
caractères, comme la classe String, à la différence qu’une instance de StringBuffer
ou de StringBuilder est modifiable.
⇒ plus efficace lorsqu’on effectue beaucoup de modifications sur une chaîne de
caractères.
Les classes StringBuffer et StringBuilder
Les principales méthodes : append, insert, setCharAt,. . .
StringBuilder a de meilleures performances que StringBuffer, mais n’est
pas robuste par rapport aux accès concurrents.
StringBuilder existe depuis le JDK 1.5.
StringBuilder est la classe habituellement utilisée.
Exemple
On veut qu’un bibliobus affiche tous les livres qu’il contient :
// Dans la classe Promotion
public String toString(){
StringBuilder sb = new StringBuilder();
sb.appnd(nom);
if (nbEtudiants>0) {
sb.append("Voici mes étudiants");
for (int i=0;i<nbEtudiants;i++){
sb.append("\n");
sb.append(lesEtudiants[i].getPrenom());
sb.append(" ");
sb.append(lesEtudiants[i].getNom());
}
}
return sb.toString();
}
3
3
Retour vers les objets
Durée de vie des variables et des objets
– un objet existe tant qu’il existe une référence vers lui ;
– une variable d’instance d’un type primitif existe tant qu’il existe une référence
vers l’objet auquel elle appartient.
Définition d’une classe
Une classe est définie par :
– ses attributs, ou variables
– ses méthodes
Les attributs sont définis par leur type ;
Les méthodes sont définies par leur signature.
Les méthodes
Signature d’une méthode
On appelle signature d’une méthode son nom, le type de ce qu’elle retourne, et la
nature de ses arguments. C’est ce qu’on appelle parfois aussi son entête.
Les méthodes
Surcharge de méthodes
C’est la possibilité d’avoir un même nom de méthode avec des signatures différentes (et donc des comportements différents). C’est la nature des paramètres effectifs
qui détermine la méthode exécutée.
Le compilateur choisit la méthode à utiliser par concordance de l’appel et de la
signature.
Variables de classe et variables d’instance
– une variable de classe (static) est une variable qui n’est créée qu’une seule
fois par classe, et qui est partagée par toutes les instances de cette classe ;
– une variable d’instance est une variable qui existe pour chaque instance d’une
classe, et qui contient une valeur relative à l’instance à laquelle elle appartient.
Exemples :
– les constantes d’une classe
– les variables qui contiennent une information relative à l’ensemble des instances
d’une classe (compteur d’instances,. . .)
Méthodes d’instance, méthodes de classe
Une méthode qui ne manipule aucune variable d’instance (par exemple, une méthode qui effectue un calcul uniquement à partir de ses paramètres) a vocation à être
déclarée static.
4
public static boolean estValide(String nom){
return (nom.length()<MAXLG);
}
Les modificateurs d’accessibilité
A l’intérieur d’une classe, une variable ou une méthode peut être définie avec un
modificateur d’accès. Les différents modificateurs d’accessibilité sont :
private l’élément (variable ou méthode, d’instance ou de classe) est privé, il n’est
accessible que depuis la classe elle-même (le code de la classe ds laquelle il est
défini) ;
pas de modificateur d’accès l’accès est dit package.
protected l’accès est étendu (par rapport à private au code des classes du même
package et aux sous-classes de la classe. Nous reviendrons plus tard sur cette
notion, liée à l’héritage ;
public accessible à partir de tout code qui a accès à la classe où l’élément est défini.
This
Le mot-clé this désigne l’instance courante.
Il peut être utilisé :
– pour accéder à un membre de l’instance this.nom = nom ;
– pour passer sa référence à un autre objet Dans la classe Personne Livre liv
= new Livre(...) ; liv.jeTEmprunte(this) ; et Livreimplémente
la méthode void jeTEmprunte(Personne p) ;
Le mécanisme de création et d’initialisation d’un objet
1. les variables de classe sont créées dès les premier appel à la classe (soit pour une
instanciation – appel à new, soit par un accès direct à une variable de classe) :
(a) initialisés au niveau de la déclaration ;
(b) les constructeurs de statiques (plus rares) ;
2. les variables d’instance initialisées hors constructeur (à la déclaration) ;
3. exécution du constructeur ;
Exemple
public class FeuTricolore{
public static final String[] COULEURS =
{"ROUGE","ORANGE","VERT"};
private int feu;
public FeuTricolore(int feu){
this.feu = feu%COULEURS.length;
}
public FeuTricolore(){}
5
public String toString(){
return COULEURS[feu];
}
public void tourne(){
feu = (feu+1)%COULEURS.length;
}
}//FeuTricolore
Exemple
public static void main(String[] args){
System.out.println("Quelles sont les "
+ "couleurs possibles?");
for(int i=0;i<FeuTricolore.COULEURS.length;
i++)
System.out.println(FeuTricolore.COULEURS[i]);
FeuTricolore ft = new FeuTricolore(2);
System.out.println(ft);
for (int i=0;i<10;i++){
ft.tourne();
System.out.println(ft);
}
}//main
4
Les interfaces
Les interfaces
Décomposer un problème en sous-problèmes :
– c’est définir le contrat à respecter par chaque partie
– c’est définir les protocoles de communication entre objets
contrat ≡ interface
Une interface n’est pas une classe :
– elle ne peut pas être instanciée (pas de new) ;
– elle n’implémente aucune méthode.
Une interface ne peut contenir que
– la signature de méthodes (public)
– la déclaration de constantes (public static final)
Exemple
public interface Automobiliste {
public static final String NVLE_IMMAT
= "1111WWW99";
6
public void acheteUneVoiture(Voiture v);
public void acheteUneVoiture(String immat);
public void vendVoiture();
}
Déclaration d’une interface
– Une interface est dans un fichier du même nom que l’interface ;
– Une interface peut être déclarée dans un package ;
– Une interface est public ou rien (i.e. package) ;
– Un fichier qui contient une définition d’interface peut contenir des instructions
import ;
Implémentation d’une interface
Une classe, si elle implémente une interface, doit fournir une implémentation pour
toutes les méthodes définies dans l’interface.
Une classe peut implémenter plusieurs interfaces.
Syntaxiquement :
class NomDeLaClasse implements NomDUneInterface, NomDUneAutreInterface{
...}
Exemple
public class Personne implements Automobiliste{
private String nom;
// tous les attributs d’une Personne ...
private Voiture v;
public void acheteUneVoiture(Voiture v){
if ((v==null) && v.estAchetee(this))
this.v = v;
}
public void acheteUneVoiture(String immat){
if (v==null)
v = new Voiture(immat);
}
public void vendVoiture(){
v = null;
}
// et les autres methodes et constructeurs...
}//Personne
Typage
– Les définitions d’interface créent des noms de types tout comme le font les définitions de classe.
– On peut utiliser le nom d’une interface comme le nom de type d’une variable ;
– Toute instance d’une classe qui implémente cette interface peut être affectée à
cette variable.
7
Typage
Automobiliste a = new Personne("Dup","Jean",32);
Personne p = new Personne("Dur","Paul",28);
a.acheteUneVoiture("2345ABC62");
p.acheteUneVoiture("1234ABC59");
p.changeSociete("Marastoca");
a.changeSociete("Marastoca");//Refus
Conflit de noms
Une classe peut implémenter plusieurs interfaces.
Que se passe-t-il si un même nom de méthode se trouve défini dans plusieurs interfaces ?
Plusieurs cas :
– même signature. Pas de conflit.
– les signatures différent par les paramètres. Pas de conflit : surcharge
de méthodes
– les signatures ne diffèrent que par leur type de retour. Conflit ! Il n’est pas possible qu’une classe implémente ces deux interfaces en même temps.
8