Plan du polycopié

Planche : 1

• ``Java in a Nutshell'', D. Flanagan, O'Reilly, 1997
  Très bon pour le programmeur C ou C++, JDK 1.1
• ``Java : de l'esprit à la méthode'',
  M. Bonjour, G. Falquet, J. Guyot et A. Le Grand
  Vuibert, 2e édition, 1999.
  Très clair, bonne pédagogie, adapté au JDK 1.2
• ``Just JAVA and Beyond'', P. van der Linden, SUN Press 1998.
  Très bonne présentation avancée, JDK 1.1
• ``Data Structures and Algorithms in Java'', M. T. Goodrich, R. Tamassia, Wiley 1998.
  Algorithmique en Java + un ``Primer'' en annexe, JDK 1.1
• ``Java et Internet'', G. Roussel et E. Duris
  Vuibert, 2000
  Présentation complète de la partie réseau et distribution du langage.

Planche : 2

• contexte d'exécution sur une même machine virtuelle
• même zone mémoire (¹ fork)
• ne dépend pas du système (Windows 3.1)
• possède un nom et une priorité
• pas de préemption à priorité égale
  Þ le faire à la main
  dépend de l'implantation de la JVM
• ne va pas plus vite
• sert à exprimer des algos concurrents

• une thread de plus grande priorité devient ``exécutable'';
• une méthode yield ou sleep est lancée;
• ou que son quota de temps a expiré pour les systèmes implantant un temps partagé.
  

Planche : 3

• sous-classer la classe Thread
  et redéfinir la méthode public void run()
  MCThread x = new MCThread (); x.start();
• Implanter l'interface Runnable
  et implanter public void run
  MCTheadI x = new MCThreadI();
MCThreadI y = new Thread(x,"Nom"); y.start()

class TestThreads {
  public static void main (String []args) {
    MyThread mt1 = new MyThread(1);
    MyThread mt2 = new MyThread(2);
    mt1.setPriority(10);
    mt2.setPriority(10);
    mt1.start();
    mt2.start();
  }
}
class MyThread extends Thread {
  int num;
  int st = 1;
  MyThread(int n) { num = n;} 

  public void run() {
    int i=0;
    while (st < 5000001) {
      if ((st % 1000000) == 0) {System.out.println("MT" + num+ " trace = "+st);}
      st++;
      yield();
    }
  }   
}

Planche : 4

• start() et stop()
• suspend() et resume()
• wait() et notify (synchronisation)
• sleep(i) en millisecondes
• yield()
• join()
• setPriority(i)

• exécutable
• en cours d'exécution
• bloqué
• mort
  

Planche : 5

1. sans relation
2. avec relation mais sans synchronisation
3. relation d'exclusion mutuelle
4. relation d'exclusion mutuelle avec communication

Exemple de deux threads sans relation

public class SR {
  public static void main ( String []s) {
    Thread t1 = new Aff("Bonjour");
    t1.start();
    new Aff("Au revoir").start();
  }
}

class Aff extends Thread {
  String txt;
  Aff (String s){txt=s;}

  public void run () {
    while(true) {
      ES.writeln(txt);
      yield();
    }
  }
}

Planche : 6

Planche : 7

  synchronized (o) { ... }
  }

// ou sur une methode

synchronized type nom_methode( ..) { ...}

Planche : 8

1. appel d'une méthode synchronized
   il garantit qu'une seule méthode ``synchronisée'' peut être appelée sur cet objet
2. bloc synchronized sur un objet
   il verouille l'objet.

Planche : 9

• o.wait() : relache le verrou et attend une notification
• o.notify() : relance une tâche en attente (une au hasard). Elle doit en premier réacquérir le verrou.
• o.notifyAll() : relance toutes les tâches.

Planche : 10

// thread du producteur       // thread consommateur
entree code sync                entree code sync
  while(buffer plein)           while (buffer vide)
    wait()                        wait()
  produit_1()                   consomme_1()
  notify()                      notify()

Exemple : un producteur/consommateur

