SlideShare une entreprise Scribd logo
Télécharger ce document sur http://www.krymo.com




        JAVA

LES 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, commentaires

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

  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 application
On veut créer une application informatique la plus simple possible
en java qui vous permette d’afficher le message hello world sur
L’écran.

Cette application se composera d’une seule classe nommée MonAppli
Et 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 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ée
dans 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 instance
On veut créer une application informatique en java qui vous permette d’afficher le message
hello world sur l’écran.

Cette application se composera de 2 classes l’une nommée MonAppli, l’autre nommée
GestionMessage.
La méthode Afficher permet l’affichage du message dans la fenêtre DOS en utilisant
system.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 instances
On veut créer une application informatique en java qui vous permette d’afficher le message
hello world sur l’écran.

Cette application se composera de 2 classes l’une nommée MonAppli, l’autre nommée
GestionMessage.
La méthode Afficher permet l’affichage du message dans la fenêtre DOS en utilisant
system.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 tests
Les tests :
if (condition ) { inst1; inst2; inst3; }
if ( condition ) { ……} else {….}
if ( condition ) { ……} else if {….} else {….}

La sélection
switch ( valeur ) {
          case 1 : …..;
          case 2 : …..; break;
          case 3 : ……;
          default : ……;

Les itérations
for (int i=0;i<12;++i) {

                     inst1;
                     inst2;
}
La boucle while ( condition ) { ….; …..; …..}
La boucle do { inst1; inst2; …} while (condition);
Application : calcul d’une moyenne
On veut écrire une application permettant de saisir des valeurs entières au clavier et les mémoriser
dans 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éthodes
SaisirMoyenne( ), 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 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
     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 classe


encapsulation



                             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 statiques


Les variables et méthodes static sont communes à l’ensemble
des instances de la classe. Il est donc inutile d’instancier une
classe pour accéder à ses membres static

Exemple :
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 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 {
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 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 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 type




Le mot clé implements permet à 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 implements Runnable, Serialisable extends Applet
Une interface peut hériter ( extends ) de plusieurs interfaces
Combinaison d’interfaces

public 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’interface

public 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 bouton
import 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érence
Dial.setLayout(new BorderLayout());// choix de la stratégie de placement
Dial.add(new Label("Voulez vous sortir"),"North");// création d’une étiquette
Dial.add(new Button("OUI"),"West");// ajout d’un premier bouton
Dial.add(new Button("NON"),"East");// ajout d’un deuxiè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 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 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
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éroulement

Phase 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énement
Phase 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énements
On 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 écouteur
Syntaxe : 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 à suivre

o Choisir le type d’événement à prendre en compte
    clic sur bouton implique ActionEvent
o 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

                                               Button
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 saisie
L’appui sur le bouton AFFICHER permet d’afficher la chaîne saisie
L’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 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 programmation

Class fenetre extends Frame {

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

// Objet ecouteur
Class 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.*;
                                                                                exemple
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();
                 }
}



       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 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
                                   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 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 des
priorité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ô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();
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 Runnable
Une 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 applet
import   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();
                         }
                   }

Contenu connexe

Tendances

Td pascal tdD
Td pascal tdDTd pascal tdD
Td pascal tdD
Chawki Riadh
 
Chap 6 : classes et interfaces
Chap 6 : classes et interfacesChap 6 : classes et interfaces
Chap 6 : classes et interfaces
Aziz Darouichi
 
Cours java script
Cours java scriptCours java script
Cours java script
AdelThaljaoui
 
Le langage C
Le langage CLe langage C
Le langage C
Bruno Delb
 
Chap1: Cours en C++
Chap1: Cours en C++Chap1: Cours en C++
Chap1: Cours en C++
Aziz Darouichi
 
Introduction a la compilation Aperçu de la compilation / Assembleur MIPS - C1
Introduction a la compilation  Aperçu de la compilation / Assembleur MIPS - C1Introduction a la compilation  Aperçu de la compilation / Assembleur MIPS - C1
Introduction a la compilation Aperçu de la compilation / Assembleur MIPS - C1
Beligh HAMDI
 
