Cours d’Introduction à J2ME

COURS DE JAVA EMBARQUÉ

Partie I

Wensdy [email protected]

Ecole Supérieure d’Infotronique d’Haiti

mailto:[email protected]



Plan de la 1ère partie

Présentation

Introduction Système embarqué Terminal Mobile

J2ME

Environnement de développement MIDP

Lexique

Présentation (1/2)

Objectif : Introduire les étudiants au développement des

applications pour téléphones mobiles sous Java ME.

Répartition Cours Magistraux: 15 Heures (5 séances de 3

heures) Travaux Pratiques: 30 Heures par Groupe

Groupe 1: à définir Groupe 2: à définir

Calendrier Annuel Disponible sur Moodle

Présentation (2/2)

04/13/2023

Système embarqué - Définition

Un système embarqué (ou système enfoui) est la mise en œuvre conjointe d’une plateforme matérielle et de son logiciel d’exploitation. Il est de plus complètement intégré au système qu’il contrôle et se différencie d’un ordinateur essentiellement par la variété réduite d’applications qui peuvent s’exécuter. Il est en général de petite taille et consomme très peu d’énergie.

Système embarqué - Les E/S d’un système

Origines des entrées Capteurs Base de données …

Destinations des sorties Utilisateurs Systèmes de commandes

Système embarqué - Domaines d’utilisation

Traditionnellement : Avionique Robotique

Actuellement: Electronique grand public Téléphonie mobile Transports Domotique Systèmes temps réels Multimédia Monétique Banque …

Système embarqué - Contraintes matérielles

Taille de la mémoire. Vitesse du processeur. Consommation. Capacité graphique. Capacité de stockage.

Système embarqué - Contraintes logicielles

Sureté de fonctionnement (ordonnancement, synchronisation…).

Gestion des périphériques d’E/S. Durée du temps de traitement qui doit

être la plus courte possible. Adaptation à l’environnement.

Système embarqué - Les 5 types d’applications (1/2)

Les applications locales c’est-à-dire qui ne nécessitent pas de connexion réseau (ex: jeux, calculatrice, …).

Les applications tournant en réseau peer to peer c’est-à-dire de terminal à terminal sans l’intermédiaire d’un serveur (ex: certains jeux, chat direct, certains outils de téléchargements, …).

Les applications client-serveur légères telle que l’affichage de contenu transmis par un serveur. Le terminal client ayant une logique applicative limitée.

Système embarqué - Les 5 types d’applications (2/2)

Les applications client-serveur intelligentes qui par rapport aux précédentes nécessitent un traitement coté client relativement important (ex: application sans fil).

Les applications distribuées qui tournent sur plusieurs clients sans nécessiter de serveur (certains jeux multi-joueurs, appareil de surveillance, …).

Terminal mobile - Définition

On appellera terminal mobile ou terminal embarqué un système embarqué monoprocesseur spécialisé pour un ensemble réduit de taches (ex: téléphone cellulaire, un PDA, un système de navigation pour voiture…).

Plan

J2ME Historique Caractéristiques Configurations et Profiles Packages Optionnels

J2ME - Historique (1/2)

Historiquement, Sun a proposé plusieurs plateformes pour le développement d'applications sur des machines possédant des ressources réduites, typiquement celles ne pouvant exécuter une JVM répondant aux spécifications complètes de la plate-forme Java SE. On peut citer : JavaCard (1996) : pour le développement sur des

cartes à puces PersonnalJava (1997) : pour le développement sur des

machines possédant au moins 2Mo de mémoire EmbeddedJava (1998) : pour des appareils avec de

faibles ressources

J2ME - Historique (2/2) En 1999, Sun propose de mieux structurer ces différentes

plateformes sous l'appellation J2ME (Java 2 Micro Edition). Courant 2000, la plate-forme J2ME est créée pour le

développement d'applications sur appareils mobiles ou embarqués tels que des téléphones mobiles, des PDA, des terminaux, ... : elle est donc la descendante des différentes plateformes antérieures relatives aux appareils mobiles. Seule la plate-forme JavaCard n'est pas incluse dans Java ME et reste à part.

L’élaboration de J2ME (renommé Java ME en 2005) est la seconde révolution dans l’histoire du langage Java, la première étant le concept des servlets, ces bouts de codes Java, sécurisés, tournant sur un serveur, en remplacement des scripts CGI (Common Gateway Interface) jugés peu fiable.

Caractéristiques

Un environnement J2ME est composé de plusieurs éléments: Une machine virtuelle dédiée tenant compte des

ressources limitées du matériel cible. Un ensemble d’API de base. Des API spécifiques.

Pour répondre à la plus large gamme d’appareils cibles, J2ME est modulaire grâce à 3 types d’entités qui s’utilisent par composition : Configurations Profiles Packages optionnels

Les configurations

DéfinitionUne configuration concerne un ensemble de produits caractérisés par certaines contraintes au niveau de la mémoire et de la puissance du processeur. Elle définit également le type de machine virtuelle qui sera utilisée et l’ensemble minimal de classes de base de l’API.

Types : CLDC : Connected Limited Device Configuration CDC : Connected Device Configuration

Configuration CLDC (1/3)

Elle concerne les appareils possédant : Une connexion réseau limité des ressources faibles :

Une mémoire limitée (moins de 512 Ko de mémoire dont au minimum 128 Ko de ROM et 32 Ko de RAM).

Une puissance processeur limitée Un écran d’affichage réduit Des entrées limitées Des batteries d’autonomie limitée


