Java guide de formation complet pour apprendre les bases de programmation
Java pdf guide de formation complet pour apprendre les bases de programmation
1.1.2 Formats de fichiers
Les programmes java contiennent ce que l’on appelle des classes. Pour le moment nous ne mettrons qu’une seule classe par fichier et nous donnerons au fichier le même nom que la classe qu’il contient. Les fichiers sources portent l’extension .java tandis que les programmes compilés portent l’extension .class. Le compilateur que nous avons invoqué en ligne de commande avec l’instruction java c, a générale fichier .class correspondant au fichier source passé en argument.
1.1.3 Machine virtuelle
Le fichier .class n’est pas un exécutable, il contient ce que l’on appelle du pseudo-code. Le pseudo code n’est pas exécutable directement sur la plate-forme (système d’exploitation) pour laquelle il a été compilé, il est nécessaire de passer par un logiciel appel une machine virtuelle. La machine virtuelle
lit le pseudo-code et l’interprète (i.e. l’exécute). Le grand avantage de Java est que le pseudo code ne dépend pas de la plate-forme mais de la machine virtuelle. Un programme compilé peut être exécuté par n’importe quel OS, la seule nécessité est de posséder une machine virtuelle Java (JVM) adaptée à cette plateforme.
1.1.4 Linkage
En java, le linkage se fait à l’exécution, cela signifie que si vous modifiez un fichier, vous aurez une seule classe à recompiler, et vous pourrez immédiatement exécuter votre application.
1.2 Le Java procédural
Ce cours vous introduit au Java dans sa dimension procédurale. Le but de ce cours est de vous familiariser avec les instructions de base avant d’aborder les concepts de la programmation objet.
1.2.1 Structure d’une classe
Pour le moment, nous appellerons classe un programme Java. Une classe se présente de la sorte: class NomClasse
{
Class contents
}
Vous remarquez que de façon analogue au C, une classe est un bloc délimitépar des accolades et que les commentaires d’écrivent de la même façon. On ecrit les noms des classes en concaténant les mots composant ce nom et en faisant commencer chacun d’eux par une majuscule. N’oubliez pas de ne mettre qu’une seule classe par fichier et de donner au fichier le même nom que celui de cette classe.
1.2.2 Variables
Nous disposons en Java des mêmes types qu’en C. Tous les types mis à votre disposition par Java sont appelétypes primitifs.
Booléens
L’un deux nous servira toutefois à écrire des choses que l’on rédige habituellement de façon crade en C : boolean. Une variable de type boolean peut prendre une des deux valeurs true et false, et seulement une de ces deux valeurs. On déclare et utilise les variables exactement de la même façon qu’en C.
Chaines de caractères
Il existe un type chaîne de caractères en C. Nous l’examinerons plus détails ultérieurement. Les deux choses à savoir est que le type chaîne de caractères est String, et que l’opérateur de concaténation est +.
final
Les variables dont la déclaration de type est précédée du mot-cléfinal sont non-modifiables. Une fois qu’une valeur leur a étéaffecté, il n’est plus possible de les modifier. On s’en sert pour représenter des constantes. Les règles typographiqus sont les mêmes : toutes les lettres en majuscules et les mots séparés par des . Par exemple, final int TAILLE = 100;
Déclare une constante TAILLE de type int initialisée à 100.
1.2.3 Entrées-sorties
La saisie de variables est un calvaire inutile en Java, nous nous en passerons pour le moment. Pour afficher un message, quel que soit son type, on utilise le sous-programme System.out.print. Par exemple, System . out. print (” Hello World\n” ) ;
Le sous-programme System.out.println ajoute automatiquement un retour à la ligne après l’affichage. On aurait donc pu écrire :
System. out. println (” Hello World” ) ;
Il est aussi possible d’intercaler valeurs de variables et chaînes de caractères constantes, on sépare les arguments par des +. Par exemple,
System. out. println (”La valeur de a est ” + a + ” et celle de b est ” + b ) ;
1.2.4 Sous-programmes
On définit en Java des sous-programmes de la même façon qu’en C, attention toutefois, les sous-programmes que nous définirons dans ce cours seront déclarés avec le mot-cléstatic. Par exemple, si je veux faire un sous-programme qui retourne le successeur de la valeur passée en argument cela donne
class TestJavaProcedural {
static int succ(int i ) {
return i + 1;
}
/∗
Autres sous−programmes
∗/
}
Si vous oubliez le mot cléstatic, le compilateur vous enverra des insultes. Nous verrons plus tard ce que signifie ce mot et dans quels cas il est possible de s’en passer. Attention : Tous les types primitifs en Java se passent en paramètre par valeur, et cette fois-ci je ne vous mens pas!
1.2.5 Main
Lorsque vous invoquez la machine virtuelle, elle part à la recherche d’un sous-programme particulier appelémain. Il est impératif qu’il soit défini comme suit :
public static void main(String [ ] args)
{
instructions
}
La signification du mot-clépublic vous sera expliquée ultérieurement. La seule chose dont il faut prendre note est que vous ne devez pas l’oubliez, sinon la machine virtuelle vous enverra des insultes!
1.2.6 Instructions de contrôle de flux
En Java, les instructions if, switch, for, while et do ... while se comportent de la même façon qu’en C. Donc, pas d’explications complémentaires...
1.2.7 Exemple récapitulatif
Nous avons maintenant tout ce qu’il faut pour écrire un petit programme : public class Exemple
/∗
Retourne lenombre b eleve a la puissance n.
∗/
static int puissance(int b , int n)
1
int res = 1;
for (int i = 1 ; i <= n ; i++) res ∗= b ;
return res;
}
/∗
Affiche {2ˆk | k = 0 , .. . , 30}.
∗/
public static void main( String [ ] args )
{
for (int k = 0 ; k <= 30 ; k++)
System . out. println ( ”2^” + k + ” = ” + puissance(2, k ) ) ;
}
1.3 Ob jets
Dans un langage de programmation, un type est
– Un ensemble de valeurs
– Des opérations sur ces valeurs
En plus des types primitifs, il est possible en Java de créer ses propres types. On appelle type construit un type non primitif, c’est-à-dire composéde types primitifs. Certains types construits sont fournis dans les bibliothèques du langage. Si ceux-làne vosu satisfont pas, vous avez la possibilitéde créer vos propres types.
1.3.1 Création d’un type
Nous souhaitons créer un type Point dans R2. Chaque variable de ce type aura deux attributs, une abscisse et une ordonnée. Le type point se compose donc à partir de deux types flottants. Un type construit s’appelle une classe. On le définit comme suit :
public class Point
{
float abscisse ; float ordonnee ;
}
Les deux attributs d’un objet de type Point s’appelle aussi des champs. Une fois définie cette classe, le type Point est une type comme les autres, il devient donc possible d’écrire
Point p , q ;
Cette instruction déclare deux variables p et q de type Point, ces variables s’appellent des objets. Chacun de ces objets a deux attributs auxquels on accède avec la notation pointée. Par exemple, l’abscisse du point p est p.abscisse et son ordonnée est p.ordonnee. Le fonctionnement est, pour le moment, le même que pour les structures en C.
1.3.2 Les méthodes
Non contents d’avoir défini ainsi un ensemble de valeurs, nous souhaiterions définir un ensembe d’opérations sur ces valeurs. Nous allons pour ce faire nous servir de méthodes. Une méthode est un sous-programme propre à chaque objet. C’est-à-dire dont le contexte d’exécution est délimitépar un objet. Par exemple,
public class Point {
float abscisse ; float ordonnee ;
void presenteToi ()
{
System. out . println (”Je suis un point , mes coordonnées sont (”
+ abscisse + ” , ” + ordonnee + ”)” ) ;
}}
La méthode presenteToi s’invoque à partir d’un objet de type Point. La syntaxe est p.presenteToi() oùp est de type Point. p est alors le contexte de l’exécution de presenteToi et les champs auquel accèdera cette méthode seront ceux de l’objet p. Si par exemple, on ecrit q.presenteToi(), c’est q qui servira de contexte à l’exécution de presenteToi. Lorsque l’on rédige une méthode, l’objet servant de contexte à l’exécution de la méthode est appelél’objet courant.
1.3.3 L’instanciation
Essayons maintenant, impatients et nerveux, de vérifier ce que donnerait l’exécution de
public class Point {
float abscisse ; float ordonnee ;
void presenteToi ()
{
System. out . println (”Je suis un point , mes coordonnées sont (”
+ abscisse + ” , ” + ordonnee + ” ) ” ) ;
}
public static void main(String [ ] args)
{
Point p ;
p . abscisse = 1;
p.ordonnee = 2;
p . presenteToi ( ) ;
}
}
Pas de chance, ce programme ne compile pas. Et davantage pointilleux que le C, le compilateur de Java s’arrête au moindre petit souci... Le message d’erreur à la compilation est le suivant :
Point.java:15: variable p might not have been initialized
p.abscisse = 1;
1 error
Que peut bien signifier ce charabia? Cela signifie que le compilateur a de très sérieuses raisons de penser que p contient pas d’objet. En Java, toutes les variables de type construit sont des pointeurs. Et les poin¬teurs non initialisés (avec malloc en C) sont des pointeurs ayant la valeur null. Pour faire une allocation dynamique en Java, on utilise l’instruction new. On fait alors ce que l’on appelle une instanciation. La syntaxe est donnée dans l’exemple suivant :
p = new Point ( ) ;
Cette instruction crée un objet de type Point et place son adresse dans p. Ainsi p n’est pas un objet, mais juste un pointeur vers un objet de type Point qui a étécrée par le new. Et à partir de ce moment-là, il devient possible d’accéder aux champs de p. new fonctionne donc de façon similaire à malloc et le programme suivant est valide :
public class Point
float abscisse ; float ordonnee ;
voici presenteToi()
System. out. println ( ”Je suis un point, mes coordonnees sont ( ” + abscisse + ” , ” + ordonnee + ” ) ” ) ;
1
public static voici main( String [ ] args )
Point p ;
p = new Point ( ) ; p . abscisse = 1; p.ordonnee = 2; p . presenteToi ( ) ;
Vous remarquez qu’il n’y a pas de fonction de destruction (free() en C). Un programme appeléGarbage Collector (ramasse-miette en français) est exécutédans la machine virtuelle et se charge d’éliminer les objets non référencés.
1.3.4 Les packages
Bon nombre de classes sont prédéfinies en Java, elles sont réparties dans des packages, pour utilisez une classe se trouvant dans un package, on l’importe au début du fichier source. Pour importer un package, on utilise l’instruction import.
1.3.5 Le mot-cléthis
Dans toute méthode, vous disposez d’une référence vers l’objets servant de contexte à l’exécution de la méthode, cette référence s’appelle this.
1.4 Tableaux
1.4.1 Déclaration
Un tableau en Java est un objet. Il est nécessaire de le créer par allocation dynamique avec un new en précisant ses dimensions. On note T[ ] le type tableau d’éléments de type T. La taille du tableau n’est précisée qu’àl’instanciation. On déclare un tableau t d’éléments de type T de la façon suivante :
T[ ] t ;
Par exemple, si l’on souhaite créer un tableau i d’éléments de type int, on utilise l’instruction : int [ ] i ;
1.4.2 Instanciation
Comme un tableau est un objet, il est nécessaire d’instancier pendant l’exécution. On instancie un tableau avec l’instruction
new T[ taille]
Par exemple, si l’on souhaite déclarer et allouer dynamiquement un tableau de 100 entiers, en utilise int [ ] i = new int [ 1 0 0 ] ;
1.4.3 Accès aux éléments
On accède aux éléments d’un tableau avec la notation à crochets, par exemple,
int [ ] t = new int [ 1 0 0 ] ;
for (int i = 0 ; i < 100 ; i++) {
t [ i ] = 100 − ( i + 1); Sytem . out. print ln ( t [ i ] ) ;
}
On remarque que la variable i est déclarée à l’intérieur de la boucle for, cette façon de déclarer les variables est très utile en Java. Dans l’exemple,
public class ExempleTableau
{
public static void main(String [ ] args)
{
final int T = 20;
int [ ] t = new int [T] ;
for (int i = 0 ; i < T ; i++)
t [ i ] = i ;
for (int i = 0 ; i < T ; i++)
System . out . println ( t [ i ] ) ;
}
}
Une tableau est allouédynamiquement et ses dimensions sont de taille fixée à la compilation.
1.4.4 Longueur d’un tableau
Pour connaître la taille d’un tableau on utilise l’attribut length. Par exemple,
int [ ] t = new int [T] ;
for (int i = 0 ; i < t.length ; i++) t [ i ] = i ;
for (int i = 0 ; i < t.length ; i++) System . out. println ( t [ i ] ) ;
1.4.5 Tableaux à plusieurs dimensions
On crée un tableau à plusieurs dimensions (3 par exemple) en juxtaposant plusieurs crochets. Par exemple,
int [ ] [ ] [ for (int for (int for (int
T=t[i][j][k] = 100∗ i + 10∗ i + k ; Sytem . out. println ( t [ i ] [ j ] [ k ] ) ;
}
On encore,
public class ExempleCubique
{
public static void main(String [ ] args)
{
final int T = 3;
int [ ] [ ] [ ] u = new int[T][T][T];
for (int i = 0 ; i < T ; i++)
for (int j = 0 ; j < T ; j++)
for (int k = 0 ; k < T ; k++)
{
u[i][j][k] = 100∗ i + 10∗ j + k ;
System . out . println (u [ i ] [ j ] [ k ] ) ;
}}}
1.5 Encapsulation 1.5.1 Exemple
Implémentons une file de nombre entiers. Nous avons un exemple dans le fichier suivant :
public class FilePublic {
/∗
Elements de la file ∗/
int [ ] entiers ;
/∗ ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ ∗/ /∗
Indice de la tete de file et du premier emplacement libre dans le tableau.
∗/
int first , firstFree ;
/∗ ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ ∗/ /∗
Initialise les attributs de la file. ∗/
public void init (int taille )
{
entiers = new int [ taille ] ;
first = firstFree = 0;
Decale i d ’une position vers la droite dans le tableau, revient au debut si i deborde. ∗/
public int incrementeIndice (int i )
{
i ++;
i f ( i == entiers . length )
i = 0;
return i ;
Retourne vrai si et seulement si la file est pleine.
∗/
...
Si vous travaillez en équipe, et que vous êtes l’auteur d’une classe FilePublic, vous n’aimeriez pas que vos collègues programmeurs s’en servent n’importe comment! Vous n’aimeriez pas par exemple qu’ils manipulent le tableau entiers ou l’attribut first sans passer par les méthodes, par exemple :
FilePublic f = new FilePublic ( ) ;
f . init (20);
f . entiers [ 4 ] = 3;
f . first += 5;
/* ... arretons la les horreurs ... */
Il serait appréciable que nous puissions interdire de telles instructions. C’est-à-dire forcer l’utilisateur de la classe à passer par les méthodes pour manier la file.
1.5.2 VisibilitéLa visibilitéd’un identificateur (attribut, méthode ou classe) est l’ensemble des endroits dans le code ou il est possible de l’utiliser. Si un identificateur et précédédu mot clépublic, cela signifie qu’il est visible partout. Si un identificateur et précédédu mot cléprivate, cela signifie qu’il n’est visible qu’àl’intérieur de la classe. Seule l’instance à qui cet identificateur appartient pourra l’utiliser. Par exemple :
public class FilePrivate {
private int [ ] entiers;
private int first , firstFree ;
public void init (int taille) {
entiers = new int [ taille ] ; first = firstFree = 0;
}
private int incrementeIndice (int i )
{
i ++;
i f ( i == entiers . length )
i = 0;
return i ;
}
public boolean estPlein ()
{
return first == firstFree + 1;
}
public boolean estVide ()
{
return first == incrementeIndice ( firstFree ) ;
}
public void enfile (int n)
{
i f ( ! estPlein ())
{
entiers [ f i r s t F r e e ] = n ;
firstFree = incrementeIndice ( firstFree ) ;
}}
public void defile ()
{
i f ( ! estVide ())
first = incrementeIndice(first ) ;
}
public int premier()
{
i f ( ! estVide ())
return entiers [ first ] ;
return 0;
}}
On teste cette classe de la même façon :
public class TestFilePrivate
{
public static void main(String [ ] args)
{
FilePrivate f = new FilePrivate ( ) ;
f . init (20);
for (int i = 0 ; i < 30 ; i+=2)
{
f . enfile ( i ) ;
f . enfile ( i +1);
System . out . println ( f . premier ( ) ) ;
f . defile ( ) ;
}
while ( ! f . estVide () )
{
System . out. println ( f . premier ( ) ) ;
f . d e f i l e ( ) ;
}
}}
S’il vous vient l’idée saugrenue d’exécuter les instructions :
FilePrivate f = new FilePrivate ( ) ;
f . init (20);
f . entiers [ 4 ] = 3;
f . first += 5;
/* ... arretons la les horreurs ... */
vous ne passerez pas la compilation. Comme les champs entiers et first sont private, il est impossible de les utiliser avec la notation pointée. Cela signifie qu’ils ne sont accessibles que depuis l’instance de la classe FilePrivate qui sert de contexte à leur exécution. De cette façon vous êtes certain que votre classe fonctionnera correctement. En déclarant des champs privés, vous avez cachéles divers détails de l’implémentation, cela s’appelle l’encapsulation. Celle-ci a pour but de faciliter le travail de tout programmeur qui utilisera cette classe en masquant la complexitéde votre code. Les informations à communiquer à l’utilisateur de la classe sont la liste des méthodes publiques. A savoir public class FilePrivate
{
public void init (int taille){/* ... */} public boolean estPlein (){ /* ... */} public boolean estVide(){/* ... */} public void enfile (int n){/* ... */} public void d e f i l e (){ /* ... */} public int premier () { /* ... */}
}
On remarque non seulement qu’il plus aiséde comprendre comment utiliser la file en regardant ces quelques méthodes mais surtout que la façon dont a étéimplémentéla file est totalement masquée.
1.5.3 Constructeur
Supposons que notre utilisateur oublie d’invoquer la méthode init(int taille), que va-t-il se passer? Votre classe va planter. Comment faire pour être certain que toutes les variables seront initialisées ? Un constructeur est un sous-programme appeléautomatiquement à la création de tout objet. Il porte le même nom que la classe et n’a pas de valeur de retour. De plus, il est possible de lui passer des paramètres au moment de l’instanciation. Remplaçons init par un constructeur:
public class FileConstructeur {
private int [ ] entiers;
private int first , firstFree ;
FileConstructeur(int taille)
{
entiers = new int [ taille ] ;
first = firstFree = 0;
}
private int incrementeIndice (int i )
{
i ++;
i f ( i == entiers . length )
i = 0;
return i ;
}
public boolean estPlein ()
{
return first == firstFree + 1;
}
public boolean estVide ()
{
return first == incrementeIndice ( firstFree ) ;
}
public void enfile (int n)
{
i f ( ! estPlein ())
{
entiers [ f i r s t F r e e ] = n ;
firstFree = incrementeIndice ( firstFree ) ;
}
}
public void defile ()
{
i f ( ! estVide ())
first = incrementeIndice(first ) ;
}
public int premier()
{
i f ( ! estVide ())
return entiers [ first ] ;
return 0;
}}
On peut alors l’utiliser sans la méthode init,
public class TestFileConstructeur
{
public static void main(String [ ] args)
{
FileConstructeur f = new FileConstructeur (20);
for (int i = 0 ; i < 30 ; i+=2)
{
f . enfile( i ) ;
f . enfile ( i +1);
System . out. println ( f . premier ( ) ) ;
f . defile ( ) ;
}
while ( ! f . estVide () )
{
System . out. println ( f . premier ( ) ) ; f . defile ( ) ;
}}}
1.5.4 Accesseurs
Il est de bonne programmation de déclarer tous les attributs en privé, et de permettre leur accès en forçant l’utilisateur à passer par des méthodes. Si un attribut X est privé, on crée deux méthodes getX et setX permettant de manier X. Par exemple,
public class ExempleAccesseurs {
private int foo;
public int getFoo ()
{
return foo;
}
public void setFoo (int value)
{
foo = value;
}
}
On ainsi la possibilitéde manier des attributs privés indirectement.
1.5.5 Surcharge
Il est possible de definir dans une même classe plusieurs fonctions portant le même nom. Par exemple,
public class FileSurcharge {
private int [ ] entiers;
private int first , f i r s t F r e e ;
FileSurcharge(int taille)
{
entiers = new int [ taille ] ;
first = firstFree = 0;
}
FileSurcharge ( FileSurcharge other )
{
this(other. entiers . length ) ;
for ( int i = 0 ; i < other . entiers . length ; i++)
entiers [ i ] = other . entiers [ i ] ;
first = other. first ;
firstFree = other. firstFree;
}
private int incrementeIndice (int i ) {
i ++;
i f ( i == entiers . length )
i = 0; return i ;
}
public boolean estPlein ()
{
return first == firstFree + 1;
}
public boolean estVide ()
{
return first == incrementeIndice ( firstFree ) ;
}
public void enfile (int n)
{
i f ( ! estPlein ())
{
entiers [ f i r s t F r e e ] = n ;
firstFree = incrementeIndice ( firstFree ) ;
}
}
public void defile ()
{
i f ( ! estVide ())
first = incrementeIndice(first ) ;
}
public int premier()
{
i f ( ! estVide ())
return entiers [ first ] ;
return 0;
}
}
On remarque qu’il y a deux constructeurs. L’un prend la taille du tableau en paramètre et l’autre est un constructeur de copie. Selon le type de paramètre passéau moment de l’instanciation, le constructeur correspondant est exécuté. Dans l’exemple ci-dessous, on crée une file g en applicant le constructeur de copie à la file f.
public class TestFileSurcharge
{
public static void main(String [ ] args)
{
FileSurcharge f = new FileSurcharge (20);
for (int i = 0 ; i < 30 ; i+=2)
{
f . enfile( i ) ;
f . enfile ( i +1);
System . out. println ( f . premier ( ) ) ;
f . defile ( ) ;
}
FileSurcharge g = new FileSurcharge ( f ) ;
while ( ! f . estVide () ) {
System . out. println ( f . premier ( ) ) ;
f . defile ( ) ;
}
while ( ! g . estVide () )
{
System . out . println (g . premier ( ) ) ;
g . defile ( ) ;
}
1.6 Héritage
1.6.1 Héritage Le principe
Quand on dispose d’une classe c, on a la possibilitéde l’agrandir (ou de l’étendre) en créant une deuxième classe c'. On dit dans ce cas que c' hérite de c, ou encore que c est la classe mère et c' la classe fille. Par exemple, considérons les deux classes suivantes :
public class ClasseMere {
private final int x ;
public ClasseMere (int x)
{
this.x = x ;
}
public int getX ( ) {
return x ;
}
}
public class ClasseFille extends ClasseMere {
private final int y ;
public ClasseFille (int x , int y)
{
super(x);
this.y = y ;
}
public int getY ( )
{
return y ;
}
}
Le mot-cléextends signifie hérite de. Le mot-clésuper est le constructeur de la classe mère. Tout ce qui peut être fait avec la classe mère peut aussi être fait avec la classe fille. Notez donc que la classe fille est une extension de la classe mère. On peut par exemple utiliser la classe fille de la façon suivante :
public class Test ClasseFille
{
public static void main(String [ ] args)
{
ClasseFille o = new ClasseFille (1 , 2);
System . out. println (” (” + o.getX() + ” , ” +
o.getY() + ”)” ) ;
}
}
Notes bien que comme la classe mère possède une méthode getX, la classe fille la possède aussi. Et l’attribut x de tout instance de la classe mère est aussi un attribut de toute instance de la classe fille.
Héritage simple Vs. héritage multiple
En java, une classe ne peut avoir qu’une seule classe mère. Dans d’autres langages (comme le C++) cela est permis, mais pour des raisons de fiabilité, Java l’interdit.
Object
En java, toutes les classes héritent implicitement d’une classe Object.
1.6.2 Polymorphisme
Considérons l’exemple suivant :
public class TestClasseFillePolymorphisme
{
public static void main(String [ ] args)
{
ClasseMere o = new ClasseFille (1 , 2);
System . out. println (” (” + o.getX() + ” , ” +
(( ClasseFille )o ) . getY () + ” ) ” ) ;
}
}
On remarque d’une part que o référence un objet de la classe fille de son type. Cela s’appelle le polymor¬phisme. D’autre part, si l’on souhaite effectuer des opérations spécifiques aux objets de la classe fille, il est nécessaire d’effectuer un cast.
1.6.3 Redéfinition de méthodes
La méthode toString() appartient initialement à la classe Object. Elle est donc héritée par toutes les classes. Vous avez la possibilitéde la redéfinir, c’est à dire de remplacer la méthode par défaut par une méthode davantage adaptée à la classe en question.
1.6.4 Interfaces
Une interface est un ensemble de constantes et de méthodes vides. Il est impossible d’instancier une interface. Il est nécessaire que la classe qui hérite de l’interface (mot-cléimplements) définisse les méthodes qu’elle contient. En voici un exemple d’utilisation :
interface Presentable
{
public void presenteToi ( ) ;
}
public class ExempleInterface implements Presentable {
public int x , y ;
public void presenteToi ()
{
System. out. println (”Je s