public class Sync {
  public static void main (String [] args) {
     Producteur p = new Producteur();
     p. start();
     Consommateur c = new Consommateur(p);
     c.start();
  }
}

class Consommateur extends Thread {
  Producteur mien;
  Consommateur(Producteur un){mien=un;}

  public void run() {
    while(true) {
       String r = mien.consomme();
       System.out.println("Consommation : "+r);
       try {sleep((int)(1000*Math.random()));}
       catch (Exception e0) {}
   }
 }
}

class Producteur extends Thread {
  private String [] buffer = new String [8];
  private int ip = 0;
  private  int ic = 0;

  public void run() { 
    while(true) {
      produce();
    }
  }

synchronized void produce() { 
  while (ip-ic+1 > buffer.length) {try{wait();} catch(Exception e) {} }
  buffer[ip % 8] = "Machine "+ip;
  System.out.println("produit : ["+(ip % 8)+"]  "+buffer[ip % 8]);
  ip++;
  notify();
}

synchronized String consomme() { 
   while (ip == ic) {try{wait();} catch(Exception e) {}}
   notify();
   return buffer[ic++%8];
}
}

Planche : 11

• système graphique indépendant d'une plateforme
  Þ avoir les boutons Mac sur MAc, Motif sous Motif, ...
• avoir une API de porgrammation simple (??)
• qui pourra être intégré dans un navigateur.

Planche : 12

Planche : 13

• composants simples : Button, Label, ...
• conteneurs : pouvant recevoir d'autres composants

Planche : 14

• Ceux qui n'ouvrent pas de fenêtres : Panel, Applet
• Ceux qui ouvrent une fenêtre : Dialog, FileDialog et Frame

Exemple de dessin

import java.awt.*;
import java.awt.event.*;

class TestXframeD {
  static public void main(String [] args) {
    XframeD d = new XframeD();
  }
}


class XframeD extends Frame { 

   Canvas p;
   Color c1 = Color.blue;
   Color c2 = Color.red;
   Color c=c1;

 XframeD() {
   super("DESSIN");

   p = new Canvas();
   p.setSize(400,300);
   
   this.setSize(420,320);
   this.add(p);
   this.pack();
   this.show();
 }

  public void paint( Graphics gs) { 
   Graphics g = p.getGraphics();
   if (c.equals(c1)){c=c2;}
   else {c=c1;}
   g.setColor(c);
   g.drawString("Mon dessin",160,40);
   
   for (int i = 0; i< 10; i++) {
     g.fillRect(40+i*20,100,10,10);   
   }
  } 
}

Créer une interface

import java.awt.*;
import java.awt.event.*;

class TestXframe {
  static public void main(String [] args) {
    Xframe e = new Xframe();
    e.init_event();
  }
}

class Xframe extends Frame { 

   String monlogin  ="emmanuel";
   String monpasswd ="pilpoil";
   TextField login;
   TextField passwd;
   Panel p;


 Xframe() {
   super("LOGIN");
   p = new Panel();
   p.setSize(400,500);
   login = new TextField(8);
   passwd = new TextField(8);
   p.add(new Label("Login : "));
   p.add(login);
   p.add(new Label("Password : "));
   passwd.setEchoChar('*');
   p.add(passwd);
   this.add(p);
   this.pack();
   this.show();
 }

  void init_event() { 
  }
} 

Planche : 15

Planche : 16

public <TypeEvt>Listener set<TypeEvt>Listener(
                                 <TypeEvt>Listener monDelegue)
public <TypeEvt>Listener add<TypeEvt>Listener(
                                 <TypeEvt>Listener monDelegue)
public <TypeEvt>Listener remove<TypeEvt>Listener(
                                 <TypeEvt>Listener monDelegue)

Planche : 17

Exemple de délégué

import java.awt.*;
import java.awt.event.*;

class AdaptateurAction implements ActionListener {

  XframeE A;

  AdaptateurAction(XframeE a) {
    A=a;
  }