Exemple d’appareils : set-top box, PDA haut de gamme…

Machine virtuelle utilisée : KVM (Kilo Virtual Machine).

KVM est une machine virtuelle allégée et ne possédant pas certaines fonctionnalités de la JVM classique.


L’ API du CLDC se compose de 4 packages:

java.io : pour la gestion des entrées sorties par flux

java.lang : classes de base du langage java java.util : classes utilitaires notamment pour

gérer les collections, la date et l’heure… javax.microedition.io : classes pour gérer des

connections génériques

Configuration CDC

Elle concerne les appareils possédant : Au minimum 512 Ko de ROM et 256 Ko de

RAM. Un processeur 32 bits, en général. Un accès réseau conséquent.

Machine Virtuelle : CVM (Convergence Virtual Machine). Elle possède l’ensemble des fonctionnalités de la JVM Classique mais des capacités réduites.

Les Profiles (1/2)

Définition :Un profile définit une spécification des API, c’est-à-dire l’ensemble des API à utiliser dans une application J2ME pour une configuration donnée.

Une configuration peut contenir plusieurs profiles.

Les Profiles (2/2)

Types pour la configuration CLDC : MIDP : Mobile Information Device Profile PDAP : Personal Digital Assistant Profile

Types pour la configuration CDC : Fundation Profile Personal Basis Profile Personal Profile …

Profile MIDP (1/4)

Profile standard pour les terminaux légers. Il requiert : Un minimum de 256 Ko de ROM en plus de ce

que nécessite la configuration CLDC. Un minimum de 512 Ko de RAM + ROM pour

Java et ses bibliothèques (dont 128 Ko de RAM dédiée au tas).

Profil MIDP (2/4)

Un écran d’au moins 96x54 pixels; Des périphériques d’entrées tel qu’un clavier

ou écran tactile; Et une connexion réseau bidirectionnelle;

Profil MIDP (3/4)

L’API du MIDP se compose des API du CLDC et de trois packages :

javax.microedition.midlet : cycle de vie de l’application

javax.microedition.lcdui : interface Homme-Machine

javax.microedition.rms : persistance des données

Profil MIDP (4/4)

Ce profile permet l’exécution d’applications qui auront au préalable été téléchargées et installées. Les applications peuvent être de type bureautique, commerciales, de services, des jeux… L’écriture de ces applications que l’on appellera des MIDlets, sera détaillée par la suite.

Profile PADP (1/2)

Vient juste au dessus de MIDP et requiert : 512 Ko minimum pour Java et ses

bibliothèques, mais au maximum 16 Mo de ROM + RAM;

Un écran d’affichage d’au moins 20000 pixels Un terminal de pointage Et une entrée pour caractère

Profile PADP (2/2)

Ce profile est à mi chemin entre les profiles MIDP et le Foundation Profile.

Le profile PDAP permet d’avoir des applications de type MIDlet mais il utilise en plus un sous ensemble de l’AWT (Abstract Window Toolkit) du J2SE pour les interfaces graphiques utilisateurs.

Profile Fundation (1/2)

Il requiert : 1 Mo de ROM en plus des besoins de

l’application; 512 Ko de RAM en plus des besoins de

l’application; Une connexion réseau riche; Et une IHM (Interface Home Machine) réduite.

Profile Fundation (2/2)

C’est le profile de base pour la configuration CDC. Il permet de développer des applications n’ayant pas besoin d’interface utilisateur mais d’une connexion réseau très riche.

Profiles Personnels

Le profile personnel de baseIl permet de renforcer les fonctionnalités réseau du profile Fundation en lui permettant en plus, d’implémenter des IHM et GUI de base.

Le profile personnelC’est un profil complet pour ce qui est de la conception d’IHM et de GUI. Il repose sur l’AWT du J2SE.

Résumé des configurations et profiles

Packages Optionnels

Définir des API relatives à une fonctionnalité spécifique dont le support est facultatif.

L’ensemble de ces packages permet d’utiliser des technologies particulières (Bluetooth, services web, lecteur de code barre…).

Souvent dépendants du matériel. Ces API ne font pas partie de Java ME

mais elles s’appuient sur elle ou l’étendent pour définir des API spécifiques à un appareil ou une fonctionnalité.

Plan

Environnement de développement MIDP J2ME Wireless ToolKit (WTK) Définitions MIDlets et MIDletSuite Méthodologie de conception d’une MIDlet Interface Utilisateur

Le WTK

Boite à outil permettant de créer des applications mobiles et autres systèmes sans fil.

Avec WTK, on peut créer de nouveaux projets, les compiler et les exécuter. Mais on ne peut pas éditer le ou les codes sources correspondants.

Définition de MIDlet

Le mot MIDlet est formé à partir de MIDP et du suffixe « let » cher à Java (applet, servlet).

Une MIDlet est, comme son nom l’indique, une application reposant sur le profil MIDP et dont la classe principale étant la classe abstraite javax.microedition.midlet.MIDlet.

Définition de MIDletSuite

Une MIDletSuite est un ensemble de MIDlets réunies au sein d’un même paquetage. Ce paquetage se compose d’une archive java (fichier « .jar ») et d’un fichier décrivant le contenu de cette archive (fichier « .jad »).

Structure d’une MIDlet (1/2)

Une MIDlet peut être dans les trois états suivants : Activation; Veille; Destruction.

Le passage dans une état se fait par l’appel à la méthode correspondante, par le gestionnaire d’applications.

Structure d’une MIDlet (2/2)

