Programmation Java

Caractéristiques de Java
 Java est un langage de programmation moderne développé
par Sun Microsystems (aujourd'hui racheté par Oracle)
 Java est un langage de programmation orientée objets
 Java fonctionne comme une machine virtuelle (indépendant
de toute plate forme)
 Java est simple (pas de pointeur, pas d’héritage multiple)
 Java est gratuit
 Java contient une très riche bibliothèque de classes
(Packages) qui permettent de:
 Créer des interfaces graphiques
 Utiliser les données multimédia
 Communiquer à travers les réseaux
Environnement de Java
1. Java Developer’s Kit (JDK)
 Le compilateur (javac)
 L’interpréteur (java), ou bien Un JRE (Java Runtime
Environment)
 L’appletviewer (inspecteur d’applet)

Le JDK contient par ailleurs l’API de java (Application

Programmes Interface)
Le Kit JDK ne contient pas d’éditeur
2. Le code source
 Une application java est généralement composée de plusieurs fichiers
sources. Les fichiers sources de java ont l’extension .java
 Une seule classe publique par fichier;
 Le nom du fichier doit être le même que celui de la classe qui contient
main();

3. La compilation
La compilation va transformer le code source en j-code ou byte-code java
Javac nom_fich.java
 Création d’un fichier nom_fich.class
4. La machine virtulle Java (JVM)
 Le code java comprend des instructions écrites pour JVM
 Un programme java est exécuté sur tout ordinateur (tout OS) pour
lequel une machine virtuelle est disponible
 Une application sera exécutée par l’interpréteur de java
Java nom_fich.java
JVM va faire le lien entre le byte code et la machine.
Convention d’écriture en Java
Type Convention Exemple
Nom d’une classe Débute par une majuscule Class Voiture
Nom d’une variable Débute par une minuscule premierObjet
Nom de méthode Débute par une minuscule Void demarre()
sauf pour le constructeur
Constante S’écrit en majuscule CONST
Nom de fichier Ne contient pas de blanc et Nom_fich
source ne commence jamais par
des chiffres

 Toutes ces déclarations sans accent ! !

 Les programmes Java sont des classes qui représentent
des objets de la vie réelle
 Pour exécuter une classe Java comme un programme,
cette classe doit posséder une méthode nommée main().
Ce qu'il faut retenir
 La JVM est le cœur de java,
 JVM fait fonctionner vos programmes java,
précompilés en code binaire (byte code)
 Les fichiers contenant le code source de vos
programmes java ont l'extension .Java
 Les fichiers précompilés correspondant à vos codes
sources java ont l'extension .Class
 Le byte code est un code intermédiaire entre votre
programme et votre machine
 Un programme java, codé sous windows peut être
précompilé sous mac et enfin exécuté sous linux,
 Votre machine NE PEUT PAS interpréter du byte
code.
Système - l’onglet Avancé bouton Variables d’environnement
Les trois étapes principales de la
programmation en Java

 Ecrire le programme en Java et l’enregistrer

sur un disque sous l’extension .java
 Compiler le programme pour le traduire en
un code binaire spécial compréhensible par
Java: javac.
 Exécuter le programme.
Premier programme Java sous
Windows
public class BonjourMonde {
public static void main(String[] args) {
System.out.println("Bonjour Monde");
}
}

Compilatio
Code_source.java n code_binaire.class

Java fait la différence entre les lettres minuscules et majuscules.

Programmer avec Eclipse
Eclipse IDE est un environnement de développement intégré
(Integrated Development Environment). On peut y écrire, compiler et
exécuter les programmes. Donc permet de créer des projets de
développement

Jbuilder (payant), NetBeans, JCreator

Un JRE (ou Java Runtime Environment) sert à lire les programmes
qui ont été codés en Java. Eclipse est codé en Java : donc, pour
utiliser Eclipse, il vous faut un JRE.
Création de programmes dans
Eclipse

NomClasse

Méthode
principale

Main() Le point d’entrée d’une application (programme)

Java
 Toutes les méthodes commencent par une ligne de
déclaration appelée signature de la méthode :
public static void main(String[] args)
 Le mot-clé public signifie que la méthode main() peut être
utilisée par n’importe quelle autre classe Java ou par Java lui-
même.
 Le mot-clé static signifie qu’il n’est pas nécessaire de créer
une instance (une copie) de l’objet BonjourMonde en
mémoire pour pouvoir utiliser cette méthode.
 La liste des arguments : String[] args signifie que la méthode
peut recevoir un tableau (array) de chaînes de caractères
(String) qui représentent du texte. Les valeurs qui sont
passées à la méthode sont appelées arguments.
La programmation orientée objet
?
C’est la représentation du monde réel
C’est la capacité de regrouper des
paramètres dans un ensemble.
Un ensemble de principe clés qui
permettent la mise en place d’un logiciel.
Les objets
 Un objet peut être vu comme un ensemble de données et
des fonctions qui lui sont associées.
 Ces fonctions sont appelées méthodes.
 Un objet est "responsable" de ses données, il peut les
protéger.
 Dans ce cas, un autre objet n'accède pas directement à
ces données, il le fait via les méthodes, on parle alors
d'encapsulation.
Les classes
Une classe est un moule d'objet (un
modèle), elle décrit les attributs et les
méthodes de toute une famille d'objets.
Une classe définit en particulier un type
d'objet. Les objets d'une même classe
auront des attributs de même type, mais
avec des valeurs différentes.
Une classe est la description générale
d'une famille d'objet et un objet est une
instance de classe.
Exemple

