Table des matières
Introduction
Au début des années 90, Sun travaillait sur un projet visant à concevoir des logiciels simples et performants exécutés dans des PDA (Personnal Digital Assistant). Le langage C++ a été retenu pour la programmation de ces logiciels, mais le langage C s’est avéré peu performant , notamment en ce qui concerne la sécurité et la facilité d’utilisation. On a donc opté pour un nouveau langage spécifique inspiré du C : le langage Java.
Avec le langage Java on peut avoir:
- des applications, sous forme de fenêtre ou de console
- des applets, qui sont des programmes Java incorporés à des pages web
- des applications pour appareils mobiles, avec J2ME
- et bien d’autres ! J2EE, JMF, J3D pour la 3D…
JAVA la Plateforme
Plateforme = environnement hardware et software sur lequel le programme est exécuté.
Java « Platform » se compose de:
- Java Virtual Machine (Java VM)
- Java Application Programming Interface (Java API)

JVM
Une machine virtuelle est un ordinateur fictif s’exécutant sur un ordinateur réel :
- possède un langage natif propre et traduit un programme écrit dans ce langage vers le langage natif de l’ordinateur.
- Définit les spécifications hardware de la plateforme
- Lit le bytecode compilé (indépendant de la plateforme)
La Java Virtual Machine n’est qu’une partie du logiciel Java, liée à l’interaction avec le Web. Elle est incluse dans le téléchargement du logiciel Java et permet l’exécution des applications Java
API: Java Application Programming Interface
L’API Java est structuré en libraires (packages). Les packages comprennent des ensembles fonctionnels de composants (classes).. Le noyau (core) de l’API Java (inclus dans toute implémentation complète de la plateforme Java) comprend notamment :
- Essentials (data types, objects, string, array, vector, I/O,date,…)
- Applet §Abstract Windowing Toolkit (AWT)
- Basic Networking (URL, Socket –TCP or UDP-,IP)
- Evolved Networking (Remote Method Invocation)
- Internationalization
- Security
Exécution d’un programme java
Un programme Java est compilé et interprété !

Etapes de développement
- On développe, un programme JAVA en utilisant un IDE ou bien n’importe quel éditeur de texte.
- Afin de pouvoir créer une application JAVA consistante, on a besoin du JDK.
- Pour tester et lancer le code écrit, on doit, nécessairement, disposer du JRE.