L’appel à la méthode startApp() permettra d’aller dans l’état d’activation, l’appel à pauseApp() dans l’état de veille et l’appel à destroyApp() dans l’état de destruction.

Sur la diapo suivante, les états d’activation, de veille et de destruction sont respectivement appelés Active, Pause et Destroy.

Cycle de vie d’une MIDlet

Remarque

Une MIDlet peut d’elle-même passer dans les états de veille ou de destruction en appelant respectivement les méthodes notifyPaused() et notifyDestroyed(). Lorsqu’elle est dans l’état de veille, elle continue à recevoir des informations comme par exemple les timers, et elle peut décider de sortir de cet état en appelant la méthode resumeRequest().

MIDlet Méthodologie de conception

La conception d’une MIDlet nécessite plusieurs étapes : L’écriture; Compilation La pré-vérification; Le test de l’application; La mise en paquet; Et le test de l’application après la mise en

paquet.

Ecriture d’une MIDlet (1/2)

3 principes à respecter Le constructeur de la MIDlet ne doit pas faire

l’hypothèse de la disponibilité de ressources systèmes, car rien ne garantit leur présence. Il doit donc comporter le minimum d’informations permettant à la MIDlet de se lancer.

Ecriture d’une MIDlet (2/2)

3 principes à respecter (suite) : Il faut faire attention à n’initialiser le système

qu’une seule fois. En effet, vu que l’initialisation se fait à partir de la méthode startApp() et que celle-ci est appelée au début mais aussi à chaque sortie de l’état de veille, il faudra distinguer ces situations.

Une MIDlet en état de veille ne devra pas bloquer de ressources partagées critiques.

Exemple de MIDlet

La MIDlet présentée à la diapo suivante : Ne contient qu’un

bouton de commande.

Et se contente d’afficher un message de bienvenue.

Compilation d’une MIDlet

La compilation s’obtient avec la ligne de commande suivante : javac–d.–bootclasspath /home/wensdy/programmation/j2me/midp2.0fcs/classes/MaPremiereMIDlet.java

L’option « -d » indique que les classes doivent être générées dans le répertoire courant.

L’option « -bootclasspath » indique le répertoire où se trouvent les classes à importer.

Pré-vérification d’une MIDlet (1/2)

La pré-vérification s’obtient avec la ligne de commande suivante : preverify –d . –classpath home/wensdy/programmation/j2me/midp2.0fcs/classes/MaPremiereMIDlet

L’option « -d » indique que le fichier résultat issu de la phase de pré-vérification doit être mis dans le répertoire courant. Comme ce fichier porte le même nom que le fichier de classe utilisé en entrée, cela revient à écraser l’ancien fichier « .class » par le nouveau.

Pré-vérification d’une MIDlet (2/2)

Remarques : En l’absence de l’option (-d) le fichier résultat

est mis dans un répertoire output créé lors de la pré-vérification dans le répertoire de travail.

On ne va pas effectuer la pré-vérification sur un fichier « .class » mais sur une classe, donc en paramètre de l’outil de pré-vérification il ne faut pas mettre « MaPremiereMIDlet.class », mais MaPremiereMIDlet.

Test d’une MIDlet

Le test d’une application s’effectue avec la ligne de commande suivante : midp –classpath . MaPremiereMIDlet

Si on essaie d’exécuter une application qui n’a pas été pré-vérifiée, on obtient le message d’erreur suivant : ALERT : Error verifying class MaPremiereMIDlet.

Mise en paquet d’une MIDlet (1/4)

On utilise l’outil jar pour créer l’archive java (ou encore le paquet). L’archive java va contenir le code de l’ensemble des classes, et des ressources utilisées par la MIDlet comme par exemple des fichiers images (icônes…).

La ligne de commande est la suivante : jar cvfm MIDlet1.jar manifest.txt MaPremiereMIDlet.java


Le contenu du fichier manifest.txt est le suivant : MIDlet-1 : MIDlet1, MIDlet1.png,

MaPremiereMIDlet MIDlet-Name : MIDlet1 MIDlet-Vendor : Unknown MIDlet-Version : 1.0 MicroEdition-Configuration : CLDC-1.0 MicroEdition-Profile : MIDP-2.0


Liste des attributs obligatoires du fichier manifest : MIDlet-<num>, MIDlet-Name, MIDlet-Version, MIDlet-Vendor, MicroEdition-Configuration, MicroEdition-Profile.


Liste des attributs optionnels : MIDlet-Icon, MIDlet-Description, MIDlet-Info-URL, MIDlet-Jar-URL, MIDlet-Data-Size.

Test d’une MIDlet empaquetée (1/3)

Le test d'une application après la phased'archivage s'effectue avec la ligne de

commande suivante : midp classpath. Descriptor MIDlet1.jad

Fichier.jad : fichier de description du contenu de la MIDletSuite.


Contenu du .jad : Il contient les mêmes propriétés que le fichier manifest. La différence vient de la propriété MIDletJarSize qui est obligatoire dans le .jad.

Le fichier .jad sera utilisé par le gestionnaire d'application J2ME pour pouvoir vérifier que l'application est bien conforme au teminal avant de la lancer.


Le fichier MANIFEST.MF décrit les caractéristiques de l'archive .jar tandis que le fichier MIDlet1.jad décrit les caractéristiques de l'application contenue dans l'archive. Il peut éventuellement y avoir plusieurs applications, dans ce cas elles sont toutes décrites.

Interface Utilisateur

Prend en compte : Un écran tactile Un clavier limité en nombres de touches

