bases se java

LES BASES DU LANGAGE

JAVA


Sommaire

Principes généraux de la syntaxe

Identificateurs et mots clefs

Types primitifs

Types objet

Types tableaux

Allocation de types

Conventions de codage


Qu’est ce que la syntaxe :

�Identificateurs :de constantesde variables, tableaux, …de méthodes, de classes, …

� Principes généraux

�Écriture des lignes de programme :

le point-virgule ;les parenthèses ( )les accolades { }La virgule ,

�Écrire de commentaires

�Mots clés :de variables, tableaux, …de méthodes, de classes, …

La syntaxe : principes


�Écriture des lignes de programme :

le point-virgule :

les parenthèses :

les accolades :

La virgule :

lignes de programme

Une ligne de programme ;Une autre ligne ;Encore une ligne ;

if ( condition dans un test )for ( champ1 ; champ2; champ3 )Methode ( )

{ ………………………….délimite un bloc d’instruction} ………………………….

int ValeurSomme , Moyenne, Total ;Methode( Var1, Var2, Var3 )

Les commentairesLES BASES DU LANGAGE

�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 ligneencore une lignela fin du commentaire */

Les identificateursLES BASES DU LANGAGE

�Rôle d’un identificateur

�Cas des constantes

�Cas des variables, tableaux, référence

�Cas des méthodes

MINIMATOTALTAUX

VoiciUneVariableUnTableau[ ]UnAutreTableau[ ][ ]

AfficherTexte ( )

Les mot-clésLES BASES DU LANGAGE

�Qu’est ce qu’un mot-clé

�Exemple de mot-clé

int float string

AppletRandomdrawRectangle

Les types, variables, commentaires

Les types primitifs

� boolean : true et false� byte : 1 octet� char : 2 octets� short : 2 octets� int : 4 octets� long : 8 octets� float : 4 octets� double : 8 octets

les variables

�Identificateur : nom donné à la variable�Type voir à gauche�Déclaration : partout dans un bloc de programme�Syntaxe de déclaration : type Identificateur ;

Exemple : float Longueur;int Somme, Couleur;

� Affectation Variable1 = expression ;�Conversion de type

exemple : Somme = (int)Longueur ;Les commentaires

// commentaire sur une ligne/* commentaires sur

plusieurs lignes*/

Les tableaux

Les 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 [ ] [ ] ;

� Affectationint [ ] compte = { 1,2,4,78,9, …. };TableauColonnesLignes = new int [20] ;

� Utilisationint Longueur = TableauColonnesLignes.length ;


Convention d’écriture de programme

� Les entêtes de programme

La syntaxe : Conventions

// Entête du programme//……………// ……………

import package.sousPackage. * ;………………

Class nomDeClasse1 {

}

Class nomDeClasse3 {

}

L’entête contient les informationsd’identification ( titre, version, auteur,..), de description ( résumé succinct, …), de protection ( copyright, … )

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 classeutilisées dans le programme

� Les entêtes de classe

� La place des bibliothèques

// Entête de classe

// Entête de classe

� la place des classes

Ma première application

On veut créer une application informatique la plus simple possibleen java qui vous permette d’afficher le message hello worldsurL’é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 ( )


Ma première applicationLES BASES DU LANGAGE

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èquesimport java.lang.* ;

public class MonAppli {// méthode principale de l’application

public static void main( String Arguments[ ]) {system.Out.println ( "Hello World " );

}}

// -------------------------------------------------------------------------------------------------------// Classe de gestion de message// -------------------------------------------------------------------------------------------------------


Modification : Intégration d’une variable

On veut modifier l’application précédentepour pouvoir afficher le même message. La différence consiste à déclarer une variable de type String 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.

Modif : variableLES BASES DU LANGAGE

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èquesimport java.lang.* ;


public static void main( String Arguments[ ]) {String Message= "Hello World ";system.Out.println ( Message );

}}


On veut créer une application informatique en java qui vous permette d’afficher le message hello worldsur 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

MonAppli

main ( )


Modif : création d’une instance

GestionMessage

Afficher ( )


Application : Gestion de message avec création d’une instance


public static void main( String Arguments[ ]) {GestionMessage ref;ref = new GestionMessage ( ) ;ref . Afficher ( );

}}

// -------------------------------------------------------------------------------------------------------// Classe principale de l’application// -------------------------------------------------------------------------------------------------------

Modif : Instance