Java uik-chap3-bases java
Java uik-chap3-bases javaJava uik-chap3-bases java
Java uik-chap3-bases java
Amel Morchdi
 
Chapitre6: Surcharge des opérateurs
Chapitre6:  Surcharge des opérateursChapitre6:  Surcharge des opérateurs
Chapitre6: Surcharge des opérateurs
Aziz Darouichi
 
Initiation à l'algorithmique
Initiation à l'algorithmiqueInitiation à l'algorithmique
Initiation à l'algorithmique
Abdoulaye Dieng
 
cours algorithme et structure de données 1er année
cours algorithme et structure de données 1er annéecours algorithme et structure de données 1er année
cours algorithme et structure de données 1er année
Missaoui Abdelbaki
 
Chapitre1: Langage Python
Chapitre1: Langage PythonChapitre1: Langage Python
Chapitre1: Langage Python
Aziz Darouichi
 
Chapitre2fonctionscppv2019
Chapitre2fonctionscppv2019Chapitre2fonctionscppv2019
Chapitre2fonctionscppv2019
Aziz Darouichi
 
Fascicule tp programmation c
Fascicule tp programmation cFascicule tp programmation c
Fascicule tp programmation c
Missaoui Abdelbaki
 
Langage C
Langage  CLangage  C
Langage C
jwilili
 

Tendances (20)

Td pascal tdD
Td pascal tdDTd pascal tdD
Td pascal tdD
 
Chap 6 : classes et interfaces
Chap 6 : classes et interfacesChap 6 : classes et interfaces
Chap 6 : classes et interfaces
 
Ch13
Ch13Ch13
Ch13
 
Cours compilation
Cours compilationCours compilation
Cours compilation
 
Cours java script
Cours java scriptCours java script
Cours java script
 
Le langage C
Le langage CLe langage C
Le langage C
 
Chap1: Cours en C++
Chap1: Cours en C++Chap1: Cours en C++
Chap1: Cours en C++
 
Introduction a la compilation Aperçu de la compilation / Assembleur MIPS - C1
Introduction a la compilation  Aperçu de la compilation / Assembleur MIPS - C1Introduction a la compilation  Aperçu de la compilation / Assembleur MIPS - C1
Introduction a la compilation Aperçu de la compilation / Assembleur MIPS - C1
 
Java uik-chap3-bases java
Java uik-chap3-bases javaJava uik-chap3-bases java
Java uik-chap3-bases java
 
Algorithme
AlgorithmeAlgorithme
Algorithme
 
Chapitre6: Surcharge des opérateurs
Chapitre6:  Surcharge des opérateursChapitre6:  Surcharge des opérateurs
Chapitre6: Surcharge des opérateurs
 
Initiation à l'algorithmique
Initiation à l'algorithmiqueInitiation à l'algorithmique
Initiation à l'algorithmique
 
cours algorithme et structure de données 1er année
cours algorithme et structure de données 1er annéecours algorithme et structure de données 1er année
cours algorithme et structure de données 1er année
 
Chapitre1: Langage Python
Chapitre1: Langage PythonChapitre1: Langage Python
Chapitre1: Langage Python
 
Cours java
Cours javaCours java
Cours java
 
Chapitre2fonctionscppv2019
Chapitre2fonctionscppv2019Chapitre2fonctionscppv2019
Chapitre2fonctionscppv2019
 
Le langage C
Le langage CLe langage C
Le langage C
 
Polymorphisme
PolymorphismePolymorphisme
Polymorphisme
 
Fascicule tp programmation c
Fascicule tp programmation cFascicule tp programmation c
Fascicule tp programmation c
 
Langage C
Langage  CLangage  C
Langage C
 

En vedette