L’ API est regroupée dans le package javax.microedition.lcdui et se compose d’éléments de haut niveaux et de bas niveaux

Interface Utilisateur – Classe Display (1/3)

Possède des méthodes pour afficher les éléments graphiques.

La méthode statique getDisplay() renvoie une instance de la classe Display qui encapsule l’écran associé à la midlet fournie en paramètre de la méthode

La méthode getCurrent() pour connaitre l’objet courammant affiché et la méthode setCurrent() pour afficher l’objet fourni en paramètre


Les éléments de l’interface graphique appartiennent à une hiérarchie d’objets : tous les éléments affichables héritent de la classe abstraite Displayable.


Classe Screen: classe mère des éléments de haut niveaux

Classe Canvas: classe mère des éléments de bas niveaux

Impossible d’ajouter un élément directement dans Display sans qu’il soit inclus dans un objet héritant de Displayable

Un seul objet de type Displayable peut être affiché.!

Lexique

API (Application Programming Interface) : Une API est une bibliothèque qui regroupe des fonctions sous forme de classes pouvant être utilisées pour développer.

Applet : Une petite application java compilée, incluse dans une page html, qui est chargée par un navigateur et qui est exécutée sous le contrôle de celui-ci. Pour des raisons de sécurité, par défaut, les applets ont des possibilités très restreintes.

AWT (Abstract Window Toolkit) : Une bibliothèque qui regroupe des classes pour développer des interfaces graphiques. Ces composants sont dits « lourds » car ils utilisent les composants du système sur lequel ils s’exécutent. Ainsi, le nombre des composants est volontairement restreint pour ne conserver que les composants présents sur tous les systèmes.

Lexique

CGI (Common Gateway Interface) : interface utilisée par les serveurs HTTP et est indépendante de tout langage.

GUI (Global User Interface) : Dispositif de dialogue Homme-Machine, dans lequel les objets à manipuler sont dessinés sous forme de pictogrammes à l’écran, que l’utilisateur peut opérer en imitant la manipulation physique des ces objets avec un dispositif de pointage, le plus souvent une souris.

JVM (Java Virtual Machine) : C’est la machine virtuelle dans laquelle s’exécute le code java. C’est une application native dépendante du système d’exploitation sur laquelle elle s’exécute. Elle répond à des normes dictées par Sun pour assurer la portabilité du langage. Il en existe plusieurs développées par différents éditeurs notamment Sun, IBM, Borland, Microsoft…


Partie II






Plan de la 2ème partie (1/3)

La P.O.O Objet – Définition Encapsulation – Définition Interface d’un Objet – Définition Classe – Définition Instanciation – Définition Héritage - Définition

Les Modificateurs Les Threads

Objet - Définition

Un objet est un ensemble autonome de méthodes et de données destiné à accomplir des tâches précises.

Les méthodes ne peuvent agir que sur les données de l'objet auquel elles appartiennent.

Encapsulation - Définition

L'encapsulation des données se traduit par le fait que les données d'un objet ne peuvent pas être modifiées directement par les méthodes extérieures à l'objet.

Pour modifier les données d'un objet il faut donc passer par ses méthodes.

L'encapsulation facilite et simplifie la réutilisation d'un objet tout en protégeant ses ressources.

Interface d’un Objet - Définition

C'est l'ensemble des méthodes visibles de l'extérieur, permettant d'appeler d'autres méthodes ou d'agir sur des données, non accessibles directement.

Classe - Définition

Une classe est un modèle utilisé pour créer un objet. Elle englobe nécessairement toutes les caractéristiques que l'on veut retrouver dans la famille d'objet qu'elle sert à créer.

Instanciation - Définition

C'est l'action de créer un objet à partir d'une classe.

Un objet est alors une instance d'une classe.

Instanciation (suite)

Le mot clé pour signifier une instanciation est new.

Pour instancier l'objet Objet1 à partir de la classe Classe1 on écrira :

Classe1 Objet1 = new Classe1()

Héritage - Définition

C'est le mécanisme permettant à une classe d'hériter de tous les comportements et attributs d'une autre classe.

L'héritage de propriétés se fera au niveau des classes et non des objets.

Héritage (suite)

Le mot clé pour signifier un héritage est : extends. Lors de la déclaration de la sousclasse on écrira :

class sousclasse extends superclasse

L'héritage multiple n'est pas autorisé comme en C++ par exemple. Une classe ne peut avoir qu'une seule superclasse, par contre son nombre de sousclasse n'est pas limité.


Les Modificateurs Modificateurs – Définition Modificateurs de contrôles d’accès Evolution des droits d’accès Les types de variables Le modificateur static Le modificateur final Le modificateur abstract

Les threads

Modificateurs - Définition

Les modificateurs sont des mots clés que l'on place au début de la déclaration d'une classe, d'une méthode ou d'une variable, et qui en change le sens.

Plusieurs modificateurs peuvent être appliqués au même élément.

Modificateurs des droits d’accès

public: les fonctions de toutes les classes peuvent accéder aux données ou aux méthodes d'une classe définie avec le niveau de visibilité public. Il s'agit du plus bas niveau de protection des données.

protected: l'accès aux données est réservé aux fonctions des classes héritières, c'est-à-dire par les fonctions membres de la classe ainsi que des classes dérivées.

private: l'accès aux données est limité aux méthodes de la classe elle-même. Il s'agit du niveau de protection des données le plus élevé.

Résumé des modificateurs de contrôles d'accès

Evolution des droits d'accès