Manger
Fille Boire
Parler
Un prénom Dormir
Un nom
Rougir
Une date de naissance
Une adresse
Un lieu de naissance

Ce sont les propriétés

Elle a des attributs et des méthodes

Qu’est qu’une classe ?

Manger
Fille Boire
Parler
Un prénom Dormir
Un nom
Rougir
Une date de naissance
Une adresse
Un lieu de naissance

Ce sont les actions qu’elle peut réaliser

Elle a des attributs et des méthodes

Déclaration d’une classe
public class Fille {

private int id ;
private String nom;
private String prenom; On les appelle variables
private String dateNaissance; d’instance.
private String lieudeNaissance;

public static int nbFille =0 ;

}

Elles sont communes à toutes les instances.

Elles sont accessibles uniquement par le biais d’un objet.
Déclaration d’une classe
public class Fille {

private int id ;
private String nom;
private String prenom; Les variables de la classe
private String dateNaissance;
private String lieudeNaissance;

public static int nbFille =0 ;

}
Il faudra utiliser le mot clé static pour déclarer une
variable de classe.
Une variable de classe est une variable qui est commune à
toutes les instances de cette classe. Une variable de ce type
peut être accessible sans avoir à passer par une instance
de la classe.
Résumé: Un objet est un élément (ou instance) d'une classe. L'objet est
le composant effectif des programmes (c'est lui qui calcule) alors que la
classe est plutôt une définition ou une spécification pour l'ensemble des
instances à venir.
Déclaration d’un objet
 Pour utiliser une classe, elle doit être instanciée. Il y aura
alors création d’un objet. Mais avant de créer un objet il
faut le déclarer:

NomClasse nomObjet ;
Fille salma ;
 On vient de déclarer un objet de type Fille qui s’appelle
salma. Il va falloir construire l’objet.

nomObjet = new NomClasse();

salma = new Fille();
new permet de construire l’objet.
 On peut créer et déclarer un objet en une seule étape:
NomClasse nomObjet = new NomClasse();
Les constructeurs
 Un constructeur a pour objectif d’initialiser les attributs de la
classe.
 Un constructeur a plusieurs caractéristiques:

o Il porte le même nom que sa classe.

o Il ne retourne pas de valeur, et ne mentionne pas void au début de sa
déclaration.
o Toute classe possède au moins un constructeur. Si une classe ne
déclare pas de constructeur, un constructeur vide est crée
automatiquement par défaut.
 Un constructeur est une fonction qui est appelée par le bais de
l’opérateur new
monObjet = new Constructeur (arguments);
 Si un constructeur est défini dans une classe, il faudra
obligatoirement l’utiliser.
La variable this
La variable this sert a référencier dans une méthode l’objet en cours
d’utilisation. Son emploi peut s’avérer utile dans les constructeurs avec des
paramètres lorsque les variables de la classe et celles du constructeur portent
le même nom.
class Incremente {
int increment;
int petitPlus;
Incremente (int increment, int petit) {
this. increment = increment ;
/* variable de la classe = variable du constructeur*/
petitPlus = petit; }
int additionne (int n) {
return (n + increment + petitPlus) }
class Constructeur {
public static void main (String[] arg) {
Incremente monAjout = new Incremente(10,1);
System.out.println(monAjout.additionne(4)); }
}
Les méthodes
Les méthodes
 Les arguments : ce sont les arguments que l’on souhaite
passer à la méthode. Elles sont obligatoirement séparés par
une virgule.
 Lenom de la méthode : C’est le nom que l’on attribue à la
méthode.
 Pour l’appeler, il faudra utiliser ce nom.
 La valeur de retour : Chaque méthode peut retourner une
valeur. Il faudra la spécifier dans le corps de la méthode.
◦ Si le type est void, il ne retournera rien.
◦ Par contre, si on spécifie un type de retour, il faudra
obligatoirement retourner une valeur. Dans le cas contraire,
une erreur de compilation sera générée.
L’encapsulation
 C’est un mécanisme fondamental de la Programmation
Orientée objet.
 L’encapsulation consiste à protéger les informations
contenues dans un objet.
 Un utilisateur peut manipuler les données à l’aide des
méthodes.
 Il existe 3 niveaux d’accès.

 Public

 Privé (Private)
 Protégé (Protected)
L’encapsulation
Public
Accessible par tout le monde (toutes les méthodes)
Privé

Uniquement manipulable par l’objet lui-même.

(utilisée que par les méthodes de la même classe)

Protégé

manipulable par l’objet lui-même

Et les enfants (les sous classes).
L’encapsulation
 Par défaut, si on n’indique aucun modificateur, la classe,
la méthode ou la variable est visible par toutes les
classes se trouvant dans le même packetage.

Final

Une variable constante

Une méthode qui ne peut pas être redéfinie

Techniques de base de la
programmation java
1. Commentaires en java
En java, il existe deux types de commentaires:
// commentaire simple sur une ligne (uniligne)
/* */ commentaire de plusieurs lignes (multiligne)
2. Types élémentaires en java
Java dispose de 8 types élémentaires suivants. Ces types sont appelés
primitives en java:
boolean Destiné à une valeur logique (true, false)
byte Octet signé 8 bits (-128 et 127)
short Entier court signé 16 bits (-32768 – 32767)
char Caractère 16 bits
int Entier signé 32 bits
float Virgule flottante 32 bits
double Double précision 64 bits
long Entier long 64 bits
Java dispose également des classes suivantes pour gérer ces primitives
Classe Primitive
Character char
Byte byte
Short short
Integer int
Long long
Float float
Double double
Boolean boolean
3. Déclaration et utilisation de variables
La déclaration est l’attribution d’un identificateur à une entité en cours
de création.
a. Déclaration des variables
Pour déclarer une variable on écrit:
[modificateur] primitive identificateur
Par exemple: public int nombreEntier;
b. Identificateur
A chaque objet, classe, programme ou variable est associé un
identificateur. En java, ces identificateurs doivent respecter les
règles suivantes:
 Les majuscules et les minuscules sont distinguées
 Le premier caractère ne doit pas être un chiffre
 L’identificateur ne doit pas être un mot clé de java
c. Mots clé de java
abstract boolean break byte case
catch char class continue default
do double else extends false
final finally float for if
implements import instanceof int interface
long native new null package
private protected public return short
static super switch synchronized this
throw throws transient true try
Void volatile while
4. Déclaration et utilisation de variables
* multiplication
/ division
% modulo
+ addition
- soustraction
= affectation
== identité
!= différent de
&& et logique
|| ou logique
>> Décalage binaire à droite
<< Décalage binaire à gauche
& et binaire
| ou binaire
5. Les tableaux
a. Déclaration d’un tableau
Les tableaux doivent être déclarés comme tous les objets. Java
dispose de deux syntaxes équivalentes pour la déclaration des
tableaux.

primitive[ ] tableau;
ou
primitive tableau[ ];
Exemple: int[] tab1; ou int tab2[];
b. Définition d’un tableau
La définition d’un tableau est l’opération dont le résultat est la
création d’un objet tableau.
Les tableaux Java sont de taille fixe. La définition devra indiquer la
taille du tableau. La syntaxe à employer est la suivante:
tableau= new primitive[dimension];
Dimension est le nombre d’éléments que le tableau pourra contenir
Comme les autres objets, les tableaux peuvent être déclarés et définis sur la
même ligne:
int[] tab2 = new int[5];

Exemple:
class TableauA {
public static void main(String[] argv) {
char[] tableau;
tableau = new char[2];
tableau[0]=‘h’;
tableau[1] = ‘a’;
System.out.println(tableau); // println utilisée avec tableau de caractères
} }
A l’exécution on aura: ha
Autre façon de définir un tableau
On peut définir un tableau avec un tableau littéral au moment de sa
déclaration.
Exemple: boolean tableau[] = {true,false,true};
c. Longueur d’un tableau
Peut être trouvée par l’attribut length.
tab.length est la longueur du tableau tab.

class TableauB {
public static void main(String[] argv) {
int tableau[] = new int[3];
System.out.println("Taille du tableau: "+ tableau.length);
for(int i=0; i< tableau.length ; i++)
{ tableau[i] = i;
System.out.println(tableau[i]);
}
} }
Dépassement des bornes d’un tableau
Le dépassement est une erreur non pas de compilation mais
d’exécution.
Exemple: for(int i=0; i<= tableau.length ; i++)
On utilise les mots réservés catch et try pour intercepter l’exception.
d.Tableau multidimensionnel
Les tableau de java peuvent comporter plusieurs dimensions.
Pour déclarer un tableau multidimensionnel, in utilise la syntaxe
suivante:
Primitive[ ][ ] [ ] tableau;
Exemple: int[ ][ ] tableau;

La définition du tableau peut être effectuée à l’aide de:

 Tableaux littéraux: int[][] tableau= {{1,2,3,4},{5,6,7,8}};

ou
 L’opérateur new: int[][] tab= new int[2][4];

Pour accéder à tous les éléments du tableau, on doit utiliser des

boucles imbriquées:
Exemple: int[][] tab= new int[2][4];
for(int i= 0; i< tab.length; i++) {
for (int j= 0; j< tab[i].length; j++) }
tab[i][j]= i+j; } }
6. Lire les entrées clavier
Pour lire au clavier on peut utiliser la classe Scanner. On doit
l’instancier pour pouvoir l’utiliser.
Scanner sc = new Scanner(System.in);
L’objet sc peut prendre différents paramètres.
System.in correspond à l'entrée standard en Java.
Il faut importer la classe Scanner, grâce à l'instruction import. Cette
classe se trouve dans le package java.util.
Ajouter au dessus de la déclaration de la classe:
import java.util.Scanner;
a. Récupération des entrées
Scanner sc = new Scanner(System.in);
System.out.println("Veuillez saisir un mot :");
String str = sc.nextLine();
System.out.println("Vous avez saisi : " + str);