  public void actionPerformed(ActionEvent e) {
    if ((e.getSource() == A.login) || (e.getSource() == A.passwd))
    { if ((A.login.getText().equals(A.monlogin)) &&
         (A.passwd.getText().equals(A.monpasswd)))
      {A.OK=true; A.good();}
      else {A.nogood();}
    }
  }
}

Exemple d'association de traitement d'événements

import java.awt.*;
import java.awt.event.*;

class TestXframeE {
  static public void main(String [] args) {
    XframeE e = new XframeE();
    e.init_event();
  }
}

class XframeE extends Xframe {

  boolean OK = false;

  void init_event () { 
    AdaptateurAction aa;
    aa = new AdaptateurAction(this);
    login.addActionListener(aa);
    passwd.addActionListener(aa);    
  }

  void good() {
    ES.writeln("C'est parti");
    System.exit(0);
  }

  void nogood() {
    ES.writeln("Essaie encore!!!");
  }
  
}

Planche : 18

Planche : 19

1. nouveau membre (champs) d'une classe
2. à l'intérieur d'un bloc d'instructions

Exemple d'une classe locale

import java.awt.*;
import java.awt.event.*;
import java.applet.*;

class Test3_1 extends Applet {

  class AdaptateurSouris extends MouseAdapter 
    implements MouseListener {
      public void mousePressed (MouseEvent e)
      {
        int x = e.getX();
        int y = e.getY();
        System.out.println("x = " + x + "  y = "+y);
        getGraphics().drawString("salut tout le monde",x,y);
      }
     }

  Test3_1() {
    MouseListener clic = new AdaptateurSouris();

    addMouseListener(clic);
  }

  public void init () {
    this.setBackground(Color.white);
  }
}

Planche : 20

Exemple d'une classe locale anonyme

import java.awt.*;
import java.awt.event.*;
import java.applet.*;

class Test3_2 extends Applet {
  Test3_2() {
    MouseListener clic = new MouseAdapter () {
      public void mousePressed (MouseEvent e)
      {
        int x = e.getX();
        int y = e.getY();
        System.out.println("x = " + x + "  y = "+y);
        getGraphics().drawString("salut tout le monde",x,y);
      }
     };
    addMouseListener(clic);
  }

  public void init () {
    this.setBackground(Color.white);
  }
}

Planche : 21

Planche : 22

• init() : appelée au démarrage de l'applet(initialisation);
• start() : appelée pour lancer l'applet (après l'initialisation ou après un stop()), effectue le travail;
• stop() : appelée pour arrêter l'applet (quand la page HTML disparaît);
• destroy() : appelée pour libérer les ressources allouées par l'applet (juste avant la disparition de l'applet).

Planche : 23

• Ecrire un fichier ``HTML''avec une balise <APPLET>... </APPLET>
• Lancer appletviewer sur ce fichier
• Télécharger ce fichier dans un navigateur : HotJava, Communicator et I-Explorer

Planche : 24

<html>
 <head> Exercices en Java
 </head>
<body>
 <H1> Test </H1>
  <P>
  <applet code="Test1" height=400 width=400>
  <P><EM> Not a java-powered browser! </EM>
  </applet>
</body>
</html>

Applet de dessin

import java.awt.*;
import java.awt.event.*;
import java.applet.*;

public class graf extends Applet { 
 
 
  public void paint(Graphics g) {
    g.drawRect(25,30,60,40);
    g.drawRect(125,30,100,100);

    g.setColor(Color.cyan);
    g.drawOval(25,30,60,40);
    g.drawOval(125,30,100,100); 
  } 

} 

Applet et applications

import java.awt.*;

public class grafa {
  public static void main(String []args) {
    Frame d = new Frame();
    d.setSize(400,300);
    graf g = new graf(); 
    g.setSize(300,200);
    d.add(g);
    d.show();
    g.init();
    g.start();
    d.paint(d.getGraphics());
  }
}

Applet de login

import java.applet.*;
import java.awt.*;
import java.awt.event.*;