class TriBulle {public void GestionTri () {

Tri();Afficher();

}private void Tri(){}private void 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

Voiture Reference = new Voiture ;

type

La reference Sur l’objet

Est de

Crée une instance De voiture

Place son adresse dans une reference

On veut créer une application informatique en java qui vous permette d’afficher le message hello worldsur 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

MonAppli

main ( )


Modif : création de 2 instances

GestionMessage

Afficher ( )


Application : Gestion de message avec création de 2 instances


public static void main( String Arguments[ ]) {GestionMessage refObjet1, refObjet2;refObjet1= newGestionMessage ( ) ;refObjet2= newGestionMessage ( ) ;……………….. ;}

}


class GestionMessage {// méthode principale de l’application

public void Afficher () {system.Out.println ( "Hello World " );

}}


Modif : 2 instances

Mon Premier AppletLES BASES DU LANGAGE

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èquesimport java.applet.* ;

import java.awt.*;

class GestionDeMessage extend Applet {// méthode principale de l’application

public void paint( Graphics ref) {ref . drawString( ( "Hello World « ,10,25 );

}}


// --------------------------------------------------------------------

// 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);

}

}

Un autre exemple d’appletLES BASES DU LANGAGE

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( )

MonAppli

main ( )

MoyenneNbreNotesNotesEtudiant[ ]Moyenne

AfficherMoyenne ( )CalculerMoyenne( )SaisirNotes( )GestionCalcul ( )

On donne la représentation graphique du diagrammedes classes de l’application.On demande en utilisant les algorithmes vus en coursde construire les classes MonAppli et Moyenne

Les packages

Les 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

Voiture

AttributsCouleurnuméro

MéthodesDémarrer( )

Une classe

Voiture

Un objetUne instance

Voiture

Couleur : bleueNuméro 1258SF28

Démarre

class Voiture {int Couleur;String Numéro;public void Démarrer() {………}

}

L’instanciationnew Voiture ;

L’instanciation et la référenceVoiture Reference = new Voiture ;

Permet de manipuler

Classes / méthodes / attributs

class Voiture {

}

Déclaration des attributs de la classe

Définition d’une méthode

Définition d’une autre méthode

encapsulation

Accès et visibilité

class Video {

}

public void SelectionVideo (int ) {

= ;

AfficheNomVideo();}

private void AfficheNomVideo ( ) {

}

public int ;

private int ;

this.TailleVideo

TailleVideo

TailleVideo

TailleVideo

NbreVideo

Accès public

Accès privé

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 classeDéclarées en public :

accessibles en plus depuis n’importe quel autre objetDéclarées en private :

inaccessibles depuis un autre objeton encapsule les données et les méthodes

}

public ou private type Méthode ( ) {

}

Déclarées dans la méthode :Accessibles que de la méthode

int TailleVideo

Variables et méthodes statiques

Les 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 static

Exemple :public staticvoid main ( …){

}

constructeurs

class Voiture {

}

public Voiture ( ) {

}

Il s’agit d’une méthode portantLe même nom que la classe

class AutreClasse {

}

A l’instanciation on appelle ( exécute )Implicitement le constructeur

new Voiture ( ) ;

class Voiture {String NomMarque;

}

public void Voiture (String Marque ) {

this.NomMarque = Marque ;}

class AutreClasse {

}

new Voiture ( Marque) ;

Constructeurs et passage de paramètres

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 par leur signature.

ex :public Voiture () { ……….}

public Voiture ( int a) {…………}public Voiture ( String n, int a) {…….}public Voiture (int a , String n) {…….}

Héritage

class Vehicule {protectedint marque;

protected void Rouler ( ) { …….}}

class Voiture extends Vehicule {

}

Voiture

Vehicule

marque

Rouler ( )

Hérite de

super ( )Rouler ( );

class AutreObjet {

}

new Voiture () ;

Le constructeur de la classe dérivée estappelé à l’instanciation

Le mot clé super () :appelle le constructeurde la classe de base

Les interfaces et classes abstraites

Il s’agit d’une classe ayant au moins une méthode abstraite mot clé abstract

Une classe abstraite ne possède pas de définition de méthode

L’instanciation est impossible par l’opérateur new

Une classe dérivée doit redéfinir l’ensemble des méthodes abstraites

exemple : Dans l’interface mouseListenerLes méthodes mousePressed(), mouseClicked(), ….doivent toutes être redéfinies

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 type

Le mot clé implementspermet à une classe d’implémenter une interface