La méthode nextLine() récupère le contenu de toute la ligne saisie et

repositionne la "tête de lecture" au début d'une autre ligne. (Utiliser
pour renvoyer une chaîne de caractères)
Pour lire un int, on doit utiliser la méyhode nextInt().
De façon générale, pour récupérer un type de variable, il vous suffit
d'appeler nextType de variable commençant par une majuscule .
Exemple:
Scanner sc = new Scanner(System.in);
int i = sc.nextInt();
double d = sc.nextDouble();
long l = sc.nextLong();
byte b = sc.nextByte();
Le type primitive char n'est pas pris en compte par la classe Scanner.
On pourrait récupérer un caractère comme suit:
System.out.println("Saisissez une lettre :");
Scanner sc = new Scanner(System.in);
String str = sc.nextLine();
char carac = str.charAt(0);
System.out.println("Vous avez saisi le caractère : " + carac);
Récupérer une chaîne de caractères,
utiliser une méthode de l'objet String (ici, charAt(0) )
récupérer le premier caractère saisi !
8. Les structures de contrôle
a. Les instructions conditionnelles
L’instruction if
If (expression)
InstructionSiVrai;
Else
InstructionSiFaux;

L’opérateur ?
Condition ? siVrai : siFaux ;
Exemple: int a=2, b=5;
int min=a<b ? a : b;
L’instruction switch
Switch (variable) {
case cas1: instruc11;
instruc12;
…
break;
case cas2: instruc21;
instruc22;
…
break;
…
default : instrDefault;
}
b.Les instructions de répétition
L’instruction while
while (condition)
Instruction;
L’instruction do … while
do
instructions;
while (condition)
L’instruction for