Hello World (Pré-configuration)
- Installer le JDK sous Windows ◦Télécharger et exécuter le programme “jdk-xux-windows-x64/32.exe” depuis le site d’Oracle (http://www.oracle.com/technetwork/java/javase/downloads/index.html)
- Paramétrer correctement la variable PATH (Variables d’environnement )
Les bases du langage JAVA
Java est un langage orienter objet ,d’abord nous traitons Java comme un langage de programmation classique. Nous aborderons les objets ultérieurement.
Dans un programme on trouve deux choses:
- des données
- les instructions qui les manipulent

Les données
Pour qu’un programme puisse traiter des informations (Les données), il est nécessaire que ces dernières soient mémorisées dans des variables .
Variable
Quel nom choisir pour notre variable ?
- Les noms des variables sont case-sensitive
- Les white space ne sont pas permis
- Évitez les mots réservés de java
- Le nom de la variable doit commencer par une lettre miniscule. ( Notation Camel Case. Exemple: age, quantiteStock )
Syntaxe:
type nomVariable [=value];
int id = 0;

Constante
On déclare une constante avec le mot final
final int MAX_STOCK=100;
- Le nom de la constante doit être en majuscule.
- Si le nom est composé de plusieurs mots, on utilise _ pour la séparation des mots
Les Types
Les types primitives entiers

Les types primitives reels

Exemple:
float x=1.2f
double y=34.8d
Le type primitives caractère char
char sexe=‘M’;
Le type primitives boolean
boolean abonne=true;
Le type non primitives chaine de caractère String
String message = ‘’Bonjour les amis’’;
Les variables primitives
Déclaration d’une variable primitive réservation de l’espace mémoire.
Int ram ;
boolean romain;

La valeur affectée à la variable sera stockée dans l’espace mémoire réservé.
ram=18;
disponible =false;

Les operateurs
Opérateurs arithmétiques
+, -, * : opérateurs arithmétiques
/ : division entière si les 2 arguments sont des entiers
% : reste de la division entière
exemples : 15 / 4 donne 3 15 % 2 donne 1
Opérations sur les entiers
incrémentation ++ & décrémentation – – => ajoute ou retranche 1 à une variable
int n = 12;
n ++; //Maintenant n vaut 13
// « équivalent à » n = n+1;
n- -; //« équivalent à » n = n-1;
8++; // est une instruction illégale
!! Peut s’utiliser de manière suffixée : ++n
- La différence avec la version préfixée se voit quand on les utilisent dans les expressions.
- En version suffixée la (dé/inc)rémentation s’effectue en premier
int m=7; int n=7;
int a=2 * ++m; //a vaut 16, m vaut 8
int b=2 * n++; //b vaut 14, n vaut 8
Les opérateurs logiques de comparaisons
- Égalité : opérateur ==
- Différence : opérateur !=
- supérieur et inférieur strictement à : opérateurs > et <
- supérieur et inférieur ou égal : opérateurs >= et <=
Les opérateurs logiques
- et logique : &&
- ou logique : ||
- non logique : !
Exemples :
boolean a,b, c;
a= true;
b= false;
c= (a && b); // c vaut false
c= (a || b); // c vaut true
c= !(a && b); // c vaut true
c=!a; // c vaut false
boolean x;
x= true;
x= false;
x= (5==5); // l ’expression (5==5) est évaluée et la valeur est affectée à x qui vaut alors vrai
x= (5!=4); // x vaut vrai, ici on obtient vrai ,5 est différent de 4
x= (5>5); // x vaut faux, 5 n'est pas supérieur strictement à 5
x= (5<=5); // x vaut vrai, 5 est bien inférieur ou égal à 5
Déclaration des variables

Exemples :
boolean x=true;
char sexe=‘M’;
int n=12;
float f=1.2f;
double d=34.8d;
String message = ‘’Bonjour les amis’’;
! Declaration d’un tableau : il existent plusieurs méthodes :

int[] tab;
tab = new int[5];
tab[0] = 10; // initialiser le premier élément
tab[1] = 20; // initialiser le second élément
int[] tab = { 10, 20, 30, 40, 50}; //déclaration + initialisation
Les valeurs par défaut des variables
Type | Valeur par défaut |
byte | 0 |
short | 0 |
int | 0 |
long | 0L |
float | 0.0f |
double | 0.0d |
char | ‘\u0000’ |
boolean | false |
Instructions et commentaires en JAVA
- Toute instruction se termine par le caractère ‘;’
- Il existe deux manières d’écrire des commentaires (qui ne doivent donc pas être compilés) dans un texte source :
- Les commentaires écrits sur plus d’une ligne sont encadrés par les symboles /* et */ ,
- Les commentaires écrits sur une seule ligne sont précédés des symboles //.
La Class Principale
Tous les programmes Java doivent avoir un point d’entrée, qui est toujours la méthode main (). Chaque fois que le programme est appelé, il exécute automatiquement la méthode main () en premier.
La méthode main () peut apparaître dans toute classe faisant partie d’une application, mais si l’application est un complexe contenant plusieurs fichiers, il est courant de créer une classe séparée juste pour main (). La classe principale peut avoir n’importe quel nom, bien qu’en général elle s’appelle simplement “Main”
public class Test{
public static void main(String[] args){
PcPortable monPcPortable;
monPcPortable =new PcPortable();
}
}
Les Structures de Contrôle Conditionnelles
On appelle structure conditionnelle les instructions qui permettent de tester si une condition est vrai ou faux
Structure conditionnelle ( if )
L’instruction if prend pour paramètre une expression booléenne placée obligatoirement entre parenthèses.
- Si l’expression renvoie true, le bloc d’instructions suivant est exécuté.
- Si elle renvoie false, le bloc d’instruction suivant est ignoré
if (expression) instruction;
ou if (expression) {
instruction 1;
instruction 2;
...
instruction n;
}
L’instruction else permet de compléter une instruction if lorsque la valeur retournée par l’expression est false
if (expression) {
bloc d'instructions 1;
}
else {
bloc d'instructions 2;
}
Il est possible d’écrire plus simplement des imbrications successives d’instructions if else
if (expression1) {
bloc1;
} else if (expression 2) {
bloc2;
} else if (expression3) {
bloc3;
} else {
bloc4;
}
Structure conditionnelle ( switch )
L’instruction switch permet de s’affranchir des branchements else if vu précédemment, dans le cas ou les conditions sont toujours des tests d’égalité sur la même variable. Une grosse contrainte porte sur le paramètre de l’instruction switch : il doit être obligatoirement de type entier (ok pour la version 8). On peut donc uniquement utiliser le switch pour comparer des valeurs entières entre elles.
La structure switch permet d’effectuer tel ou tel traitement en fonction de la valeur des conditions 1ou 2 ou ..n .
switch (expression) {
case valeur 1: d'instructions; break;
case valeur 2: d'instructions; break;
. .
case valeur N: d'instructions; break;
default: d'instructions par défaut ;
}
La boucle for
La boucle for est utilisée pour répéter un traitement sous forme de bloc d’instructions un certain nombre de fois en principe connu à l’avance.



L’instruction while
L’instruction while permet d’itérer un bloc d’instructions tant qu’une condition est vérifiée.
Elle présente de plus l’avantage de tester la condition avant la première exécution.
Les instructions break et continue peuvent aussi être utilisées dans les boucles while.
while (expression) {
instruction1;
instruction2;
...
instructionn;
}
L’instruction do…while
L’instruction do…while correspond au “repeat” des autres langages. Il correspond au cas ou le traitement doit s’éffectuer au moins une fois et lorsque c’est lui qui détermine l’état de la condition.
do {
instruction1;
instruction2;
...
instructionn;
} while (expression);
Les packages
- Un package regroupe un ensemble de classes sous un même espace de ‘nomage’.
- Les noms des packages suivent le schéma : name.subname …
- Une classe Watch appartenant au package time.clock doit se trouver dans le fichier time/clock/Watch.class
- Les packages permettent au compilateur et à la JVM de localiser les fichier contenant les classes à charger.
- L’instruction package indique à quel package appartient la ou les classe(s) de l’unité de compilation (le fichier).
- Les répertoires contenant les packages doivent être présents dans la variable d’environnement CLASSPATH
- En dehors du package, les noms des classes sont : packageName.className
- L’instruction import packageName permet d’utiliser des classes sans les préfixer par leur nom de package.
- Les API sont organisées en package (java.lang, java.io, …)

Classe et objet
un langage orienté-objet
Qu’est-ce qu’un objet ?
Modélise toute entité identifiable, concrète ou abstraite, manipulée par l’application logicielle :
- une chose tangible ex: ville, véhicule, étudiant, un bouton sur l’écran
- une chose conceptuelle ex: date, réunion, planning de réservation
Un objet possède :
- Une identité unique (permet de distinguer un objet d’un autre)
- Des états interne représentent les caractéristiques de l’objet (Les attributs)
- Des comportements représentent les opérations qui s’appliquent sur ces états (les méthodes)
Classe et objet Java ?
On appelle classe la structure d’un objet, c’est-à-dire la déclaration de l’ensemble des entités qui composeront un objet.
Un objet est donc « issu » d’une classe, c’est le produit qui sort d’un moule. En réalité on dit qu’un objet est une instanciation d’une classe
objet = instance
Une classe est composée de deux parties :
- Les attributs (parfois appelés données membres) : il s’agit des données représentant l’état de l’objet
- Les méthodes (parfois appelées fonctions membres): il s’agit des opérations applicables aux objets

Déclaration de la classe
public class PcPortable {
/*Déclaration des attributs*/
/*Déclaration des méthodes*/
//commentaire sur une seule ligne
/*commentaires sur
plusieurs lignes*/
}
- Le fichier .java doit avoir le même nom que la classe (PcPortable.java)
- Le nom de la classe doit commencer par une majiscule
Catégories des variables
Il existe deux sortes de variables :
- Une variable primitive contient des bits qui représentent sa valeur. Exemple : int, foat , boolean.
- Une variable référence contient des bits qui indiquent comment accéder à l’objet. Exemple : String, Chien, Joueur,…

Les variables références: String
- on crée une référence sur une String
- Lorsqu’on déclare une variable objet , on est en fait en train de faire la réservation de l’espace mémoire pour la référence

Les variables références: Les tableaux

Déclaration des méthodes
Syntaxe:
Type_retour nom_method([arguments]) { }
Exemple:
void afficherInfoPcPortable (){ }
Le nom de la méthode doit commencer par un verbe
Les constructeurs
Pour créer un objet à partir d’une classe, on utilise l’opérateur new.
L’opérateur new fait appel au constructeur de la classe
public class Test{
PcPortable pc1=new PcPortable();
}

- un constructeur porte le même nom que la classe dans laquelle il est défini
- un constructeur n’a pas de type de retour (même pas void)

Qu’est ce que fait le Le mot-clé this ?
Le mot-clé this permet de désigner l’objet courant, this permet d’accéder aux attributs et méthodes de l’objet courant
- Pour manipuler un attribut de l’objet courant: this.couleur
- Pour manipuler une méthode de la super-classe : this.ajouter_PcPortable (100)
- Pour faire appel au constructeur de l’objet courant: this()
- Si vous ne créez pas un constructeur dans votre classe, le compilateur va automatiquement vous créer un constructeur par défaut implicite.
- Si le constructeur surchargé est créé, le constructeur par défaut implicite ne sera plus créer par le compilateur
- La platforme java différencie entre les différents constructeurs déclarés au sein d’une même classe en se basant sur le nombre des paramètres et leurs types.
On ne peut pas créer deux constructeurs ayant le même types des paramètres.
Chemise(int id) {
this.id=id
}
Chemise(int id) {
this.id=id*2 //Erreur de compilation
}
Quel constructeur va choisir Java lorsque vous allez créer votre objet ?

Le Destricteur
le programmeur java n’a pas à s’occuper lui-même de libérer la mémoire en supprimant les objets devenus inutiles, c’est le rôle du Garbage Collector
Le Garbage Collector est exécuté automatiquement dès que la mémoire disponible devient inférieure à un certain seuil.
Le destructeur est une méthode spéciale qui sera appelée lorsque l’objet sera nettoyé de la mémoire par le Garbage Collector.

Java Destructor finalize()
Notion de référence



Encapsulation
- L’encapsulation est un pilier de la programmation orientée objet, où chaque classe définit des méthodes ou des propriétés pour interagir avec les données membres, mais ce principe peut se rencontrer dans d’autres styles de programmation (par exemple la programmation modulaire [les packages]).
- Consiste à ne laisser apparaître d’un code que ce qui doit être visible de l’extérieur
- On parle de contrôle d’accès
- On peut masquer des membres d’une classe ou des classes d’un package
Les niveaux d’accès
- Public : un élément public est accessible de partout et sans aucune restriction.
- Protected : un élément protected l’accès aux données est réservé aux fonctions des de la même package ainsi que les classes héritières, c’est-à-dire par les fonctions membres de la classe ainsi que des classes dérivées
- Private : un élément private (privé) est accessible uniquement au sein de la classe dans laquelle il est déclaré. Ces éléments ne peuvent être manipulés qu’à l’aide de méthode spécifiques appelés accesseur et mutateur
- « Package » : un élément est Package par défaut est accessible uniquement aux classes d’un package et à ses classes filles.
Encapsulation des classes


Encapsulation des attributs


Encapsulation des méthodes


- Dans le but de renforcer le contrôle de l’accès aux variables d’une classe, il est recommandé de les déclarer private.
- Pour la manipulation des attributs private, on utilise:
- Un mutateur (setter): est une méthode qui permet de définir la valeur d’une variable particulière
- Un accesseur (getter): est une méthode qui permet d’obtenir la valeur d’une variable particulière.
- Le setter et le getter doivent être déclarés public
private float prix;
public void setPrix(float prix){
this.prix=prix;
}
public float getPrix(){
return prix;
}
private boolean absent;
public void setAbsent(boolean absent){
this.absent=absent;
}
public boolean isAbsent(){
return prix;
}
Static
- Les variables static sont communes à toutes les instances de la classe.
- Il n’est pas nécessaire d’instancier une classe pour accéder à un de ses membres statiques.
- Les attributs static sont initialisés par défaut à 0 pour les nombres entiers et réels, à false pour les booléens et à null pour les références.
- Les méthodes static sont des fonctions qui délivrent un résultat indépendamment de tout objet, elles sont mises (en dehors de leur classe) en les faisant précéder du nom de la classe les définissant.
Les attributs static
Utilisation : On invoque les variables static avec le nom de la classe.
class Etudiant{
String nom;
static int nbrEtudiants;
Etudiant(String nom){
this.nom=nom;
nbrEtudiants++;
}
}
class Test{
public static void main(String[] args){
System.out.println(Etudiant.nbrEtudiants);
}
}
Les méthodes static
Le comportement d’une méthode statique ne dépend pas de la valeur des variables d’instance
class MaClassMath{
static int min(int a , int b){
if(a<b){
return a;
}else{
return b;
}
}
}
Utilisation: L’appel à une méthode statique se fait en utilisant le nom de la classe.
class Test {
public static void main ( String [] args ){
int x = MaClassMath .min (21 ,4);
}
}
Puisque les méthodes static appartiennent à la classe, elles ne peuvent en aucun cas accéder aux variables d’instances qui appartiennent aux instances de la classe.
- Les méthodes d’instances accèdent aux variables d’instance et méthodes d’instances
- Les méthodes d’instances accèdent aux variables de classe (static) et méthodes de classe (static)
- Les méthodes de classe (static) accèdent aux variables de classe (static) et méthodes de classe (static)
- Les méthodes de classe (static) n’accèdent pas aux variables de d’instance et méthodes d’instance
- Dans une méthode static on ne peut pas utiliser this
Héritage

- Duplication de code.
- Une modification faite sur un attribut (ou méthode) commun doit être refaite dans les autres classes.
Solution:

On place dans la classe mère tous les attributs et toutes les méthodes communs à toutes les classes.
Les classes filles ne comportent que les attributs ou méthodes plus spécifiques.
Les classes filles héritent automatiquement les attributs (et les méthodes) qui n’ont pas besoin d’être ré-écrits.
En Java, on indique qu’une classe hérite d’une autre en utilisant le mot-clé “extends”
class Personne {
String nom;
long cin;
public void setNom(String nom){
this.nom=nom;}
public String getNom(){
return nom;}
public void setCin(long cin){
this.cin=cin;}
public long getCin(){
return cin;}
}
class Etudiant extends Personne {
float moyenne;
public void setMoyenne(float moyenne){
this.moyenne=moyenne;}
public float getMoyenne (){
return moyenne;}
}
Une classe peut avoir plusieurs sous-classes.

Une classe ne peut avoir qu’une seule classe mère

class Personne {
private String nom;
private long cin;
public Presonne(){
nom=“Mohamed”;
cin=00000000;
}
}


Redéfinition
class Personne {
public void lire() {
System.out.println(“Je sais lire”);
}
}
class Etudiant extends Personne {
public void lire() {
System.out.println(“Je suis un étudiant”);
super.lire();
}
}
=> Possibilité de réutiliser le code de la méthode héritée (super)
Surcharge
class Etudiant extends Personne {
public void lire(String titreLivre) {
System.out.println(“Je sais lire”);
System.out.println(“J’ai lu le livre ”+titreLivre);
}
}
On garde la même nom de la méthode, le même type de retour et on change les paramètres => On parle alors de surcharge
La classe Object
- Toutes les classes java héritent implicitement de la classe Object.
- On dit alors que la classe Object est l’ancêtre de toutes les classes
- Méthodes importantes de la classe Object :
- public String toString()
- public booleanequals (Object)
- public final Class getClass()
- public inthashcode()

Final attribut / methode / class
- Le mot clé Java final signifie « Cela ne peut pas changer ».
- Vous pourriez vouloir empêcher les changements pour deux raisons :
- conception
- efficacité
- Une constante est utile pour deux raisons:
- Elle peut être une constante lors de la compilation qui ne changera jamais
- Elle peut être une valeur initialisée à l’exécution qu’on ne veut pas changer.
- Une méthode indiquée comme final ne peut être redéfinie dans une classe dérivée.
public class MaClass {
public final void uneMethode() { ... }
}
- Les class final ne peuvent être dérivées , Cela peut être fait dans un souci d’efficacité ou pour empêcher l’utilisateur d’en faire une utilisation non appropriée dans la classe dérivée
public final class ClasseFinal { ... }
Polymorphisme
N’importe quel objet en Java qui peut passer d’une relation « est un » peut être considéré polymorphe. Le polymorphisme est le fait de référencer une classe fille avec un référence déclaré de type une classe mère.

Avec le polymorphisme : le type de la référence peut être la classe mère de l’objet instancié. èOn peut penser à un tableau polymorphique.
Soit :
Personne [ ] personne = new Personne [3];
- Déclarer un tableau de type Personne.
- Un tableau qui contiendra des objets de type Personne.
On peut mettre n’importe quel classe fille de la classe
personne [0] = new Etudiant();
personne [1] = new Employe();
personne [2] = new Chercheur()


Lorsqu’une méthode d’un objet est accédée au travers d’une référence “surclassée” (Personne), c’est la méthode définie au niveau de la classe réelle (Employe) de l’objet qui est invoquée et exécutée
Class abstract
- La définition d’une classe abstraite est entre la définition d’une classe «normale» et d’une interface
- Elle déclare un comportement
- Elle ne définit pas d’’implémentation
Pour définir une classe abstraite, on utilise le mot clé abstract
public abstract class Personne
Méthode abstraite
Une méthode sans implémentation est obligatoirement abstraite , elle est défini par le mot clé abstract public abstrat void lire();
Une classe dont une méthode est abstraite est obligatoirement abstraite et est donc défini par le mot clé abstract.
public abstract class Personne
{
public abstract void lire();
}

Exceptions
L’exception est une erreur qui se produit, soudainement, lors de l’exécution d’un programme
Une exception :
- est un objet, instance d’une classe d’exception
- provoque la sortie d’une méthode
- correspond à un type d’erreur
- contient des informations sur cette erreur

- Throwable est la classe de base, à partir de laquelle vont dériver toutes les exceptions.
- Error: Elle gère les erreurs liées à la machine virtuelle (LinkageError, ThreadDeath etc.)
- Exception: contient l’ensemble des exceptions gérées par le Programmeur (ArithmeticException etc.).
- RunTimeException: regroupe les erreurs de base(Arithmetic, etc.)
- IOException: regroupe les erreurs entrée/sortie.
- Error et RunTimeException appartiennent à la catégorie « uncheked » donc “throws” n’est pas nécessaire à coté de la méthode qui lance une exception de cette catégorie là.
- Toutes les autres excéptions (y compris donc celles créées par le programmeur) appartiennent à la catégorie des “checked” où l’utilisation de “throws” est exigée.
Une exception peut être déclenchée de deux façons :
- Suite à une erreur d’exécution dans le programme JAVA, la JVM génère une exception (RunTimeException) ou bien ( Error)
- Le développeur peut, à son tour, déclencher une exception au sein de son programme(qui étend la classe Exception).
Exemple:
public class Calcul {
public static void main(String[] args) {
int x = 20, y = 0 ;
System.out.println (x / y); //Aucune erreur lors de la compilation
}}
Résultat d’exécution :
Exception in thread "main" java.lang.ArithmeticException: / by zero
at Erreur.main(Erreur.java:4)
Le programmeur peut lever ses propres exceptions à l’aide du mot réservé throw.
throw prend en paramètre un objet instance de Throwable ou d’une de ses sous-classes.
Le mot-clé throw fait partie des mots-clés réservés du langage Java, et il permet de forcer la génération d’une exception, représentée par l’objet qu’on lui passe en paramètre.
throw new MonException ("Exception personnalisée !!!");
Interface et Collection
Une interface est une collection d’opérations utilisée pour spécifier un service offert par une classe.
Une interface peut être vue comme une classe abstraite sans attributs et dont toutes les opérations sont abstraites.
- Toutes les méthodes sont abstraites
- Elles sont implicitement publiques
- Possibilité de définir des attributs à condition qu’il s’agisse d ’attributs de type primitif
- Ces attributs sont implicitement déclarés comme static final

import java.awt.*;
public interface Dessinable {
public void dessiner(Graphics g);
void effacer(Graphics g);
}
Une classe JAVA peut implémenter simultanément plusieurs interfaces
Pour cela la liste des noms des interfaces à implémenter séparés par des virgules doit suivre le mot clé implements
class RectangleDessinable extends Rectangle implements Dessinable,Comparable {
public void dessiner(Graphics g){
g.drawRect((int) x, (int) y, (int) largeur, (int) hauteur);
}
public void effacer(Graphics g){
g.clearRect((int) x, (int) y, (int)largeur, (int) hauteur);
}
public int compareTo(Object o) {
if (o instanceof Rectangle)
...
}
}
Interface et polymorphisme
Une interface peut être utilisée comme un type a des variables (références) dont le type est une interface il est possible d’affecter des instances de toute classe implémentant l’interface, ou toute sous-classe d’une telle classe.
public class Fenetre {
private nbFigures;
private Dessinable[] figures;
...
public void ajouter(Dessinable d){
...
}
public void supprimer(Dessinable o){
...
}
public void dessiner() {
for (int i = 0; i < nbFigures; i++)
figures[i].dessiner(g);
}
}

Héritage d’interface
- De la même manière qu’une classe peut avoir des sous-classes, une interface peut avoir des “sous-interfaces”
- Une sous interface
- hérite de toutes les méthodes abstraites et des constantes de sa “super-interface”
- peut définir de nouvelles constantes et méthodes abstraites
- Une classe qui implémente une interface doit implémenter toutes les méthodes abstraites définies dans l’interface et dans les interfaces dont elle hérite.

interface Set extends Collection
{
...
}
A la différence des classes une interface peut étendre plus d’une interface à la fois

package java.nio;
interface ByteChannel extends ReadableByteChanel, WriteableByteChanel {
}
Les collections
Collection : objet qui regroupe de multiples éléments dans une seule entité.
Utilisation de collections pour
- stocker, retrouver et manipuler des données
- transmettre des données d ’une méthode à une autre.
Exemples :
- un dossier de courrier : collection de mails
- un répertoire téléphonique : collection d ’associations noms numéros de téléphone.
Par exemple, un tableau est une collection. Le JDK fournit d’autres types de collections sous la forme de classes et d’interfaces. Ces classes et interfaces sont dans le paquetage java.util
Des interfaces dans 2 hiérarchies principales :
- Collection<E>
- Map<K,V>
Collection correspond aux interfaces des collections proprement dites par contre Map correspond aux collections indexées par des clés ,un élément de type V d’une map est retrouvé rapidement si on connaît sa clé de type K (comme les entrées d’un dictionnaire ou les entrées de l’index d’un livre)



Comme exemple, on va voir les classes ArrayList et HashMap comme classes d’implémentation de List et de Map , elles permettront d’introduire des concepts et informations qui sont aussi valables pour les autres classes d’implantation
- Collections (avec un s final) fournit des méthodes static pour, en particulier,
- trier une collection
- faire des recherches rapides dans une collection triée
- Arrays fournit des méthodes static pour, en particulier,
- trier
- faire des recherches rapides dans un tableau trié
- transformer un tableau en liste
Exemple de liste
List <String> l = new ArrayList <String>();
l.add("Pierre Jacques");
l.add("Pierre Paul");
l.add("Jacques Pierre");
l.add("Paul Jacques");
Collections.sort(l);
System.out.println(l);
Exemple de Map
Map <String, Integer> frequences = new HashMap <String, Integer> ();
for (String mot : args) {
Integer freq = frequences.get(mot);
if (freq == null)
freq = 1;
else
freq = freq + 1;
frequences.put(mot, freq);
}
System.out.println(frequences);
Conclusion
Dans la prochaine partie, nous passerons à la logique de programmation,
Que pensez-vous de ce cours ? Donnez-nous votre avis dans un commentaire.