public class passwdTest extends Applet {


String monlogin  ="tartempi";
String monpasswd ="itaparit";
TextField login;
TextField passwd;
boolean OK = false;


ActionListener RC = new ActionListener() {
  public void actionPerformed(ActionEvent e) {
    if ((e.getSource() == login) || (e.getSource() == passwd))
    { if ((login.getText().equals(monlogin)) &&
         (passwd.getText().equals(monpasswd)))
      {OK=true; good();}
      else {nogood();}
    }
  }
};

  public void init() {
    login = new TextField(8);
    passwd = new TextField(8);
    add(new Label("Login : "));
    add(login);
    add(new Label("Password : "));
    passwd.setEchoChar('*');
    add(passwd);
    login.addActionListener(RC);
    passwd.addActionListener(RC);
  }

  public void good() {
    resize(120,180);
    this.getGraphics().drawString("c'est parti...",10,150);
  }

  public void nogood() {
    this.getGraphics().drawString("identification incorrecte",10,100);
  }
}

Planche : 25

• lecture/écriture de données
• structures circulaires
• coercion de type à la relecture
• sauvegarde de code

Planche : 26

• classes de flux
  • ObjectOutputStream : flux de sérialisation
  • ObjectInputStream : flux de désérialisation
• interface
  • Serializable : doit être implantée (vide) pour être sérialisé

Planche : 27

• le nom et une clé (checksum) de la classe
• tous les champs (de données) sérialisables

Exemple

import java.io.*;
class Exemple20 implements Serializable   {
  String nom;
  Exemple20 autres;

  Exemple20() {nom=null;autres=null;}
  Exemple20(String n, Exemple20 e) {nom=n;autres=e;}

  boolean estVide() {return (nom == null);}
  void detruit() {nom=null;autres=null;}
  public String toString() { 
    if (estVide()) return "[]";
    else if (autres.estVide()) return nom;
    else return nom+"::"+autres.toString();
  }
  public void ajoute (String unNom) {
    System.out.println("*");
    Exemple20 e = new Exemple20(nom,autres);
    autres=e;
    nom=unNom;
  }
}

class Execute  {
  public static void main (String[] args) {
    Exemple20 e = new Exemple20();
    ObjectOutputStream out;
    ObjectInputStream in;
        
   try {
    e.ajoute("machin");
    e.ajoute("truc");
    System.out.println("1 : "+e);
    out = new ObjectOutputStream(new FileOutputStream("Exemple20.dat"));
    out.writeObject(e);
    out.flush(); out.close();
    e.detruit();
    System.out.println("2 : "+e);
    in = new ObjectInputStream(new FileInputStream("Exemple20.dat"));
    e.ajoute("bidule");
    e.autres = (Exemple20)in.readObject();
    in.close();
    System.out.println("3 : "+e);
    }
    catch (java.lang.ClassNotFoundException exc){System.err.println(exc);}
    catch (StreamCorruptedException exc) {System.err.println(exc);}
    catch (IOException  exc) {System.err.println(exc);}
  }
}

Planche : 28

java Execute

*
*
1 : truc::machin
2 : []
*
3 : bidule::truc::machin

Planche : 29

• classe de bas niveau : pour les couches basses (DatagramPacket,...)
• et de haut niveau : pour les clients/serveurs

Planche : 30

• ServerSocket : méthode accept retourne une socket quand une demande est reçue;
• Socket (classe finale) : pour la communication à travers le réseau. Les méthodes getOutputStream() et getInputStream permettent de récupérer les canaux de communication.
• URL : permet de dialoguer via une URL.

Planche : 31

• Serveur : classe générique (au numéro du port près)
• Connexion : pour les canaux et le traitement

Partie serveur générique

import java.io.*;
import java.net.*;

public class Serveur extends Thread {
  protected static final int PORT =45678;
  protected ServerSocket ecoute;


Serveur ()
{ try
    { ecoute = new ServerSocket(PORT);}
  catch (IOException e)
    {System.err.println(e.getMessage());
     System.exit(1);
    }
  System.out.println(
     "Serveur en ecoute sur le port : "+PORT);
  this.start();
}

public void run ()
{ try
    {while (true)
       {Socket client=ecoute.accept();
        Connexion c = new Connexion (client);}}
  catch (IOException e)
    {System.err.println(e.getMessage());
     System.exit(1);}
}

public static void main (String[] args)
  {new Serveur();}

}