Initiation aux langages informatiques (1)
Initiation aux langages informatiques (1)Initiation aux langages informatiques (1)
Initiation aux langages informatiques (1)
Pierre Tran
 
Initiation aux langages informatiques
Initiation aux langages informatiquesInitiation aux langages informatiques
Initiation aux langages informatiques
Pierre Tran
 
Les langages de programmation
Les langages de programmationLes langages de programmation
Les langages de programmation
Pierre Tran
 
Les langages de programmation sont trop compliqués
Les langages de programmation sont trop compliquésLes langages de programmation sont trop compliqués
Les langages de programmation sont trop compliqués
mercury_wood
 
Initiation aux langages informatiques (2)
Initiation aux langages informatiques (2)Initiation aux langages informatiques (2)
Initiation aux langages informatiques (2)
Pierre Tran
 
Chap XIII : calcul scientifique avec python
Chap XIII : calcul scientifique avec pythonChap XIII : calcul scientifique avec python
Chap XIII : calcul scientifique avec python
Mohammed TAMALI
 

En vedette (6)

Initiation aux langages informatiques (1)
Initiation aux langages informatiques (1)Initiation aux langages informatiques (1)
Initiation aux langages informatiques (1)
 
Initiation aux langages informatiques
Initiation aux langages informatiquesInitiation aux langages informatiques
Initiation aux langages informatiques
 
Les langages de programmation
Les langages de programmationLes langages de programmation
Les langages de programmation
 
Les langages de programmation sont trop compliqués
Les langages de programmation sont trop compliquésLes langages de programmation sont trop compliqués
Les langages de programmation sont trop compliqués
 
Initiation aux langages informatiques (2)
Initiation aux langages informatiques (2)Initiation aux langages informatiques (2)
Initiation aux langages informatiques (2)
 
Chap XIII : calcul scientifique avec python
Chap XIII : calcul scientifique avec pythonChap XIII : calcul scientifique avec python
Chap XIII : calcul scientifique avec python
 

Similaire à Les bases du langage java

Introduction java
Introduction javaIntroduction java
Introduction java
Fouad Root
 
cours fortran.pptx
cours fortran.pptxcours fortran.pptx
cours fortran.pptx
MED B
 
cours-gratuit.com--system1id048.pdf
cours-gratuit.com--system1id048.pdfcours-gratuit.com--system1id048.pdf
cours-gratuit.com--system1id048.pdf
KamalZeghdar
 
Cours d’approfondissement de LaTeX (intermédiaire-avancé)
Cours d’approfondissement de LaTeX (intermédiaire-avancé)Cours d’approfondissement de LaTeX (intermédiaire-avancé)
Cours d’approfondissement de LaTeX (intermédiaire-avancé)
Adrien Barbaresi
 
01 - Introduction à Python chaines de caractères.pdf
01 - Introduction à Python chaines de caractères.pdf01 - Introduction à Python chaines de caractères.pdf
01 - Introduction à Python chaines de caractères.pdf
MARYAM510573
 
Langage de Programmation.pdf
Langage de Programmation.pdfLangage de Programmation.pdf
Langage de Programmation.pdf
AboubacarDiarra10
 
fortran 2.pdf
fortran 2.pdffortran 2.pdf
fortran 2.pdf
McWalidBensaid
 
C#
C#C#
Ch2-Notions de base & actions élémentaires.pdf
Ch2-Notions de base & actions élémentaires.pdfCh2-Notions de base & actions élémentaires.pdf
Ch2-Notions de base & actions élémentaires.pdf
FadouaBouafifSamoud
 
langage C++
langage C++langage C++
langage C++
mohamednacim
 
intro-csharp developement master 2 IF APP
intro-csharp developement master 2 IF APPintro-csharp developement master 2 IF APP
intro-csharp developement master 2 IF APP
frwebhelp
 