for(initialisation ; test ; incrémentation)

La boucle for en java autorise plusieurs expressions séparées par une
virgule à apparaitre dans la partie initialisation et incrémentation
mais pas dans la partie test.
Exemple:
class SubChar
{
public static void main(String[] argv) {
int i;
String s;
for(i=0,s=‘’testing’’;(i<10)&&(s.length()>1);i++,s=s.substring(1))
System.out.println(s);
}
}

Syntaxe: String substring(int debut, int fin)

9. Les attributs et méthodes statiques
Ce sont les attributs ou méthodes qui ont le modificateur static

Un attribut (une méthode) statique (ou de classe) appartient à une

classe et non a ses instances.

Un attribut statique existe dès que sa classe est chargée en mémoire

alors qu’un attribut d’instance existe lors de l’instanciation de la
classe.

Une méthode statique ne peut pas être redéfinie. Elle est

automatiquement finale.

Pour utiliser un attribut ou une méthode statique on écrit:

NomClasse.nomAttributStatique
NomClasse.nomMethodeStatique(arguments)
Cependant Java permet également d’utiliser:
nomObjet.nomAttributStatique
nomObjet.nomMethodeStatique(arguments)

nomObjet étant une instanciation de la classe qui contient l’attribut

ou la méthode statique.

On peut accéder à un membre statique par l’intermédiaire de la