Lors des héritages successifs : une méthode public dans une superclasse

reste public dans toutes les sousclasses; une méthode protected dans une superclasse

ne peut être dans les sousclasses que protected ou public;

une méthode déclarée sans modificateur de contrôle d'accès dans une superclasse peut voir son accès se restreindre dans les sousclasses.

Les types de variables (1/2)

Variable locale à une méthode : elle est déclarée et n'est visible qu'à l'intérieur de cette méthode.

Variable d'instance : elle est déclarée à l'intérieur d'une classe, mais en dehors du corps d'une méthode. Par principe elle se trouve juste après la première ligne de déclaration d'une classe. Son contenu peut varier d'une instance à l'autre.

Les types de variables (2/2)

Variable de classe : elle est, comme la variable d'instance, déclarée à l'intérieur d'une classe et en dehors du corps d'une méthode, mais à la particularité d'être commune à toutes les instances de classe (à celles qui existe déjà ainsi qu'à celles qui le seront).

De telles variables peuvent par exemple être utilisée pour implémenter des compteurs.

Le modificateur static

Placé devant une variable, il la transforme en variable de classe.

L'appel à une variable ou à une méthode static peut se faire utilisant non pas le nom de l'instance, mais directement le nom de leur classe. Cela facilite leur utilisation et augmente la lisibilité du code.

Le modificateur final (1/4)

Ce modificateur peut être appliqué à des variables, à des méthodes et à des classes.

Il indique d'une manière générale que l'élément auquel il est appliqué ne peut être modifié.

De cette particularité peuvent découler des optimisations dans l'exécution du programme.


Une variable final ne peut être modifiée et se comporte comme une constante.

Bien souvent une variable final est également static car cela ne sert à rien de la fournir à chaque objet de la classe si sa valeur ne doit jamais changer.


Une méthode final ne peut être redéfinie par la suite, que cela soit au sein de sa classe ou d'une sousclasse de sa classe.

A l'exécution son appel peut donc directement être remplacé par son code et l'interpréteur ne perd pas de temps à rechercher si elle est définie ou redéfinie dans une superclasse ou une sousclasse.


Une classe final ne peut être sousclassée.

C'est le cas de beaucoup de classes de la bibliothèque de classe de Java. C'est un gage de sécurité et de cohérence dans le fonctionnement du programme.

Cependant pour les classes définies par l'utilisateur l'utilité de ne pouvoir faire hériter une de ces classes est d'un intérêt discutable.

Le modificateur abstract (1/2)

Une méthode abstraite est une méthode dont la déclaration (la signature et le type de valeur de retour) est précédée du mot clé abstract, mais qui n'est pas définie (le comportement n'est pas spécifié).

Par exemple : public abstract void g(n);

Une méthode abstraite est obligatoirement public puisqu'elle a vocation à être redéfinie dans les classes dérivées.

Le modificateur abstract (2/2)

Une classe abstraite ne peut être instanciée pour créer des objets.

Elle n'est utilisé que dans le mécanisme d'héritage où elle sert de superclasse.

Une classe est abstraite si sa déclaration est précédé du modificateur abstract, ou si elle contient au moins une méthode abstraite.


Les threads Thread – Définition Les Multitâches Thread – Création Etat d’un Thread Interruption d’un Thread Groupes de Threads Priorités et Threads égoistes Synchronisation

Thread - Définition

Un thread est une portion de code paramétrée pour fonctionner de façon autonome.

Un thread, à la différence d'un processus, partage ses données avec les autres threads. C'est parfois risqué, mais cela permet au système

de gérer (création, détruction,...) beaucoup plus facilement les threads.

Les communications entre threads sont aussi moins lentes et moins restrictives qu'entre processus.

Les multitâches

Le multitâche c'est la possibilité d'avoir plusieurs programmes travaillant en même temps.

Il existe 2 sortes de multitâches : Le multitâche préemptif : les programmes

sont interrompus sans être consultés. Le multitâche coopératif ou non préemptif :

chaque programme peut être interrompu quand il en fournit explicitement l'autorisation.

Thread – Création (1/4)

On veut créer un thread avec la classe ci-dessous :