Fiche de TD 1 de préparation probatoire (littéraire et scientifique) du Camer...
Fiche de TD 1 de préparation probatoire (littéraire et scientifique) du Camer...Fiche de TD 1 de préparation probatoire (littéraire et scientifique) du Camer...
Fiche de TD 1 de préparation probatoire (littéraire et scientifique) du Camer...
ATPENSC-Group
 
0002- Introduction au Langage Pascal.ppsx
0002- Introduction au Langage Pascal.ppsx0002- Introduction au Langage Pascal.ppsx
0002- Introduction au Langage Pascal.ppsx
BenacerLeila
 
CPP PTT DE CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
CPP PTT DE CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCPP PTT DE CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
CPP PTT DE CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
SiratiSoufiane
 
compilation1-2020.pdf
compilation1-2020.pdfcompilation1-2020.pdf
compilation1-2020.pdf
aouatifelallaji
 
Algorithmique&Langage C-Partie1 BTS.pptx
Algorithmique&Langage C-Partie1 BTS.pptxAlgorithmique&Langage C-Partie1 BTS.pptx
Algorithmique&Langage C-Partie1 BTS.pptx
Facebokma
 
Java1_BasesLangage.pdf
Java1_BasesLangage.pdfJava1_BasesLangage.pdf
Java1_BasesLangage.pdf
LarbaSAWADOGO2
 
Java1_BasesLangage.pdf
Java1_BasesLangage.pdfJava1_BasesLangage.pdf
Java1_BasesLangage.pdf
LarbaSAWADOGO2
 
Asd
AsdAsd
Ktab asd
Ktab asdKtab asd
Ktab asd
jemaa samir
 

Similaire à Les bases du langage java (20)

Introduction java
Introduction javaIntroduction java
Introduction java
 
cours fortran.pptx
cours fortran.pptxcours fortran.pptx
cours fortran.pptx
 
cours-gratuit.com--system1id048.pdf
cours-gratuit.com--system1id048.pdfcours-gratuit.com--system1id048.pdf
cours-gratuit.com--system1id048.pdf
 
Cours d’approfondissement de LaTeX (intermédiaire-avancé)
Cours d’approfondissement de LaTeX (intermédiaire-avancé)Cours d’approfondissement de LaTeX (intermédiaire-avancé)
Cours d’approfondissement de LaTeX (intermédiaire-avancé)
 
01 - Introduction à Python chaines de caractères.pdf
01 - Introduction à Python chaines de caractères.pdf01 - Introduction à Python chaines de caractères.pdf
01 - Introduction à Python chaines de caractères.pdf
 
Langage de Programmation.pdf
Langage de Programmation.pdfLangage de Programmation.pdf
Langage de Programmation.pdf
 
fortran 2.pdf
fortran 2.pdffortran 2.pdf
fortran 2.pdf
 
C#
C#C#
C#
 
Ch2-Notions de base & actions élémentaires.pdf
Ch2-Notions de base & actions élémentaires.pdfCh2-Notions de base & actions élémentaires.pdf
Ch2-Notions de base & actions élémentaires.pdf
 
langage C++
langage C++langage C++
langage C++
 
intro-csharp developement master 2 IF APP
intro-csharp developement master 2 IF APPintro-csharp developement master 2 IF APP
intro-csharp developement master 2 IF APP
 
Fiche de TD 1 de préparation probatoire (littéraire et scientifique) du Camer...
Fiche de TD 1 de préparation probatoire (littéraire et scientifique) du Camer...Fiche de TD 1 de préparation probatoire (littéraire et scientifique) du Camer...
Fiche de TD 1 de préparation probatoire (littéraire et scientifique) du Camer...
 
0002- Introduction au Langage Pascal.ppsx
0002- Introduction au Langage Pascal.ppsx0002- Introduction au Langage Pascal.ppsx
0002- Introduction au Langage Pascal.ppsx
 
CPP PTT DE CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
CPP PTT DE CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCPP PTT DE CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
CPP PTT DE CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
 