classe ou d’une instance.

Si on modifie la valeur d’une variable statique, elle est modifiée

pour tous les instances, mêmes celles créées avant la modification.
Cela est impliqué par le fait que la variable n’existe qu’à un seul
exemplaire, partagé par la classe et toutes les instances.
9. La surcharge
Si plusieurs méthodes possèdent le même nom mais
différent par l'ensemble des types de ses paramètres, ou
par l'ordre des types de ses paramètres, on dit qu'il y a
surcharge.

Lorsque une méthode surchargée est invoquée, la bonne

méthode est choisi pour qu’il y ait correspondance sur
les paramètres de l’appel et les arguments de la méthode.
Une méthode statique ne peut pas être redéfinie. Elle est
automatiquement finale.
Exemple
class Surcharge {
int n ;
double x ;
Surcharge()
{
n = 1;
x = 3.5;
}
Surcharge(int n, double x) {
this.n = n;
this.x = x;
}
int operation(int p) {
return 10 * p + n;
}
double operation(double y, int p) {
return x * p + y;
}
double operation(int p, double y) {
return (double) n/p + y;
}
}
class EssaiSurcharge {
public static void main(String[] argv) {
Surcharge surcharge;
surcharge = new Surcharge();
System.out.println(surcharge.operation(2));
System.out.println(surcharge.operation(1.5, 4));
System.out.println(surcharge.operation(4, 1.5)); surcharge =
new Surcharge(7, 2.0);
System.out.println(surcharge.operation(2));
}
}

Remarque: si on ajoute l’instruction:

System.out.println(surcharge.operation(4, 5)); il y aura erreur de
Compilation car ambiguïté de référence par contre s’il y avait pas de
Surcharge, cette instruction ne générera pas d’erreur
Classe et héritage
1. Définition de l’héritage
L’héritage est l’un des aspects les plus utiles de la programmation
orientée objet. Il permet à une classe de transmettre ses attributs et
ses méthodes à des sous classes. Ainsi, si une classe B hérite d’une
classe A, alors la classe B contient implicitement l’ensemble des
attributs non privés de A et peut invoquer toutes les méthodes non
privées de la classe A
2. Déclaration de l’héritage
En java, pour déclarer l’héritage, on utilise le mot clé extends
Syntaxe:
Class B extends A
B hérite de A
B est dérivée (enfant) de A
B une sous classe de A
A est la super classe de B
3. Propriétés de l’héritage
Une classe dérivée peut accéder uniquement au donnée publique et
protégée de la super classe..
Tout objet de la classe dérivée est aussi un objet de la super classe
Si une classe n’hérite d’aucune autre classe, elle hérite par défaut de la
super classe Object définie dans le package java.lang
Si la déclaration d’une classe est précédée de final, alors cette classe
ne peut pas être une classe dérivée.
Une classe ne peut hériter que d’une seule autre classe (héritage
simple)
4. Référence à la super classe
Pour faire référence à la classe parente (super classe), il suffit
d’utiliser le mot clé super. Ce mot permet d’invoquer un attribut ou
une méthode de la super classe.
On utilise super(arguments) pour invoquer le constructeur de la
super classe ayant les arguments correspondants.
5. Exemples
Soit la hiérarchie suivante:

Animal

Chien Chat Canard

BergerAllemand Labrador Caniche

Les classes BergerAllemand, Labrador et Caniche sont dérivé de la