Partie serveur spécifique

class Connexion extends Thread {
  protected Socket client;
  protected DataInputStream in;
  protected PrintStream out;

  public Connexion(Socket client_soc)
  { client=client_soc;
    try
     { in=new DataInputStream(client.getInputStream());
       out=new PrintStream(client.getOutputStream());}
    catch (IOException e)
     {try {client.close();}
      catch (IOException e1){}
      System.err.println(e.getMessage());
      return;}
    this.start();
  }

  public void run()
  { try
      { while (true)
        {String ligne=in.readLine();
         if (ligne.toUpperCase().compareTo("FIN")==0) break;
         System.out.println(ligne.toUpperCase());
         out.println(ligne.toUpperCase());
         out.flush();
        }}
     catch (IOException e)
      {System.out.println("connexion : "+e.toString());}
     finally
      {try {client.close();}  catch (IOException e) {}}

  }

}

Partie client

import java.io.*;
import java.net.*;

public class Client {
  protected static final int PORT=45678;

  public static void main(String[] args)
  {
    Socket s=null;
    if (args.length != 1)
      {System.err.println("Usage: java Client <hote>");
       System.exit(1);}
    try
      { s=new Socket (args[0],PORT);
        DataInputStream canalLecture = 
          new DataInputStream(s.getInputStream());
        DataInputStream console = 
          new DataInputStream (s.getInputStream());
        PrintStream canalEcriture = 
          new PrintStream(s.getOutputStream());
        System.out.println("Connexion etablie : "+
                           s.getInetAddress()+" port : "+s.getPort());
       String ligne = new String();
       char c;
       while (true)
         { System.out.print("?"); System.out.flush();
           ligne = "";
           while ((c=(char)System.in.read()) != '\n') {ligne=ligne+c;}
           canalEcriture.println(ligne);
           canalEcriture.flush();
           ligne=canalLecture.readLine();
           if (ligne == null)
             {System.out.println("Connexion terminee"); break;}
           System.out.println("!"+ligne);
         }
      }
    catch (IOException e) {System.err.println(e);}
    finally
     { try {if (s != null) s.close();}
       catch (IOException e2) {}
     }
  }
}

Planche : 32

[chaillou@ippc56]$ java Serveur
Serveur en ecoute sur le port : 45678
ADIEU
MONDE CRUEL

[chaillou@ippc56]$ java Client ippc56
Connexion etablie : ippc56/134.157.116.56 port : 45678
?adieu
!ADIEU
?monde cruel
!MONDE CRUEL
?fin
Connexion terminee

Planche : 33

• HTTP
• FTP
• SQL serveur

Planche : 34

Planche : 35

• transparence référentielle
• Garbage Collector
• typage des objets copiés
• exceptions distantes

Planche : 36

• objet distant : sur une autre machine virtuelle Java
  
• garde le même modèle objet
• utilisation d'interface étendant Remote
• passage de paramètre et résultat par copie (Serializable)

Planche : 37

                 client              serveur
                   ^                   ^
                   |                   |
                   |                   |
                   |                   |
                   v                   v
            ---------------     ---------------
            |   stub      |     |   skeleton  |
            -----------------------------------
            |      couche des references      |
            -----------------------------------
            |      couche transport           |
            -----------------------------------

Planche : 38

• GC des objets distribués
• réplication d'objets distants
• activation d'objets persistants

Planche : 39

• java.rmi : pour le coté client
• java.rmi.server : pour le coté serveur
• java.rmi.registry : pour l'utilisation d'un service d'enregistrement et de référentiel des objets serveurs,
• tt java.rmi.dgc : pour le GC distribué.

Planche : 40

import java.rmi.*;
public interface PointRMI extends Remote {