compilation1-2020.pdf
compilation1-2020.pdfcompilation1-2020.pdf
compilation1-2020.pdf
 
Algorithmique&Langage C-Partie1 BTS.pptx
Algorithmique&Langage C-Partie1 BTS.pptxAlgorithmique&Langage C-Partie1 BTS.pptx
Algorithmique&Langage C-Partie1 BTS.pptx
 
Java1_BasesLangage.pdf
Java1_BasesLangage.pdfJava1_BasesLangage.pdf
Java1_BasesLangage.pdf
 
Java1_BasesLangage.pdf
Java1_BasesLangage.pdfJava1_BasesLangage.pdf
Java1_BasesLangage.pdf
 
Asd
AsdAsd
Asd
 
Ktab asd
Ktab asdKtab asd
Ktab asd
 

Plus de krymo

Sql
SqlSql
Sql
krymo
 
Jquery
JqueryJquery
Jquery
krymo
 
Cours javascript
Cours javascriptCours javascript
Cours javascript
krymo
 
Html de base
Html de baseHtml de base
Html de base
krymo
 

Plus de krymo (6)

Sql
SqlSql
Sql
 
Jquery
JqueryJquery
Jquery
 
Cours javascript
Cours javascriptCours javascript
Cours javascript
 
Php
PhpPhp
Php
 
Css
CssCss
Css
 
Html de base
Html de baseHtml de base
Html de base
 