Une classe peut implémenter ( implements) plusieurs interfaces et également hériter d’une classe

ex : class Bouton implementsRunnable, SerialisableextendsApplet

Une interface peut hériter ( extends) de plusieurs interfaces

interface

Combinaison d’interfaces

Dessinable déplaçable

point

public interface Dessinable{public void Dessine () ;

}

public class Point implement Dessinable{public void Dessine () {

}public void AutreMethodes () {

}

}

Papier peint

Object

Dessinable déplaçable

point

public interface Dessinable{public void Dessine () ;

}

public class Point implement DessinableDeplaçable{

}

Papier peint

Object

Dessinabledéplaçable

public interface DessinableDeplaçable extends Deplaçable,Dessinable {

}

Extension d’interface

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 fe nêtre invisibleButton b = new Button("Push me"); //construit un bout on

f.add(b); // place le bouton dans la framef.pack(); // On ajuste la frame compactagef.show(); // On la rend visible

}}

// construction d’une frame et d’une boite de dialogueimport 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 s tratégie de placementDial.add(new Label("Voulez vous sortir"),"North");/ / création d’une étiquette Dial.add(new Button("OUI"),"West");// ajout d’un pr emier boutonDial.add(new Button("NON"),"East");// ajout d’un d euxième bouton

Dial.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 framefenetre.pack(); // On compacte la taille de la fr amecreateDialog(fenetre); // création de la boite de di alogue

// dans la fenetrefenetre.show(); // ici on l'affiche

}}

Les applets

Les événements

Qu’est ce qu’un événement

L’objet événement :

Gestion de l’événement : classe écouteur

Le rôle de la méthode add… listener ( )

Le modèle de la classe écouteur

Les classes d’événements

Les interfaces listener et classes écouteur

La marche à suivre

Application

Événement externe :Clic de sourisAppui sur le clavierAppui sur un bouton……………………

Événement interneOuverture ou fermeturede frame

Événement :Information externe ou interne permettantd’influer sur le déroulement de l’application

Qu’est ce qu’un événement

Clic de souris

Objetde l’interface

Clic de souris


Signalreconnu

Clic de souris


Signalreconnu

Objetévénement

EventObject

�Phase 1 : On provoque l’événement

�Phase 2 : Analyse de l’événement

�Phase 3 : Association de l’événementà un objet événement

Présentation du déroulement

Clic de souris


Clic de souris


Ecouteur

Délègue la gestionFournit l’événement

Traite l’événement

Ecouteur

Objet source associé à écouteurMéthode add…Listener( )

�Phase 4 : l’objet source délègue la gestion

�Phase 5 : On associe l’objet source à l’objet écouteur

Présentation du déroulement

�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

Événements de haut niveau

Événements de bas niveau

�Classification des événements

�Le package gérant les événements : java.awt.event

Classes, classification, packages

�Interface listener et classe Ecouteur

Toutes les classes écouteur hérite d’une interface javaprédéfinie

Classes d’événement Interface javaActionEvent ActionListenerMouseEvent MouseListener

KeyEvent KeyListenerFocusEvent FocusListener

WindowEvent WindowListener

�Association de l’objet source et de l’objet écouteurSyntaxe : ObjetSource.add Type_EvtListener ObjetEcouteur

ObjetSource : désigne l’objet qui émet l’événementType_Evt : désigne de façon abrégée le type d’événement

Il est accolé à add et à Listener et forme un motqui désigne une méthode

ex: addActionListener, addWindowListenerObjetEcouteur : désigne la référence à l’objet écouteur

Les interfaces

o Choisir le type d’événement à prendre en compteclic sur bouton implique ActionEvent

o Définir une classe écouteur qui implémente l’interfacesi ActionEvent l’interface prédéfinie est ActionListenerla méthode prédéfinie est actionPerform(e)

o Associer l’objet source et l’objet instance de la classe écouteurSi Btn1 est le bouton source et ObjEcout l’objet écouteurl’appel se présente sous la forme :

Btn1.addActionListener ( ObjEcout )

Démarche à suivre

AFFICHER QUITTER

Saisie d’une chaîne

Button

Label

Frame

Champ de saisie

On 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’application

Construction de l’application :Ecrire l’objet AppliFrame permettant de créer cet interface graphiqueRéaliser la gestion des événements des 2 boutons en utilisant les informations précédentesEcrire le programme principal permettant de créer un instance de l’objet AppliFrameet de l’appeler

Exemple d’application à compléter

