JAVA
Introduction à la programmation
objet avec java – 4/4
Nadir BOUSSOUKAIA v1.02
SOMMAIRE
Héritage multiple et interface (15mn)
Les Threads(60mn)
2
Héritage multiple et interface (1)
objectif
avoir une classe qui hérite de plusieurs classes
Complexe et controversé (exemple en C++)
Réponse avec Java : Les interfaces
Une interface correspond à une classe où toutes les
méthodes sont abstraites.
Principe:
héritage multiple de classe interdit entre classes
Une interface peut hériter (extends) de plusieurs
interfaces.
Une classe peut implémenter (implements) une ou
plusieurs interfaces tout en héritant (extends) d'une
classe.
Une classe qui implémente une interface doit implémenter
toutes les méthodes de l’interface
3
Héritage multiple et interface (2)
abstract class Forme { public abstract double perimetre(); }
interface Affichable { void affiche(); }
class Cercle extends Forme implements Affichable, Serializable {
public double perimetre() { return 2 * [Link] * r ; }
public void affiche() {...}
}
class Rectangle extends Forme implements Affichable, Serializable {
...
public double perimetre() { return 2 * (height + width); }
public void affiche() {...}
}
...
Affichable[]affichables = {new Cercle(2), new Rectangle(2,3), new Cercle(5)};
for(int i=0; i< [Link]; i++)
affichables[i].affiche();
4
Un Thread ?
Traduction littérale : « tâche » (ou fil
d'exécution)
Thread
Unité d’exécution individuelle qui fonctionne en
parallèle d’autres Unités d’exécutions
Contrairement à un process, un thread partage
l’espace mémoire avec le programme principal
Parallèle ?
Soit plusieurs processeurs et un OS qui gère
plusieurs processeurs
Dans le cas d’un seul processeur, ceci revient à faire
du time sharing, temps partagé
cette notion n’est pas spécifique à Java!
5
Les Threads en Java
La création d’une thread s’effectue via
l’instanciation d’une classe Thread ou de toute
classe qui hérite de Thread
Pour écrire ce que le thread doit faire, il faut
créer une méthode run() : cette méthode est
l’équivalent de main() pour un programme
La méthode start() de la classe Thread
permet de démarrer le code du thread.
L’appel de la méthode start() retourne
immédiatement (détache l’execution du run())
Une fois démarré, le thread execute le code de
run() jusqu’à la sortie de la méthode.
6
Les Threads en Java
public class MaClasseThread extends Thread / implements
Runnable {
// Attributs
// Constructeurs
public MaClasseThread ( [Arguments] ) {
[Attributs] = [Arguments] ;
}
public void run ( ) {
try {
// Instructions
}
catch (InterruptException ie) {
// En cas d’interruption
}
}
} // Fin de la classe
7
La classe [Link] (1)
Cette classe représente un fil
d ’execution
2 possibilités : soit hériter de Thread soit
implémenter Runnable
class C1 extends Thread
{
public C1() { [Link](); }
public void run() {...}
}
class C2 implements Runnable
{
public C2() {Thread t = new Thread(this); [Link](); }
public void run() {...}
}
8
La classe [Link] (2)
Méthodes :
void start()
void stop()
void suspend()
void resume()
static void sleep()
static void yield()
9
Interaction entre Threads
Le classique producteur/consommateur
Comment être sur que 1 consomateur ne
peut lire que quand le producteur à fini
d ’ecrire ?
Comment être sur que 2 consomateur ne
lisent la même chose ? producteur
Solutions:
pour “locker” les ressources
tampon
partagées : synchronized
sections critiques
wait/notify consomateur consomateur
10
mot clef synchronised
synchronized permet de synchroniser l'accès à une
partie de code où à une méthode.
class Compte {
synchronized void ajouter(int montant) {...}
synchronized void retirer(int montant) {...}
}
class Client implements Runnable {
Banque b;
public Client(Banque b) {
this.b = b;
Thread t = new Thread(this); [Link]();
}
public void run() { ... [Link](100); ... [Link](10); ...}
}
Banque b = new Banque();
Client c1 = new Client (b); Client c2 = new Client(b);
P() V()
Section critique
11
wait/notify
Chaque objet possède les méthode wait(),
notify() et notifyAll()
Dans une une partie synchronized d'un objet O :
wait() relache le verrou et se met en attente.
notify() reveille un thread en attente (fifo)
notifyAll() reveille tous les threads en attente
class MyThing {
synchronized void waiterMethod() {...; wait(); ...}
synchronized void notifyMethod() {...; notify(); ...}
synchronized void anOtherMethod() {...}
12