classe Chien qui est elle dérivée de la classe Animal
La classe Animal est elle-même dérivée de la classe Object, ou d’une
autre classe descendant de la classe Object.
Il s’agit de la relation « est un »
class Animal {
boolean vivant;
int age;
Animal (int a) /* Constructeur */ {
age = a;
vivant = true;
System.out.println(‘’ Un animal de ‘’ + a+ ‘’an(s) vient d’être créé’’);
}
void vieillit() {
++age;
System.out.println(‘’C’est l’anniversaire de cet animal’’);
System.out.println(‘’ Il a maintenant’’ + age+ ‘’an(s).’’);
}
void meurt() {
vivant = false;
System.out.println(‘’Cet animal est mort’’);
}
void parler()
{
}
}
Au titre de l’héritage, les classes Canard et Chien disposent de tous
les membres de la classe Animal, et donc en particulier, de ses
variables d’instances et de ses méthodes
class Canard extends Animal {
Canard (int a) {
super (a);
}
void parler() // redéfinition de la méthode parler()
{ System.out.println(‘’ Le canard crie Cui-cui!’’); }
}
class Chien extends Animal {
Chien (int a) // Constructeur
{ super(a);
}
void parler() // redéfinition de la méthode parler()
{ System.out.println(‘’ Le chien crie Hab Hab!’’);
}
}
La classe Caniche hérite de la classe chien donc dispose de tous les
membres de la classe Chien et par transitivité dispose aussi de tous
les membres de la classe Animal
class Caniche extends Chien {
Caniche (int a) // Constructeur
{ super(a); } }
Class Animaux {
public static void main (String[] args) {
System.out.println(‘’Utilisation d’un objet Canard);
Canard titi= new Canard(3);
titi.vieillit();
titi. parler();
System.out.println(‘’Utilisation d’un objet Chien);
Chien bobi= new Chien(2);
bobi.vieillit();
bobi. parler();
System.out.println(‘’Utilisation d’un objet Caniche);
Caniche teddy= new Caniche(1);
teddy.vieillit();
teddy. parler() ;
} }
A l’exécution, on aura:
Utilisation d’un objet Canard
Un animal de 3 an(s) vient d’être créé
C’est l’anniversaire de cet animal
Il a maintenant 4 an(s).
Le canard crie Cui-cui!
Utilisation d’un objet Chien
Un animal de 2 an(s) vient d’être créé
Exemple 2
La classe Logement possède les caractériqtiques :
public class Logement {
final public double surface ; public double prix ;
public String proprietaire ; private boolean vendu ;
Logement (double surface , double prix ) {
this . surface = surface ;
this . prix = prix ;} }
public class Appartement extends Logement {
final public int etage ;
private boolean cave ;
public Appartement (double surface , double prix , int etage , boolean
cave ) {
super (surfac e, prix) ;/*appel du constructeur Logement (double
,double) de la classe Logement */ {
this . etage = etage ;
this . cave = cave ;} }
Les attributs de la classe Appartement sont : surface, prix,
proprietaire, vendu, etage et cave.

L'appel d'un constructeur de la classe mère doit être la première

instruction du constructeur de la classe fille.

Une classe héritant d'une classe A ne peut pas directement

accéder aux attributs privés de la classe A. Donc, l'utilisation d'un
constructeur de la classe mère est le seul moyen de les initialiser.

Un constructeur d'une classe dérivée commence toujours :

1. soit par l'appel explicite d'un autre constructeur de la classe.
2. soit par l'appel explicite ou implicite d'un constructeur de la
classe mère.
6. Masquage des attributs et redéfinition
(polymorphisme) des méthodes
On dit qu’un attribut d’une classe masque un attribut d’une super
classe s’il a le même nom qu’un attribut de la super classe.
On dit qu’une classe redéfinit une méthode d’une super classe si elle
définie une méthode ayant même nom, même suite de type
d’arguments et même valeur de retour qu’une méthode de la super
classe.
Une sous-classe peut redéfinir (redéfinition) les méthodes à ceux dont
elle hérite et fournir des implémentations spécifiques pour celles-ci.

Ne pas confondre surcharge et redéfinition.

Dans le cas de la surcharge la sous-classe ajoute des méthodes tandis
que la redéfinition « spécialise » des méthodes existantes
7. Classe abstraite
Une classe abstraite est une classe dont l’implémentation n’est pas complète. Elle
doit être déclarée avec le modificateur abstract.
Elle sert à définir une super classe impossible à instancier. Donc elle va servir de
modèle pour les classes enfants.
La classe abstraite va définir des méthodes en fournissant leur signature: le type
de retour, le nom et le type d’argument

C’est une assurance pour la classe de base que les classes enfants respecteront bien
les spécifications définies (contrats de services).

Exemple: Prenons la classe Humain, à partir de laquelle dérivent la classe Homme

et la classe Femme. En toute logique, Homme et Femme sont instanciables (les
objets créés ont une existence en soi), mais la classe Humain sera déclarée
abstraite car un objet Humain n'existe pas en tant que tel, puisqu'il manque
l'information sur le sexe. Ici, la classe Humain servira à implémenter des
méthodes qui seront utilisées à la fois pour Homme et pour Femme.
Une classe abstraite est dite abstraite si et seulement si elle
détient une ou plusieurs méthodes abstraites.

Il n’est pas possible d’instancier une classe abstraite, il faut

l’étendre pour pouvoir l’utiliser.

Par exemple, un animal domestique.

On sait qu’il aura obligatoirement une méthode parler.

Tous les animaux domestiques parlent mais chacune a sa
manière.

Les oiseaux vont dire : Cik Cik Cik

Le chat va dire : Miaou Miaou
Le chien va dire : Hab Hab Hab
Si l’on définie une classe abstraite AnimalDomestique,
on va y placer la méthode abstraite « parler » .
Ainsi chaque classe enfant va implémenter la méthode
parler à sa manière.

Ainsi, la classe Chien va dire : Hab Hab Hab

Ainsi, la classe Chat va dire : Miaou Miaou

abstract class AnimalDomestique {
abstract void parler(); }
class Chien extends AnimalDomestique {
void parler() {
System.out.println(" Hab Hab Hab "); } //... }
class Chat extends AnimalDomestique {
void parler() {
System.out.println("Miaou Miaou"); } // ... }
public class Poly {
static AnimalDomestique tab[] = new AnimalDomestique[2];
public static void main(String args[]) {
tab[0] = new Chien(); /*On a instancié un objet Chien qu’on a mis dans un
objet de type AnimalDomestique*/

tab[1] = new Chat();

for( int i=0; i<2; i++)
tab[i].parler(); } }
8. Les interfaces
a. Définition d’une interface
Une interface est un modèle pour une classe
Une interface est une sorte de classe qui ne contient que des prototypes de méthodes et des
constantes ayant les modificateurs static et final.
Une interface est un peu comme une classe abstraite dans laquelle aucune méthode ne serait
implémentée : les méthodes y sont seulement déclarées. Cela permet de définir un
ensemble de services visibles depuis l’extérieur (l’API : Application Programming
Interface), sans se préoccuper de la façon dont ces services seront réellement
implémentés.

b. Présentation d’une interface

Une interface se compose de deux parties:
L’en-tête
Le corps

En-tête d’une interface

[modificateur] interface <Nom> [extends <interface>]

[ ]: optionnel
<>: obligatoire
gras: mot clé
Remarque
Une interface peut avoir le modificateur public.
Une interface est toujours abstraite sans qu’il soit nécessaire de l’indiquer.
Elle peut être attribuée à un package. Si elle ne l’est pas , elle fera partie du
package par défaut.
Une interface peut dériver de plusieurs autres interfaces (héritage multiple pour
les interfaces et non pas pour les classes).
Une interface est un contrat, à savoir un ensemble de propriétés et méthodes que
la classe DOIT implémenter.

interface I1
{ }
abstract interface I2 //abstract n’est pas nécessaire
{ }
public interface I3 extends I1, I2 // héritage multiple
{ }
Classe abstraite ou interface ?
Classes abstraites et interfaces ont chacune une fonction bien
distincte : les classes abstraites servent à factoriser du code, tandis
que les interfaces servent à définir des contrats de service.

Et pourquoi ne pas utiliser des classes abstraites (dans lesquelles

aucune méthode ne serait implémentée) en lieu et place des
interfaces? La réponse est simple : dans la plupart des langages
actuels (c’est notamment le cas de Java, C#, PHP), il n’est possible
pour une classe d’hériter que d’une seule classe parente (abstraite ou
non), mais d’implémenter plusieurs interfaces.

Une classe qui implémente une interface doit obligatoirement

implémenter chacune des méthodes déclarées dans l’interface, à
moins qu’elle ne soit elle-même déclarée... abstraite!
Corps d’une interface
Le corps d’une interface contient une liste de constantes et de prototypes de
méthodes.
La syntaxe d’une déclaration d’une interface est la suivante:
Entête
{
déclarations des constantes et des prototypes des méthodes
}
Exemple:
interface Ecriture
{
static final int LIGNE_MAX = 50;
void ecrire();
}
c. Propriétés d’une interface
Pour dériver une classe d’une interface, on doit utiliser le mot clé implements suivi de
la liste des interfaces dont la classe dérive, séparées par des virgules.
Exemple: class A implements I1, I2
Une interface I peut être implémentée par une classe A signifie:
La classe A déclare implémenter l’interface I
Toutes les méthodes figurant dans l’interface I doivent être définie par la classe A
Une classe qui implémente une interface devra déclarer publiques (avec modificateur
public) toute les méthodes définies de l’interface .
Si une classe A implémente une interface I, les sous classes de A implémentent aussi
automatiquement I.

Utilisation d’une interface

Une interface peut être utilisée comme une classe.
Si I est une interface, on pourra référencer par la variable I n’importe quel objet d’une
classe implémentant l’interface I et on pourra appliquer à cet objet une méthode déclarée
dans l’interface (qui est nécessairement redéfinie dans la classe de l’objet référencée par
i)
d. Exemple d’utilisation d’une interface
interface AfficheTexte
{
void affiche();
}
class Appartement implements AfficheTexte {
public void affiche() {
System.out.println(‘’Bel appartement!’’); }
}
class Maison implements AfficheTexte {
public void affiche() {
System.out.println(‘’La maison n’est pas mal non plus’’); }
}
public class UtiliseInterface {
public static void main(String[] args) {
Appartement appart = new Appartement();
Maison demeure = new Maison();
appart.affiche();
demeure.affiche(); } }
A l’execution, on aura: Bel appartement!
La maison n’est pas mal non plus