Class fenetre extends Frame {

Button BtnCalcul = new Button( QUITTER );………………………………..Delegue1 D1 = new Delegue1(this);BtnCalcul .addActionListener( d1 );}

// Objet ecouteurClass Delegue1 implementsActionListener {// 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

}}

Exemple de programmation

class 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();

}

}

Import java.awt.*;Import java.awt.event.*;

class ObjetEcouteurTexteimplementsActionListener {

TextField Champ1;

public ObjetEcouteurTexte (TextField Ch1) {

Champ1= Ch1;

}

public void actionPerformed(ActionEvent e ) {

Champ1.getText();

}

}

exemple

class fenetre extends Frame {

public fenetre () {

}

}class ObjetEcouteurBimplementsActionListener {

public ObjetEcouteurB() {

}²


System.out.println(« quitter »);

System.exit(0);

}

}

public class Debut {

public static void main ( String Args[] ){

fenetre Ref = new fenetre();

} }

Import java.awt.*;Import java.awt.event.*;

class ObjetEcouteurTexteimplementsActionListener {

private TextField Champ1;

public ObjetEcouteurTexte (TextField Ch1) {

Champ1= Ch1;

}


Champ1.getText();

}

}

Exemple

// gestion des événements de souris et de boutonimport 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();

}

}

La classe principale

class clic implements MouseListener {

public int i=0;

public void mouseClicked(MouseEvent e){}

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){}

}

class btn implements ActionListener {

public void actionPerformed(ActionEvent e){System.exit(0);}

}

Gestion des evt de la souris

Gestion des evt du bouton

� Qu’est ce qu’un thread

Un thread est généralement appelé processus léger. Il possède un compteur ordinal, une zone de pile et chaque thread partage

avec 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 thread

Un 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

� Les états d’un thread

� L’ordonnanceur de thread

C’est le chef d’orchestre de l’application. C’est lui qui contrôle l’activation des processus et les mises en attente en fonction despriorités attribuées aux différents Thread

� Les priorités des processus

Les threadsNon Crée

Crée

Activé

En Attente

En exécution

new MonThread ( )

start( )

Bloquée sur entrée sortieMise en attente wait()On endort le processus Thread.sleep(30)

yield( )notify()

Les Threads

o La classe Thread

Cette classe permet de créer des processus et de contrôler leur déroulementPlusieurs constructeurs sont disponibles les méthodes start( ), run(), stop() assurent ce contrôle

La 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 les groupes de threads liés entre eux.

La création d’un processus consiste à créer une instance de Thread et une référence sur l’instance.A la création le constructeur de Thread appelle la méthode start() ce qui à pour effet d’activer le 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();

ClasseThread

ClasseEnVoiciUneDeThread

ClasseMesDeuxThreads

Ceci est une classe threadéeDérivée de thread

// La classe principale class MesDeuxThreads {

public static void main(String args[ ]) {

// création d’une instance de threadEnVoiciUneDeThread RefThread1 = new EnVoicUneDeThr ead("la thread 1");

//lancement de l’exécution du threadRefThread1.start();

// création d’un autre instance de threadEnVoiciUneDeThread RefThread2 = new EnVoicUneDeThr ead("la thread 1");


}}

// la classe assurant la gestion du processus ( thr ead )

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){

}}System.out.println(getName()+" est finie");}}

Une première solution

Interface Runnable

ClasseEnVoiciUneDeThread

ClasseMesDeuxThreads

// La classe principale class MesDeuxThreads {

public static void main(String args[ ]) {

// création d’une instance de threadEnVoiciUneDeThread RefThread1 = new EnVoicUneDeThr ead("la thread 1");


// création d’un autre instance de threadEnVoiciUneDeThread RefThread2 = new EnVoicUneDeThr ead("la thread 1");


}}

// la classe assurant la gestion du processus ( thr ead )

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");}}

Une deuxième solution

import java.awt.*;import java.util.*;import java.applet.*;import java.lang.*;public class TestAppletThread extends Applet implem ents 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 processusfor (int i=0; i<100; i++) {

// ici aussi on se trouve dans le processusVarAffiche=1;try {

// ici on endort le processus// on attend sur la ligne Thread.sleepVarAffiche=2;Thread.sleep(1000);VarAffiche=3;// à la fin du délai on sort de la ligne Thread.sl eep// le processus se réveille

}catch (InterruptedException e){}

repaint();}

}

Une solution applet

bases se java

Documents