• Save
Les bases du langage java
Upcoming SlideShare
Loading in...5
×
 

Les bases du langage java

on

  • 804 views

 

Statistics

Views

Total Views
804
Views on SlideShare
804
Embed Views
0

Actions

Likes
0
Downloads
0
Comments
0

0 Embeds 0

No embeds

Accessibility

Categories

Upload Details

Uploaded via as Adobe PDF

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

Les bases du langage java Les bases du langage java Presentation Transcript

  • Télécharger ce document sur http://www.krymo.com JAVALES BASES DU LANGAGE
  • LES BASES DU LANGAGE Sommaire Principes généraux de la syntaxe Identificateurs et mots clefs Types primitifs Types objet Types tableaux Allocation de types Conventions de codage
  • LES BASES DU LANGAGE La syntaxe : principes Qu’est ce que la syntaxe : Principes généraux Écriture des lignes de programme : le point-virgule ; les parenthèses ( ) les accolades { } La virgule , Écrire de commentaires Identificateurs : de constantes de variables, tableaux, … de méthodes, de classes, … Mots clés : de variables, tableaux, … de méthodes, de classes, …
  • LES BASES DU LANGAGE lignes de programme Écriture des lignes de programme : le point-virgule : Une ligne de programme ; Une autre ligne ; Encore une ligne ; les parenthèses : if ( condition dans un test ) for ( champ1 ; champ2; champ3 ) Methode ( ) les accolades : { …………………………. délimite un bloc d’instruction } …………………………. int ValeurSomme , Moyenne, Total ; La virgule : Methode( Var1, Var2, Var3 )
  • LES BASES DU LANGAGE Les commentaires Rôle d’un commentaire : Comment écrire une ligne de commentaire // voici une ligne de commentaire /* voici une autre ligne de commentaire */ Comment écrire des commentaires sur plusieurs lignes /* voici une première ligne une deuxième ligne encore une ligne la fin du commentaire */
  • LES BASES DU LANGAGE Les identificateurs Rôle d’un identificateur Cas des constantes MINIMA TOTAL TAUX Cas des variables, tableaux, référence VoiciUneVariable UnTableau[ ] UnAutreTableau[ ][ ] Cas des méthodes AfficherTexte ( )
  • LES BASES DU LANGAGE Les mot-clés Qu’est ce qu’un mot-clé Exemple de mot-clé int Applet float Random string drawRectangle
  • Les types, variables, commentairesLes types primitifs les variables boolean : true et false Identificateur : nom donné à la variable byte : 1 octet Type voir à gauche char : 2 octets Déclaration : partout dans un bloc de programme short : 2 octets Syntaxe de déclaration : type Identificateur ; int : 4 octets Exemple : long : 8 octets float Longueur; float : 4 octets int Somme, Couleur; double : 8 octets Affectation Variable1 = expression ; Conversion de type Les commentaires exemple : Somme = (int)Longueur ; // commentaire sur une ligne /* commentaires sur plusieurs lignes */
  • Les tableauxLes tableaux Identificateur : nom donné au tableau par l’utilisateur Type ( idem variables ) Déclaration : partout dans un bloc de programme Syntaxe de déclaration : type Identificateur [ ] ou type [ ] Identificateur ;Exemple : int [ ] TableauColonnesLignes; int Tab1 [ ] , Tab2 [ ] [ ] ; Affectation int [ ] compte = { 1,2,4,78,9, …. }; TableauColonnesLignes = new int [20] ; Utilisation int Longueur = TableauColonnesLignes.length ;
  • LES BASES DU LANGAGE La syntaxe : Conventions Convention d’écriture de programme Les entêtes de programme L’entête contient les informations // Entête du programme d’identification ( titre, version, auteur,..) , de description ( résumé succinct, …) //…………… , de protection ( copyright, … ) // …………… La place des bibliothèques import package.sousPackage. * ; ……………… Ici on place les importations de package et de classes nécessaires à la compilation du programme : classes d’un package ou méthodes d’une classe // Entête de classe utilisées dans le programme Class nomDeClasse1 { Les entêtes de classe } // Entête de classe la place des classes Class nomDeClasse3 { }
  • LES BASES DU LANGAGE Ma première applicationOn veut créer une application informatique la plus simple possibleen java qui vous permette d’afficher le message hello world surL’écran.Cette application se composera d’une seule classe nommée MonAppliEt d’une seule méthode nommée main ( … )Représentation graphique de l’application MonAppli main ( )
  • LES BASES DU LANGAGE Ma première application Application : Gestion de message // ------------------------------------------------------------------------------------------------------- // Application Hello World // ------------------------------------------------------------------------------------------------------- // Version 1.0 : réalisé par A. Blanc le : 10 / 11 / 2004 //--------------------------------------------------------------- // Application informatique permettant d’afficher le message hello world sur l’écran //------------------------------------------------------------------------------------------------------- // copywright interdit //------------------------------------------------------------------------------------------------------- //----------------------------------------------------------------------- // importation des bibliothèques import java.lang.* ; // ------------------------------------------------------------------------------------------------------- // Classe de gestion de message // ------------------------------------------------------------------------------------------------------- public class MonAppli { // méthode principale de l’application public static void main( String Arguments[ ]) { system.Out.println ( "Hello World " ); } }
  • LES BASES DU LANGAGE Modification : Intégration d’une variableOn veut modifier l’application précédentepour pouvoir afficher lemême message. La différence consiste à déclarer une variable de typeString qui contiendra la chaîne de caractère hello world.On utilisera une variable Message qui sera déclarée et initialiséedans la méthode principale.
  • LES BASES DU LANGAGE Modif : variable Application : Gestion de message avec intégration d’une variable // ------------------------------------------------------------------------------------------------------- // Application Hello World // ------------------------------------------------------------------------------------------------------- // Version 1.1 : réalisé par A. Blanc le : 10 / 11 / 2004 //--------------------------------------------------------------- // Application informatique permettant d’afficher le message hello world sur l’écran //------------------------------------------------------------------------------------------------------- // copywright interdit //------------------------------------------------------------------------------------------------------- //----------------------------------------------------------------------- // importation des bibliothèques import java.lang.* ; // ------------------------------------------------------------------------------------------------------- // Classe de gestion de message // ------------------------------------------------------------------------------------------------------- public class MonAppli { // méthode principale de l’application public static void main( String Arguments[ ]) { String Message = "Hello World "; system.Out.println ( Message ); } }
  • LES BASES DU LANGAGE Modif : création d’une instanceOn veut créer une application informatique en java qui vous permette d’afficher le messagehello world sur l’écran.Cette application se composera de 2 classes l’une nommée MonAppli, l’autre nomméeGestionMessage.La méthode Afficher permet l’affichage du message dans la fenêtre DOS en utilisantsystem.Out.println ( "Hello World " );Représentation graphique de l’application GestionMessage Afficher ( ) MonAppli main ( )
  • LES BASES DU LANGAGE Modif : Instance Application : Gestion de message avec création d’une instance // ------------------------------------------------------------------------------------------------------- // Classe principale de l’application // ------------------------------------------------------------------------------------------------------- class TriBulle { public void GestionTri () { Tri(); Afficher(); } private void Tri(){ } // ------------------------------------------------------------------------------------------------------- // private void Afficher(){ Classe principale de l’application // ------------------------------------------------------------------------------------------------------- public class MonAppli { } } // méthode principale de l’application public static void main( String Arguments[ ]) { GestionMessage ref; ref = new GestionMessage ( ) ; ref . Afficher ( ); } }
  • class TriBulle { int Tab[]={2,4,1, }; public void GestionTri () { System.out.println ( "Inst je suis dans gestion tri" ); Tri(); Afficher(); } private void Tri(){ System.out.println (" Inst je suis dans tri" ); } private void Afficher(){ System.out.println (" Inst je suis dans afficher" ); }} public class MonAppli 04{ public static void main( String Arguments[ ]) { TriBulle ref = new TriBulle ( ) ; System.out.println (" PP j’appelle Gestion tri" ); ref . GestionTri ( ); System.out.println (" PP fin du programme" ); } }
  • POUR i …….. for (int i=0;i<12;++i) {FINi }SI ( condition) if ( Table[i]> Table[i+1]){FSI }
  • Instance / référence et syntaxe Place son adresse dans une reference Voiture Reference = new Voiture ;type Crée une instance De voiture La reference Sur l’objet Est de
  • LES BASES DU LANGAGE Modif : création de 2 instancesOn veut créer une application informatique en java qui vous permette d’afficher le messagehello world sur l’écran.Cette application se composera de 2 classes l’une nommée MonAppli, l’autre nomméeGestionMessage.La méthode Afficher permet l’affichage du message dans la fenêtre DOS en utilisantsystem.Out.println ( "Hello World " );Représentation graphique de l’application GestionMessage Afficher ( ) MonAppli main ( )
  • LES BASES DU LANGAGE Modif : 2 instances Application : Gestion de message avec création de 2 instances // ------------------------------------------------------------------------------------------------------- // Classe principale de l’application // ------------------------------------------------------------------------------------------------------- class GestionMessage { // méthode principale de l’application public void Afficher () { system.Out.println ( "Hello World " ); } } // ------------------------------------------------------------------------------------------------------- // Classe principale de l’application // ------------------------------------------------------------------------------------------------------- public class MonAppli { // méthode principale de l’application public static void main( String Arguments[ ]) { GestionMessage refObjet1, refObjet2; refObjet1 = new GestionMessage ( ) ; refObjet2 = new GestionMessage ( ) ; ……………….. ; } }
  • LES BASES DU LANGAGE Mon Premier Applet Applet : Gestion de message // ------------------------------------------------------------------------------------------------------- // Applet Hello World // ------------------------------------------------------------------------------------------------------- // Version 1.0 : réalisé par A. Blanc le : 10 / 11 / 2004 //--------------------------------------------------------------- // applet permettant d’afficher le message hello world sur l’écran dans la fenêtre dos //------------------------------------------------------------------------------------------------------- // copywright interdit //------------------------------------------------------------------------------------------------------- //----------------------------------------------------------------------- // importation des bibliothèques import java.applet.* ; import java.awt.*; // ------------------------------------------------------------------------------------------------------- // Classe de gestion de message // ------------------------------------------------------------------------------------------------------- class GestionDeMessage extend Applet { // méthode principale de l’application public void paint( Graphics ref) { ref . drawString( ( "Hello World « ,10,25 ); } }
  • LES BASES DU LANGAGE Un autre exemple d’applet // -------------------------------------------------------------------- // importation des bibliothèques //--------------------------------------------------------------------- import java.applet.*; import java.awt.*; // -------------------------------------------------------------------- // classe MonApplet : hérite de Applet //--------------------------------------------------------------------- public class MonApplet extends Applet{ int XMessage,YMessage; String Message; // méthode d’initialisation de l’applet public void init(){ Message="* mon premier applet *"; XMessage=10; YMessage=10; } // méthode d’affichage public void paint(Graphics g){ g.setColor(Color.black); g.drawString(Message,XMessage,YMessage); } }
  • Les itérations et les testsLes tests :if (condition ) { inst1; inst2; inst3; }if ( condition ) { ……} else {….}if ( condition ) { ……} else if {….} else {….}La sélectionswitch ( valeur ) { case 1 : …..; case 2 : …..; break; case 3 : ……; default : ……;Les itérationsfor (int i=0;i<12;++i) { inst1; inst2;}La boucle while ( condition ) { ….; …..; …..}La boucle do { inst1; inst2; …} while (condition);
  • Application : calcul d’une moyenneOn veut écrire une application permettant de saisir des valeurs entières au clavier et les mémoriserdans un tableau nommé NotesEtudiant [ 24 ] puis de calculer la moyenne et de l’afficher.On utilisera un objet Moyenne composé des méthodes privées: SaisirNotes ( ) CalculerMoyenne( ) AfficherMoyenne( )La méthode GestionCalcul( ) est une méthode publique qui permet de réaliser les appels des méthodesSaisirMoyenne( ), CalculerMoyenne( ), AfficherMoyenne( )L’objet MonAppli permettra de créer une instance de l’objet Moyenne et d’appeler la méthode GestionCalcul( ) On donne la représentation graphique du diagramme des classes de l’application. Moyenne On demande en utilisant les algorithmes vus en cours de construire les classes MonAppli et Moyenne NbreNotes NotesEtudiant[ ] Moyenne MonAppli AfficherMoyenne ( ) CalculerMoyenne( ) SaisirNotes( ) main ( ) GestionCalcul ( )
  • Les packagesLes packages java C’est le regroupement des classes utilisées dans le langage java A un package correspond un domaine particulier ( awt : graphique , Math , …. ) import NomDePackage . * ; // on importe toutes les classes du package import NomDePackage . NomDeClasse ; // on importe la classe
  • Classes, Objets, Instance Instance : Objet réel ( une voiture bleue, numéro 1258 SF 28 , ….) Objet : Objet abstrait ( les voitures en général ) Classe : modélisation de l’objet abstrait dans le domaine d’étude Une instance Un objet Une classe Voiture Voiture Voiture Attributs Couleur : bleue Couleur Numéro 1258SF28 numéro Démarre Méthodes Démarrer( ) class Voiture { L’instanciation int Couleur; new Voiture ; String Numéro; L’instanciation et la référence public void Démarrer() { Voiture Reference = new Voiture ; ……… } }Permet de manipuler
  • Classes / méthodes / attributs class Voiture { Déclaration des attributs de la classeencapsulation Définition d’une méthode Définition d’une autre méthode }
  • Accès et visibilité class Video { public int NbreVideo ; Accès privé private int TailleVideo ;Accès public public void SelectionVideo (int ){ TailleVideo this.TailleVideo = TailleVideo ; AfficheNomVideo(); } private void AfficheNomVideo ( ) { Accès privé } }
  • Portée des variables, tableau, références, méthodes class ………… { Déclarées dans la classe : accessibles depuis n’importe quelle méthodes de la classe Déclarées en public : accessibles en plus depuis n’importe quel autre objet Déclarées en private : inaccessibles depuis un autre objet on encapsule les données et les méthodes public ou private type Méthode ( int TailleVideo ) { Déclarées dans la méthode : Accessibles que de la méthode } }
  • Variables et méthodes statiquesLes variables et méthodes static sont communes à l’ensembledes instances de la classe. Il est donc inutile d’instancier uneclasse pour accéder à ses membres staticExemple :public static void main ( …) {}
  • constructeurs Il s’agit d’une méthode portant Le même nom que la classe class Voiture { public Voiture ( ) { } }class AutreClasse { A l’instanciation on appelle ( exécute ) Implicitement le constructeur new Voiture ( ) ;}
  • Constructeurs et passage de paramètres class Voiture { String NomMarque; public void Voiture (String Marque ) { this.NomMarque = Marque ; } } class AutreClasse { new Voiture ( Marque) ; }
  • Caractéristiques des constructeurs Un constructeur est toujours public : public nomDeLaClasse ( ) { … } Il ne retourne rien Il peut y avoir plusieurs constructeurs dans une classe . On les distingue alors parleur signature. ex : public Voiture () { ……….} public Voiture ( int a) {…………} public Voiture ( String n, int a) {…….} public Voiture (int a , String n) {…….}
  • Héritage class Vehicule {Vehicule protected int marque; marque protected void Rouler ( ) { …….} Rouler ( ) } Hérite de class Voiture extends Vehicule {Voiture Le mot clé super () : appelle le constructeur super ( ) de la classe de base Rouler ( ); } class AutreObjet { Le constructeur de la classe dérivée est appelé à l’instanciation new Voiture () ; }
  • Les interfaces et classes abstraitesIl s’agit d’une classe ayant au moins une méthode abstraite mot clé abstractUne classe abstraite ne possède pas de définition de méthodeL’instanciation est impossible par l’opérateur newUne classe dérivée doit redéfinir l’ensemble des méthodes abstraites exemple : Dans l’interface mouseListener Les méthodes mousePressed(), mouseClicked(), …. doivent toutes être redéfinies
  • interface Une interface comporte uniquement des méthodes abstraites Une interface n’est pas une classe Une interface ne possède pas de constructeur Une interface s’utilise comme un typeLe mot clé implements permet à une classe d’implémenter une interfaceUne classe peut implémenter ( implements ) plusieurs interfaces et également hériterd’une classe ex : class Bouton implements Runnable, Serialisable extends AppletUne interface peut hériter ( extends ) de plusieurs interfaces
  • Combinaison d’interfacespublic interface Dessinable{ Object public void Dessine () ;} Dessinable déplaçable public class Point implement Dessinable{ public void Dessine () { Papier peint point } public void AutreMethodes () { } }
  • Extension d’interfacepublic interface Dessinable{ Object public void Dessine () ;} Dessinable déplaçable public interface DessinableDeplaçable extends Deplaçable,Dessinable { } Papier peint Dessinabledéplaçable public class Point implement DessinableDeplaçable{ point }
  • Le package AWT// construction d’une frame et d’un boutonimport java.awt.*;public class EssaiFrame { public static void main(String argv[]) { Frame f = new Frame("Fenetre"); //construit une fenêtre invisible Button b = new Button("Push me"); //construit un bouton f.add(b); // place le bouton dans la frame f.pack(); // On ajuste la frame compactage f.show(); // On la rend visible }}
  • // construction d’une frame et d’une boite de dialogue import java.awt.*;public class EssaiDialogue { public static void createDialog(Frame f) { Dialog Dial = new Dialog(f,"boite de dialog",true);// création d’une instance de type// dialog liée à une référenceDial.setLayout(new BorderLayout());// choix de la stratégie de placementDial.add(new Label("Voulez vous sortir"),"North");// création d’une étiquetteDial.add(new Button("OUI"),"West");// ajout d’un premier boutonDial.add(new Button("NON"),"East");// ajout d’un deuxième boutonDial.pack(); Dial.show(); // on compacte et on rend visible } public static void main(String argv[]) { // création d’une instance de type Frame liée à une référence Frame fenetre = new Frame("Fenetre"); Button Bouton = new Button("APPUYER");// création d’une instance de bouton //lié à une référence bout fenetre.add(Bouton); // On place le bouton dans la frame fenetre.pack(); // On compacte la taille de la frame createDialog(fenetre); // création de la boite de dialogue // dans la fenetre fenetre.show(); // ici on laffiche }}
  • Les applets
  • Les événementsQu’est ce qu’un événementL’objet événement :Gestion de l’événement : classe écouteurLe rôle de la méthode add… listener ( )Le modèle de la classe écouteurLes classes d’événementsLes interfaces listener et classes écouteur La marche à suivre
  • Qu’est ce qu’un événementÉvénement : Information externe ou interne permettant d’influer sur le déroulement de l’application Application Événement interne Ouverture ou fermeture de frame Événement externe : Clic de souris Appui sur le clavier Appui sur un bouton ……………………
  • Présentation du déroulementPhase 1 : On provoque l’événement Objet de l’interface Clic de souris Phase 2 : Analyse de l’événement Objet de l’interface Clic de souris Signal reconnu Phase 3 : Association de l’événement à un objet événement EventObject Objet Objet de l’interface événement Clic de souris Signal reconnu
  • Présentation du déroulement Phase 4 : l’objet source délègue la gestion Traite l’événement Objet Ecouteur de l’interface Clic de souris Délègue la gestion Fournit l’événementPhase 5 : On associe l’objet source à l’objet écouteur Objet Ecouteur de l’interface Clic de souris Objet source associé à écouteur Méthode add…Listener( )
  • Classes, classification, packages Classes d’événementsOn doit bien choisir le type d’événement à traiter.Les types d’événement les plus courants sont : Un clic sur un bouton type Button Un clic sur une zone de type Panel, événement MouseEvent La frappe d’une touche du clavier de type KeyEvent Le changement de position du curseur type FocusEvent Les ouvertures / fermetures des objets de fenêtrage type WindowEvent Classification des événements Événements de haut niveau Événements de bas niveau Le package gérant les événements : java.awt.event
  • Les interfaces Interface listener et classe Ecouteur Toutes les classes écouteur hérite d’une interface java prédéfinie Classes d’événement Interface java ActionEvent ActionListener MouseEvent MouseListener KeyEvent KeyListener FocusEvent FocusListener WindowEvent WindowListener Association de l’objet source et de l’objet écouteurSyntaxe : ObjetSource.add Type_Evt Listener ObjetEcouteur ObjetSource : désigne l’objet qui émet l’événement Type_Evt : désigne de façon abrégée le type d’événement Il est accolé à add et à Listener et forme un mot qui désigne une méthode ex: addActionListener, addWindowListener ObjetEcouteur : désigne la référence à l’objet écouteur
  • Démarche à suivreo Choisir le type d’événement à prendre en compte clic sur bouton implique ActionEvento Définir une classe écouteur qui implémente l’interface si ActionEvent l’interface prédéfinie est ActionListener la méthode prédéfinie est actionPerform(e)o Associer l’objet source et l’objet instance de la classe écouteur Si Btn1 est le bouton source et ObjEcout l’objet écouteur l’appel se présente sous la forme : Btn1.addActionListener ( ObjEcout )
  • Exemple d’application à compléter Champ de saisie Saisie d’une chaîne Label AFFICHER QUITTER Frame ButtonOn veut créer une application permettant d’afficher l’interface graphique ci dessus.A partir de cette interface, on doit pouvoir saisir du texte dans un champ de saisieL’appui sur le bouton AFFICHER permet d’afficher la chaîne saisieL’appui sur le bouton QUITTER permet de sortir de l’applicationConstruction de l’application : Ecrire l’objet AppliFrame permettant de créer cet interface graphique Réaliser la gestion des événements des 2 boutons en utilisant les informations précédentes Ecrire le programme principal permettant de créer un instance de l’objet AppliFrame et de l’appeler
  • Exemple de programmationClass fenetre extends Frame {Button BtnCalcul = new Button( QUITTER );………………………………..Delegue1 D1 = new Delegue1(this);BtnCalcul .addActionListener ( d1 );}// Objet ecouteurClass Delegue1 implements ActionListener {// méthode de gestion d’événement public Delegue1 ( fenetre f) { }public void actionPerformed (ActionEvent(e) { System.out.println( « fin par appui sur quitter « ); System.exit(0); // demande de sortie du programme }}
  • Import java.awt.*; Import java.awt.event.*; exempleclass fenetre extends Frame { private TextField Champ1; public fenetre () { Frame Ref = new Frame ( « evenement sur bouton »); Ref.setLayout ( new FlowLayout()); Button BtnQuit = new Button (« Quitter »); Champ1 = new TextField (20); Ref.add ( BtnQuit); Ref.add ( Champ1); ObjetEcouteurB RefEcout = new ObjetEcouteurB ( ); ObjetEcouteurTexte RefTexte = new ObjetEcouteurTexte (Champ1); BtnQuit.addActionListener(RefEcout); Champ1.addActionListener(RefTexte); Ref.show(); }} class ObjetEcouteurTexte implements ActionListener { TextField Champ1; public ObjetEcouteurTexte (TextField Ch1) { Champ1= Ch1; } public void actionPerformed (ActionEvent e ) { Champ1.getText(); } }
  • Import java.awt.*;Import java.awt.event.*; Exemple class fenetre extends Frame { public fenetre () { } }lass ObjetEcouteurB implements ActionListener { c public ObjetEcouteurB() { }² public void actionPerformed (ActionEvent e ) { System.out.println(« quitter »); System.exit(0); } class ObjetEcouteurTexte implements ActionListener { } private TextField Champ1; public ObjetEcouteurTexte (TextField Ch1) { Champ1= Ch1; } public void actionPerformed (ActionEvent e ) { Champ1.getText(); public class Debut { } public static void main ( String Args[] ){ } fenetre Ref = new fenetre(); }}
  • La classe principale // gestion des événements de souris et de bouton import java.awt.*; import java.awt.event.*; public class MonAppli{ public int i=0; public static void main(String argv[]){ Frame f= new Frame(); Button b=new Button("partir"); TextField Champ = new TextField(3); f.setLayout(new FlowLayout()); f.add(b); f.add(Champ); btn bouton= new btn(); b.addActionListener(bouton); clic clic=new clic(); f.addMouseListener(clic); f.setSize(800,600); f.show(); } }
  • class clic implements MouseListener { public int i=0; public void mouseClicked(MouseEvent e){ } Gestion des evt de la souris public void mousePressed(MouseEvent e){ i=i+1; System.out.println(i); } public void mouseReleased(MouseEvent e){ } public void mouseExited(MouseEvent e){ } public void mouseEntered(MouseEvent e){ } }Gestion des evt du bouton class btn implements ActionListener { public void actionPerformed(ActionEvent e){ System.exit(0); } }
  • Les Threads Qu’est ce qu’un threadUn thread est généralement appelé processus léger. Il possède un compteur ordinal, une zone de pile et chaque thread partageavec les autres l’espace d’adressage, un zone commune de données, l’environnement de variables.Cette organisation lui permet de communiquer facilement avec les autres threads de l’application ou de l’applet. Cycle de vie d’un threadUn thread comme un processus possède un cycle de vie bien définit. Il est d’abord inexistant, pour exister il doit être crée, pour vivre être activé. Lors de son déroulement il peut s’interrompre, être mise en attente d’un événement ,d’une demande de réactivation.
  • Les threads Non Crée new MonThread ( ) Crée start( ) Activé yield( ) notify() En En exécution Attente Les états d’un thread Bloquée sur entrée sortie Mise en attente wait() On endort le processus Thread.sleep(30) L’ordonnanceur de threadC’est le chef d’orchestre de l’application. C’est lui qui contrôlel’activation des processus et les mises en attente en fonction despriorités attribuées aux différents Thread Les priorités des processus
  • Les Threads o La classe Thread Cette classe permet de créer des processus et de contrôler leur déroulement Plusieurs constructeurs sont disponibles les méthodes start( ), run(), stop() assurent ce contrôleLa classe Thread définit sept constructeurs associant les paramètres Runnable, String,ThreadGroup• Un objet Runnable dont la méthode run() s’exécutera à l’intérieur du thread.• Un objet String pour identifier le thread.• Un objet ThreadGroup auquel attribuer le thread. La classe ThreadGroup organise lesgroupes de threads liés entre eux.La création d’un processus consiste à créer une instance de Thread et une référence surl’instance.A la création le constructeur de Thread appelle la méthode start() ce qui à pour effet d’activerle Thread. La méthode start() lance ensuite la méthode run() pour l’exécution.La méthode stop( ) a pour effet de l’arrêter Les méthodes de la classe static void yield(); final boolean isAlive(); final void setName(String Nom); final String getName(); public void run();
  • Une première Classe Thread solution Classe Ceci est une classe threadée EnVoiciUneDeThread Dérivée de thread // la classe assurant la gestion du processus ( thread ) class EnVoiciUneDeThread extends Thread { public EnVoiciUneDeThread(String str) { super(str); } public void run() { for (int i=0; i<10; i++) { System.out.println(i+" "+getName()); try { sleep((int)(Math.random()*10)); } catch (InterruptedException e){ } } Classe System.out.println(getName()+" est finie");MesDeuxThreads } } // La classe principale class MesDeuxThreads { public static void main(String args[ ]) { // création d’une instance de thread EnVoiciUneDeThread RefThread1 = new EnVoicUneDeThread("la thread 1"); //lancement de l’exécution du thread RefThread1.start(); // création d’un autre instance de thread EnVoiciUneDeThread RefThread2 = new EnVoicUneDeThread("la thread 1"); //lancement de l’exécution du thread RefThread1.start(); } }
  • Interface RunnableUne deuxième solution Classe // la classe assurant la gestion du processus ( thread ) EnVoiciUneDeThread class EnVoiciUneDeThread implements Runnable { public EnVoiciUneDeThread(String str) { super(str); } public void run() { for (int i=0; i<10; i++) { System.out.println(i+" "+getName()); try { sleep((int)(Math.random()*10)); } catch (InterruptedException e){ } } System.out.println(getName()+" est finie"); } } Classe MesDeuxThreads // La classe principale class MesDeuxThreads { public static void main(String args[ ]) { // création d’une instance de thread EnVoiciUneDeThread RefThread1 = new EnVoicUneDeThread("la thread 1"); //lancement de l’exécution du thread RefThread1.start(); // création d’un autre instance de thread EnVoiciUneDeThread RefThread2 = new EnVoicUneDeThread("la thread 1"); //lancement de l’exécution du thread RefThread1.start(); } }
  • import java.awt.*; Une solution appletimport java.util.*;import java.applet.*;import java.lang.*;public class TestAppletThread extends Applet implements Runnable{ private int VarAffiche; Thread Process1; public void init( ) { setBackground(Color.yellow); } public void start ( ) { Process1= new Thread(this); Process1.start(); } public void stop ( ) { } public void destroy ( ) { } public void run() { // ici on se trouve dans le processus for (int i=0; i<100; i++) { // ici aussi on se trouve dans le processus VarAffiche=1; try { // ici on endort le processus // on attend sur la ligne Thread.sleep VarAffiche=2; Thread.sleep(1000); VarAffiche=3; // à la fin du délai on sort de la ligne Thread.sleep // le processus se réveille } catch (InterruptedException e){ } repaint(); } }