  void moveto (int a, int b)    throws RemoteException;

  void rmoveto (int dx, int dy) throws RemoteException;

  void affiche()    throws RemoteException;

  double distance() throws RemoteException;
}

Planche : 41

  import java.rmi.*;
  import java.rmi.server.UnicastRemoteObject;

public class PointD extends UnicastRemoteObject
                    implements PointRMI {

  int x,y;
  PointD(int a, int b) throws RemoteException {x=a;y=b;}
  PointD() throws RemoteException {x=0;y=0;}

  public void moveto (int a, int b)
    throws RemoteException
  { x=a; y=b;}

  public void rmoveto (int dx, int dy)
    throws RemoteException
  { x = x + dx; y = y + dy;}

  public void affiche()
   throws RemoteException
  { System.out.println("(" + x + "," + y + ")");}

  public double distance()
    throws RemoteException
  { return Math.sqrt(x*x+y*y);}
}

Planche : 42

• interface et implantation par : javac
• stubs et skeletons par : rmic de la manière suivante :

Planche : 43

  import java.rmi.*;
  import java.rmi.server.UnicastRemoteObject;

  public class Creation {

    public static void main (String args[]) {

      System.setSecurityManager(new RMISecurityManager());
      try {
        PointD p0 = new PointD();
        PointD p1 = new PointD(3,4);

        Naming.rebind("//youpou.lip6.fr/point0",p0);
        Naming.rebind("//youpou.lip6.fr/point1",p1);
        System.out.println("Objets distribues 'p0' " +
            "et 'p1' sont enregistres");
      }
      catch (Exception e) { e.printStackTrace();
      }
    }
  }

Planche : 44

• le ``security manager'' garantit (??) qu'il n'y aura pas d'opérations illégales.
• l'enregistrement nécessite de nommer chaque instance

Planche : 45

import java.rmi.*;
public class Client {
  public static void main( String argv[]) {
    String url0="rmi://youpou.lip6.fr/point0";
    String url1="rmi://youpou.lip6.fr/point1";
 try {
   PointRMI p0 = (PointRMI)Naming.lookup(url0);
   PointRMI p1 = (PointRMI)Naming.lookup(url1);
   p0.affiche(); p1.affiche();
   p0.rmoveto(7,12);
   p1.rmoveto(5,6);
   p0.affiche();    p1.affiche();
   if (p0.distance() == p1.distance())
     System.out.println("c'est le hasard");
   else
       System.out.println("on pouvait parier");
   }
 catch (Exception e) {
     System.err.println("exception : " +
                         e.getMessage());
     e.printStackTrace();
}  }  }

Planche : 46

(0,0)
(3,4)
(7,12)
(8,10)
on pouvait parier

(7,12)
(8,10)
(14,24)
(13,16)
on pouvait parier

Planche : 47

exception : Connection refused to host;
...

exception : point0
java.rmi.NotBoundException: point0

Planche : 48

rmiregistry 2000&

//youpou.lip6.fr:2000

Planche : 49

• d'être indépendant des langages
• d'avoir des services d'enregistrements plus complets
• de ne pas dépendre d'un constructeur :
  de nombreux ORB, y compris gratuit

Planche : 50

interface Point {
  void moveto(in int a, in int b);
  void rmoveto(in int dx, in int dy);
  void affiche();
  double distance();
}

Planche : 51

• de connaître la classe d'un objet et obtenir la description d'une classe;
• créer des objets sans connaître son nom à l'exécution;
• accéder et modifier les champs de données;
• invoquer une méthode

Planche : 52

• construire de nouvelles classes et des tableaux
• d'accéder et de modifier des champs d'objets existants
• d'invoquer des méthodes de classes ou d'objets
• d'accéder et de modifer des element des tableaux.

• accès de l'extérieur (JavaBeans);
• outils de développement, browser de classes, débogueurs, interprète, décompilateur.

Planche : 53

• java.lang
  • Object
  • Class
• java.reflect
  • Constructor
  • Field
  • Method