public class Test implements Runnable {public void run() {//..}

}


Pour créer un objet thread Test, il faut créer une référence à un objet de la classe Thread:Thread runner;

On créé un objet objTest à partir de la classe Test : Test objTest = new Test();


Enfin on crée le thread en appelant la méthode constructeur Thread (Object) avec comme argument l'objet constituant le thread :runner = new Thread(objTest);

On lance un thread en appelant sa méthode start() :runner.start();


2ème méthode pour créer un thread : étendre la classe Thread :public class Test extends Thread {

public void run() {//..}

} Puis : Test t = new Test(); Et enfin : t.start();

Etats d'un thread (1/5)

Le cycle de vie d'un thread contient les étapes suivantes : Création Exécution Blocage Destruction


Etape de création : On y entre par l'appel à l'opérateur new.

Etape d'exécution : On y entre par l'appel à la méthode start(). Nb : il se peut que soit prêt à être exécuté,

mais ne soit pas en cours d'exécution.


Etape de blocage : On y entre quand :

La méthode sleep() du thread est appelée. Le thread appelle un opération bloquante sur les

E/S. Le thread appel la méthode wait(). Le thread essaie de verrouiller un objet déjà

verouillé par un autre thread. La méthode suspend() du thread est appelée (NB

: cette méthode ne doit plus être utilisée).


Etape de blocage : On en sort en effectuant le chemin inverse de

celuimenant au blocage : Le nombre de millisecondes est écoulé. L'opération d'E/S est finie. Un autre thread a appelé notify ou notifyAll. Le verrou a été rendu. La méthode resume() est appelée (NB : cette

méthodeen doit plus être utilisée).

Etat d'un thread (5/5)

Etape de destruction : On y entre quand :

Le thread meurt naturellement à la fin de méthode run().

Il meurt soudainement du fait d'une exception nonrécupérable.

La méthode stop() du thread est appelée (NB : cette méthode ne doit plus être utilisée).

Interruption d'un thread (1/2)

Ce mécanisme remplace la méthode stop().

On appelle la méthode interrupt() sur le thread t : t.interrupt();

Si t est bloqué (avec un sleep ou un wait) t se termine avec l'exception InterruptedException.

NB: Cette exception peut être rattrapée avec un catch.

Interruption d'un thread (2/2)

Si t n'était ni en sommeil ni en attente, il n'y a pas d'exception et le thread doit lui-même vérifiée qu'il n'a pas été interrompu en appelant les méthodes interrupted() ou isInterrupted().

static void interrupted() met à false le drapeau indiquant l'interruption du thread courant.

boolean isInterrupted() ne change pas le drapeau.

Groupes de threads

Intérêts : Gestion simultanée de plusieurs threads

Construction :ThreadGroup g = new

ThreadGroup(« groupName »);Thread t = new Thread(g, « threadName »);

Priorités et threads égoïstes

Les priorités vont par ordre croissant de 1 à 10.

Un thread est dit égoïste s'il n'appelle ni la méthode sleep() ni la méthode yield().

yield() se contente de redonner la main au gestionnaire de thread qui peut la redonner au même thread.

sleep() force le gestionnaire de thread à passer la main à un autre thread.

Synchronisation

Le problème se pose lorsque plusieurs threads doivent partager un accès aux mêmes objets.

On marque une opération qui ne doit pas être interrompue par le mot clé synchronized.

La synchronisation verrouille une portion de code au niveau d'un objet.

wait – notify – notifyAll (1/2)

La méthode wait() permet à thread exécutant du code synchronisé de se placer dans une liste d'attente.

La méthode notify() pemet à un thread de réveiller un autre thread qui s'était placé dans la liste d'attente.

La méthode notifyAll() permet de réveiller tous les threads se trouvant dans la liste d'attente.

wait – notify – notifyAll (2/2)

Remarques :

Les méthodes wait(), notify() et notifyAll() doivent se trouver au sein du même objet.

L'appel à notify() ne permet pas de reveiller un thread en particulier. Il se peut donc que ce ne soit pas le bon thread qui soit réveillé.


Partie III






Plan de la 3ème partie

Les paquetages

Les interfaces

Les exceptions

Paquetage - Définition

Un paquetage correspond à un regroupement logique de classes.

Le nom du paquetage est alors l'identificateur commun à cet ensemble de classes.

Les paquetages (1/9) – Ajout d'une

classe à un package Pour indiquer qu'une classe fait partie d'un

paquetage, il faut utiliser en début de fichier le mot clé package suivi du nom du paquetage. Pour mettre la classe Classe1 dans le paquetage MonPaquetage, au début du fichier contenant le code de la classe on mettra :

package MonPaquetage; Il n'y a qu'une utilisation du mot clé package

par fichier et il s'applique à l'ensemble des classes du fichier.

Les paquetages (2/9) – Lien entre

package et répertoire Physiquement un paquetage correspondra

à un répertoire. Prenons par exemple l'arborescence

suivant : top/rep1/rep2/rep3. Pour faire référence à une classe se trouvant dans le répertoire rep3 on va mettre dans le fichier source de cette classe : Package rep1.rep2.rep3.

Notez bien que les « / » du nom physique correspondent aux « . » du nom logique.

Les paquetages (3/9)

Pour ce qui est de l'utilisation des classes empaquetées dans un programme, il faut en général faire référence aux paquetages auxquels elles appartiennent.

Par exemple, si on considère le paquetage MonPaquetage qui contient deux classes, Classe1 et Classe2. Alors au sein du programme ces classes seront respectivement désignées par les identifiants suivants : MonPaquetage.Classe1 et MonPaquetage.Classe2.


Il est possible, grâce au mot clé import, d'importer une classe. Cette classe est alors accessible sans que l'on ait à faire référence au paquetage.

Par exemple pour utiliser directement la Classe1 dans le programme, on peut donc au début du fichier taper : import MonPaquetage.Classe1;


Il est également possible, toujours avec le mot clé import, d'importer l'ensemble des classes d'un paquetage. Pour cela on fait suivre le nom du paquetage d'une « * ».

En reprenant l'exemple précédent, pour utiliser directement les classes Classe1 et Classe2 il suffit au début du programme de taper :

import MontPaquetage.*;


Remarquez bien que l'instruction import MontPaquetage;

sans le « * » est incorrecte.

Car on importe une classe ou un ensemble de classe, et non un paquetage.


Importer l'ensemble des classes d'un paquetage ne signifie pas importer les classes des souspaquetages qu'il contient.

Par exemple, si MonPaquetage contient un souspaquetage MonSousPaquetage qui lui contient une classe : SousClasse. Alors, le chemin d'accès complet à cette classe est :MonPaquetage.MonSousPaquetage.SousClasse


Il est possible de donner le même nom à des classes de paquetages différents. Toute ambigüité est levée en utilisant le nom complet de ces classes.

Précisons bien les choses. L'importation uniquement de classes de même nom ne génère pas d'erreur à la compilation. En revanche si ces classes sont utilisées on aura une erreur à l'exécution stipulant une référence ambigüe à une classe.


Inclure d'un seul coup toutes les classes d'un paquetage y compris celles que l'on n'utilise pas n'est pas préjudiciable pour l'exécution du programme, car les classes qui ne sont pas utilisées sont écartées à la compilation.

Il existe des paquetages dit standard et dont les classes n'ont pas besoin d'être explicitement importées. C'est le cas par exemple du paquetage java.lang dont les classes Math, System, Integer,..., sont directement accessibles.


Les paquetages

Les interfaces

Les exceptions

Interface - Définition

Une interface est une classe dont toutes les méthodes sont publiques et abstraites sans que l'on ait besoin de le spécifier par les modificateurs public et abstract.

Les attributs sont par contre considérées comme static et final.

Hiérarchies (1/2)

Il existe deux types de hiérarchies : La hiérarchie de classe :

Mot clé extends Une classe hérite des propriétés et méthodes

d'une unique classe mère.

La hiérarchie de comportement : Mot clé implements Une classe hérite de comportements par

l'implémentation d'interfaces.

Hiérarchies (2/2)

On peut avoir simultanément ces 2 types de hiérarchie :

Par exemple :public class HeritageMutiple extends MaClasse

implements MonInterface1, MonInterface2 {

//...}

Remarques

Une interface se compile comme une classe.

La plupart du temps, partout où utilise une classe, on peut utiliser une interface.

Une interface ne peut pas être instanciée. Une interface ne fournit que des

déclarations de méthodes abstraites. Pour inclure plusieurs interfaces dans une

classe, il suffit de séparer leurs noms par des virgules.

Interface – Création (1/2)

Utilisation du mot clé interface.

Exemple :interface MonInterface {

public static final int v1 = 10;int v2 = 20;public abstract void m1();void m2();

}

Interface – Création (2/2)

On ne peut pas avoir de méthodes ou d'attributs private ou protected.

Les méthodes sont de type public et abstract.

Les attributs sont de type public, static et final.

Etendre les interfaces

Une interface peut hériter d'autres interfaces.

Exemple :interface MonInterface extends Int1, Int2, Int3... {//...}

On utilise le mot clé extends et les interfaces mères sont séparées par des virgules.

L'héritage multiple est autorisé.


Les paquetages

Les interfaces

Les exceptions

Les exceptions - Définition

Une exception est un événement pouvant faire échouer un programme.

Les exceptions constituent un groupe de classes englobant toutes les erreurs pouvant faire échouer un programme mais aussi d'autres situations inhabituelles.

Gestion intuitive

On va essayer de prévoir tous les cas d'erreurs possibles à l'aide des structures if...then...else ou switch...case.

Inconvénients d'une telle méthode : Il faut prévoir tous les cas possibles. La documentation doit être précise. La gestion systématique de tous les cas est

fastidieuse.

Exemple

int status = loadTextFile();if (status != 1) {

/* description de l'événement inhabituel */switch (status) {

case 2 : /* fichier non trouvé */ break;case 3 : /* erreur disque */ break;case 4 : /* fichier corrompu */ break;default : /* autre erreur */

}} else {/* chargement du fichier ok, le programme peut continuer */}

Généralités (1/2)

Une exception peut être générée par :

Le système; Les classes utilisées; Par les programmes utilisateurs de manière

intentionnelle.

Généralités (2/2)

La classe Throwable possède 2 sous classes : Error et Exception.

Les erreurs sont internes à l'environnement d'exécution java (VirtualMachineError, ThreadDeath, ...)

Il existe deux types d'exception : Les exceptions d'exécutions : dues à du code

fragile (ArrayIndexOutOfBounds, NullPointerException, ...).

Les autres exceptions (EOFException, MalformedURLException, ...).

Protection du code (1/2)

Certaines portions de code dont l'exécution est susceptible de générer des exceptions doivent être protégées.

Par exemple à la compilation si on utilise l'instruction Thread.sleep(100) sans protection on a le message d'erreur suivant :Test1.java:23: unreported exception

java.lang.InterruptedException; must be caught or declared to be thrown

Thread.sleep(100);

Protection du code (2/2)

La solution consiste donc à taper :

try {Thread.sleep(100);

} catch (InterruptedException e) {System.out.println(e.toString());

}

La clause finally

La clause finally spécifie une portion de code qui devra impérativement être exécutée.

finally peut être utilisée après un catch ou juste après un try.

On peut aussi l'utiliser pour effectuer du nettoyage après un return, un break ou un continue.

La clause throws (1/2)

Elle indique le type d'exception pouvant éventuellement être soulevée par une méthode.

Elle se place après la signature de la méthode concernée.

Si plusieurs exceptions peuvent être soulevées, on les sépare par des virgules.

La clause throws (2/2)

Au lieu d'utiliser les clauses try et catch dans le corps d'une méthode, on peut déclarer la méthode avec une clause throws et ensuite traiter l'exception dans la méthode appelante.

On pourra toujours traiter les autres exceptions à l'aide des instructions try et catch dans le corps de la méthode.

Générer des exceptions

On utilise l'instruction throw suivie du nom de l'exception.

On peut générer des exceptions qui seront traitées dans d'autres blocs.

L'utilisateur peut définir ses propres exceptions en dérivant la classe Exception.

Remarques générales

Eviter d'utiliser des exceptions si de simples tests suffisent.

Eviter les clauses catch vide.


Partie IV






Plan de la 4ème Partie

Les principales Classes et méthodes Classe Display et ses principales méthodes Classe Displayable et ses principales

méthodes Classe Screen Classe Canvas

Les Commandes

Classe Display

La classe Display définit le gestionnaire d'écran d'affichage utilisé par la MIDlet et des périphériques d'entrée.

Il existe une unique instance de Display par MIDlet.

Pour créer cette instance, on fait appel à la méthode getDisplay(). Cette méthode renvoie une instance de la classe Display qui encapsule l’écran associé à la midlet fournie en paramètre de la méthode.

Classe Display – autres méthodes

La méthode getCurrent() pour connaitre l’objet courammant affiché.

la méthode setCurrent() pour afficher l’objet fourni en paramètre.

Classe Displayable

La classe abstraite Displayable définit un objet qui a la propriété de pouvoir être affiché.

Le contenu de cet objet affichable est défini par deux sous-classes abstraites : Screen pour les affichages haut niveau Canvas pour les affichages bas niveau

Classe Displayable – Principales méthodes

Les méthodes addCommand() et removeCommand() qui respectivement ajoute ou enlève la commande passée en paramètre dans le Displayable.

La méthode setTicker() qui affiche dans le Displayable le Ticker (texte défilant) passé en paramètre et la méthode getTicker() qui retourne le Ticker contenu dans le Displayable.

La méthode setCommandListener() qui crée un écouteur des commandes du Displayable.

Classe Screen

Elle sert de classe mère aux classes implémentant les composants graphiques de haut niveau : Alert Form List TextBox

Classe TextBox

Elle définit un composant capable d'afficher et de saisir du texte.

Son constructeur : TextBox(String title, String text, int maxSize,

int constraints)

Classe List

Elle définit un composant contenant une liste d'éléments.

Ses constructeurs sont : List(String title, int listType) List(String title, int listType, String[]

stringElements, Image[] imageElements) Les différents types de listes sont :

List.EXCLUSIVE List.IMPLICIT List.MULTIPLE

Classe Alert (1/2)

Elle définit un message d'alerte affiché durant un certain délai avant de laisser la place à un autre affichage.

Ses constructeurs : Alert(String title) Alert(String title, String text, Image image,

AlertType type)

Classe Alert (2/2)

Les types d'alerte : AlertType.ALARM AlertType.CONFIRMATION AlertType.ERROR AlertType.INFO AlertType.WARNING

Classe Form (1/2)

Elle définit un objet de type formulaire.

Ses constructeurs : Form(String title) Form(String title, Item[] items)

Classe Form (2/2)

Les éléments d'un formulaire : ChoiceGroup CustomItem DateField Gauge ImageItem Spacer StringItem TextField

Classe ChoiceGroup

Elle définit un groupe d'éléments devant être placé dans un formulaire.

Ses constructeurs sont : ChoiceGroup(String label, int choiceType) ChoiceGroup(String label, int choiceType,

String[] stringElements, Image[] imageElements)

Les différents types de ChoiceGroup sont : ChoiceGroup.EXCLUSIVE ChoiceGroup.MULTIPLE ChoiceGroup.POPUP

Classe CustomItem

Elle sert de classe mère abstraite pour l'extension de fonctionnalité d'un composant de formulaire.

Le constructeur est : CustomItem(String label)

Classe DateField

Elle définit un composant éditable représentant la date et l'heure.

Ses constructeurs sont : DateField(String label, int mode) DateField(String label, int mode, TimeZone

timeZone)

Classe Gauge

Elle définit un composant graphique représentant une barre d'avancement.

Son constructeur est : Gauge(String label, boolean interactive, int

maxValue, int initialValue)

Classe ImageItem

Elle définit un composant contenant une image.

Ses constructeurs sont : ImageItem(String label, Image image, int

layout, String altText) ImageItem(String label, Image image, int

layout, String altText, int appearanceMode)

Classe Spacer

Elle définit un composant représentant une zone vide.

Son constructeur est : Spacer(int minWidth, int minHeight)

Classe StringItem

Elle définit une chaine de caractère non modifiable, ne pouvant être qu'affichée.

Ses constructeurs sont : StringItem(String label, String text) StringItem(String text)

Classe TextField

Elle définit un composant texte éditable et initialisable situé dans un formulaire.

Le constructeur est : TextField(String label, String text, int maxSize,

int constraints)

Classe Canvas

Elle sert de classe mère aux classes implémentant les composants graphiques de bas niveau : GameCanvas

Canvas possède une méthode repaint() qui appellera la méthode paint(Graphics g) contenant l'affichage graphique bas niveau.

Plan de la 4ème Partie

Les principales Classes et méthodes

Les Commandes

Les Commandes (1/3)

Un événement de haut de niveau est constitué de la source de l'événement et de l'écouteur associé.

L'interface CommandListener contient la méthode commandAction(Command c, Displayable s).

Les Commandes (2/3)

La classe Command définit le type d'action à effectuer.

Les instructions à exécuter sont elles, codés dans la méthode abstraite commandAction de CommandListener.

Les constructeurs de la classe Command sont : Command(String label, int commandType, int

priority) Command(String shortLabel, String longLabel,

int commandType, int priority)

Les Commandes (3/3)

Les différents types de commandes : Command.BACK Command.EXIT Command.STOP Command.CANCEL Command.OK Command.HELP Command.ITEM Command.SCREEN

Documents

Cours d’Introduction à J2ME