Les bases du langage java

  • 1. Télécharger ce document sur http://www.krymo.com JAVA LES BASES DU LANGAGE
  • 2. 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
  • 3. 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, …
  • 4. 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 )
  • 5. 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 */
  • 6. 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 ( )
  • 7. 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
  • 8. Les types, variables, commentaires Les 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 */
  • 9. 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 [ ] [ ] ; Affectation int [ ] compte = { 1,2,4,78,9, …. }; TableauColonnesLignes = new int [20] ; Utilisation int Longueur = TableauColonnesLignes.length ;
  • 10. 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 { }
  • 11. LES BASES DU LANGAGE Ma première application On veut créer une application informatique la plus simple possible en java qui vous permette d’afficher le message hello world sur L’écran. Cette application se composera d’une seule classe nommée MonAppli Et d’une seule méthode nommée main ( … ) Représentation graphique de l’application MonAppli main ( )
  • 12. 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 " ); } }
  • 13. LES BASES DU LANGAGE 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ée dans la méthode principale.
  • 14. 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 ); } }
  • 15. LES BASES DU LANGAGE Modif : création d’une instance On veut créer une application informatique en java qui vous permette d’afficher le message hello world sur l’écran. Cette application se composera de 2 classes l’une nommée MonAppli, l’autre nommée GestionMessage. La méthode Afficher permet l’affichage du message dans la fenêtre DOS en utilisant system.Out.println ( "Hello World " ); Représentation graphique de l’application GestionMessage Afficher ( ) MonAppli main ( )
  • 16. 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 ( ); } }
  • 17. 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" ); } }
  • 18. POUR i …….. for (int i=0;i<12;++i) { FINi } SI ( condition) if ( Table[i]> Table[i+1]){ FSI }
  • 19. 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
  • 20. LES BASES DU LANGAGE Modif : création de 2 instances On veut créer une application informatique en java qui vous permette d’afficher le message hello world sur l’écran. Cette application se composera de 2 classes l’une nommée MonAppli, l’autre nommée GestionMessage. La méthode Afficher permet l’affichage du message dans la fenêtre DOS en utilisant system.Out.println ( "Hello World " ); Représentation graphique de l’application GestionMessage Afficher ( ) MonAppli main ( )
  • 21. 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 ( ) ; ……………….. ; } }
  • 22. 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 ); } }
  • 23. 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); } }
  • 24. Les itérations et les tests Les tests : if (condition ) { inst1; inst2; inst3; } if ( condition ) { ……} else {….} if ( condition ) { ……} else if {….} else {….} La sélection switch ( valeur ) { case 1 : …..; case 2 : …..; break; case 3 : ……; default : ……; Les itérations for (int i=0;i<12;++i) { inst1; inst2; } La boucle while ( condition ) { ….; …..; …..} La boucle do { inst1; inst2; …} while (condition);
  • 25. Application : calcul d’une moyenne On veut écrire une application permettant de saisir des valeurs entières au clavier et les mémoriser dans 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éthodes SaisirMoyenne( ), 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 ( )
  • 26. 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
  • 27. 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
  • 28. Classes / méthodes / attributs class Voiture { Déclaration des attributs de la classe encapsulation Définition d’une méthode Définition d’une autre méthode }
  • 29. 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é } }
  • 30. 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 } }
  • 31. Variables et méthodes statiques Les variables et méthodes static sont communes à l’ensemble des instances de la classe. Il est donc inutile d’instancier une classe pour accéder à ses membres static Exemple : public static void main ( …) { }
  • 32. 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 ( ) ; }
  • 33. Constructeurs et passage de paramètres class Voiture { String NomMarque; public void Voiture (String Marque ) { this.NomMarque = Marque ; } } class AutreClasse { new Voiture ( Marque) ; }
  • 34. 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) {…….}
  • 35. 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 () ; }
  • 36. 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 mouseListener Les méthodes mousePressed(), mouseClicked(), …. doivent toutes être redéfinies
  • 37. 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 type Le mot clé implements permet à 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 implements Runnable, Serialisable extends Applet Une interface peut hériter ( extends ) de plusieurs interfaces
  • 38. Combinaison d’interfaces public interface Dessinable{ Object public void Dessine () ; } Dessinable déplaçable public class Point implement Dessinable{ public void Dessine () { Papier peint point } public void AutreMethodes () { } }
  • 39. Extension d’interface public 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 }
  • 40. Le package AWT // construction d’une frame et d’un bouton import 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 } }
  • 41. // 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érence Dial.setLayout(new BorderLayout());// choix de la stratégie de placement Dial.add(new Label("Voulez vous sortir"),"North");// création d’une étiquette Dial.add(new Button("OUI"),"West");// ajout d’un premier bouton Dial.add(new Button("NON"),"East");// ajout d’un deuxiè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 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 l'affiche } }
  • 43. 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
  • 44. 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 ……………………
  • 45. Présentation du déroulement Phase 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
  • 46. 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énement Phase 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( )
  • 47. Classes, classification, packages Classes d’événements On 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
  • 48. 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 écouteur Syntaxe : 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
  • 49. Démarche à suivre o Choisir le type d’événement à prendre en compte clic sur bouton implique ActionEvent o 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 )
  • 50. Exemple d’application à compléter Champ de saisie Saisie d’une chaîne Label AFFICHER QUITTER Frame Button 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 saisie L’appui sur le bouton AFFICHER permet d’afficher la chaîne saisie L’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 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
  • 51. Exemple de programmation Class fenetre extends Frame { Button BtnCalcul = new Button( QUITTER ); ……………………………….. Delegue1 D1 = new Delegue1(this); BtnCalcul .addActionListener ( d1 ); } // Objet ecouteur Class 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 } }
  • 52. Import java.awt.*; Import java.awt.event.*; exemple 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(); } } class ObjetEcouteurTexte implements ActionListener { TextField Champ1; public ObjetEcouteurTexte (TextField Ch1) { Champ1= Ch1; } public void actionPerformed (ActionEvent e ) { Champ1.getText(); } }
  • 53. 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(); }}
  • 54. 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(); } }
  • 55. 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); } }
  • 56. Les Threads 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.
  • 57. 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 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 des priorités attribuées aux différents Thread Les priorités des processus
  • 58. 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ô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();
  • 59. 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(); } }
  • 60. Interface Runnable Une 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(); } }
  • 61. import java.awt.*; Une solution applet import 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(); } }