Planche : 54

• static Class forName(String)
• Object newInstance()
• Field [] Fields()
• Method [] Methods()

Exemple d'exploration

import java.lang.reflect.*;

public class Lecture {
  public static void main(String args[]) {
    Class c = null;
    Field[] champs = null;
    Method[] methodes = null;

    try {
      c = Class.forName(args[0]);
      champs = c.getDeclaredFields();
      methodes = c.getMethods();
    }
    catch (ClassNotFoundException e) { // ...;
                                       System.exit(0);}
    catch (SecurityException e) { // PB d'autorisation
                                        System.exit(0);}
    
    for (int i=0; i< champs.length;i++) {
      Field uc = champs[i];
      System.out.println("champs "+i+" : "+uc);
    }

    for (int i = 0; i < methodes.length; i++) {
      Method um = methodes[i];
      System.out.println("methodes "+i+ " : " + um);
    }
  }

}

$ java Lecture java.lang.Boolean

champs 0 : public static final java.lang.Boolean java.lang.Boolean.TRUE
champs 1 : public static final java.lang.Boolean java.lang.Boolean.FALSE
champs 2 : public static final java.lang.Class java.lang.Boolean.TYPE
champs 3 : private boolean java.lang.Boolean.value
champs 4 : private static final long java.lang.Boolean.serialVersionUID
methodes 0 : public static java.lang.Boolean java.lang.Boolean.valueOf(java.lang.String)
methodes 1 : public static boolean java.lang.Boolean.getBoolean(java.lang.String)
methodes 2 : public final native java.lang.Class java.lang.Object.getClass()
methodes 3 : public int java.lang.Boolean.hashCode()
methodes 4 : public boolean java.lang.Boolean.equals(java.lang.Object)
methodes 5 : public java.lang.String java.lang.Boolean.toString()
methodes 6 : public final native void java.lang.Object.notify()
methodes 7 : public final native void java.lang.Object.notifyAll()
methodes 8 : public final native void java.lang.Object.wait(long) 
             throws java.lang.InterruptedException
methodes 9 : public final void java.lang.Object.wait(long,int) 
             throws java.lang.InterruptedException
methodes 10 : public final void java.lang.Object.wait() 
              throws java.lang.InterruptedException
methodes 11 : public boolean java.lang.Boolean.booleanValue()

Planche : 55

• classe abstraite java.lang.ClassLoader :
  • charger le byte-code :
    méthode : byte [] loadClassData (String)
  • définir un objet Class à partie de cette suite d'octets :
    méthode : Class defineClass(byte [], int,int)
  • faire l'édition de liens :
    méthode : resolveClass(Class)
• la méthode Class loadClass(String,bool) effectue ces tâches.

     class NetworkClassLoader extend ClassLoader {
         String host;
         int port;
         Hashtable cache = new Hashtable();
         private byte loadClassData(String name)[] {
         // load the class data from the connection
         ...
         }
         public synchronized Class loadClass(String name,
                                             boolean resolve) {
             Class c = cache.get(name);
             if (c == null) {
                 byte data[] = loadClassData(name);
                 c = defineClass(data, 0, data.length);
                 cache.put(name, c);
             }
             if (resolve)
                 resolveClass(c);
             return c;
         }
     }

ClassLoader loader= new NetworkClassLoader(host,port);
Object main= loader.loadClass("Main", true).newInstance();
...

Planche : 56

• Noyau
• implantation
• typage
• bibliothèques
• outils de développement

Planche : 57

Planche : 58

Planche : 59

Planche : 60

bibliothèques et outils de développement

sécurité des applets

portabilité, interopérabilité, efficacité et disponibilité

domaines d'applications

Planche : 61

• tutorial de ClassLoader
  
  
• téléchargement du kit de compatibilité jdk1.1 de Netscape
  
  
• navigateur MMM
  
  
• sécurité des applets O'Caml
  
  
• une comparaison Caml et Java
  
  
• SCOL

Ce document a été traduit de L^AT_EX par H^EV^EA.