Vous êtes sur la page 1sur 63

Objet?

n Informel
• Entité informatique, logicielle ou matérielle, identifiable
par un nom, une interface, un comportement, etc.
• Exemple: fichier, processus, etc.

Page 1
1
Modèle objet

n Programmation par objets:


• Entité dynamique (≠ module) associant de façon
indissociable les données, correspondant à l'objet
informel, et le code qui manipule et interprète ces
données.
n Boite noire dont les données ne sont ni
visibles, ni modifiables de l'extérieur
n Le client doit utiliser une interface publique
composée par un certain nombre de
procédures (méthodes) exportées par le
code

Page 2
2
Modèle objet - C/S
Client Serveur

method1

method2 Code

...
Données

methodx

Page 3
3
Modèle objet - C/S

n Objet actif versus Serveur

...

Page 4
4
Modèle objet - C/S
Utilisateurs
Clients Partie publique Partie privée
"Cliente" "Serveur"

Identifiant Etat
Objet
Attributs Instance

Interfaces Mise en
des
méthodes
œuvre
des Classe
méthodes

Interface
5

Page 5
5
OO Paradigme
Forever {

readSensors(); Sensor
setHeater();
}

{T°}? -> Heater on/off


Controller

on/off
Heater

Page 6
6
OO Paradigme
Définition des Objets
n Etat = Contenu de l'objet
• L'état comprend toutes les propriétés d'un objet
• Chaque propriété a une valeur.
• Tous les objets de la même "espèce" ont les mêmes
propriétés.
• Les valeurs de ces propriétés peuvent être
différentes.

• Les propriétés sont réalisées par les variables


(attributs) d'objets.

Les objets Sensor ont une propriété température.

Les objets Heater ont une propriété indiquant si ils fonctionnent : on/off.

Les objets Controller possèdent un historique des températures


envoyées par les objets Sensor.

Page 7
7
OO Paradigme
Définition des Objets
n Comportement = Réaction de l'objet
• Changement d'états
• Interaction avec les autres objets

• Définit par les méthodes de l'objet

n Classe = { objets }
• Même propriétés, même comportement

• Déclaration des variables et des méthodes

Les objets Sensor peuvent indiquer la température qu'ils mesurent aux


autres objets.

Les objets Heater peuvent être en marche ou à l'arrêt.

Les objets Controller interprêtent les données envoyées par les objets
Sensor et agissent sur les objets Heater (on/off).

3 classes : Sensor, Heater et Controller.

Page 8
8
OO Paradigme
public class Sensor { public class Controller {
double temperature; Vector history;

public void report() { public void setTemperature(double temp) {


temperature = readHardware(); updateHistory(temp);
controller .setTemperature(temperature); heater.setState(policy ());
} }
}
double readHardware() { … }
}

public class Heater {


boolean operating;

public void printState () { … }

public void setState(boolean op) {


operating = op;
if (operating) {

} else {

}
}
}

Page 9
9
OO Principles
Encapsulation
n Dissocie le comportement d'un objet de sa
réalisation
• Quoi
• Comment

• Personne ne sait comment un objet Sensor acquiert la


temperature, ni comment un objet Heater active le
chauffage

Les objets Sensor peuvent indiquer la température qu'ils mesurent aux


autres objets.

Les objets Heater peuvent être en marche ou à l'arrêt.

Les objets Controller interprêtent les données envoyées par les objets
Sensor et agissent sur les objets Heater (on/off).

3 classes : Sensor, Heater et Controller.

Page 10
10
OO Principles
Héritage/Polymorphisme
n Héritage
• Mécanisme permettant à une classe de redéfinir
(raffiner, spécialiser) le comportement d'une autre
classe.
• La sous-classe est une extension de la super-classe

n Polymorphisme
• On peut utiliser des objets sans connaître leur classe
exacte.
• Il suffit qu'ils possèdent (entre autre) le comportement
que l'on attend.

Les objets Sensor peuvent indiquer la température qu'ils mesurent aux


autres objets.

Les objets Heater peuvent être en marche ou à l'arrêt.

Les objets Controller interprêtent les données envoyées par les objets
Sensor et agissent sur les objets Heater (on/off).

3 classes : Sensor, Heater et Controller.

Page 11
11
Programmation objet
Type, Classe, Objet, etc.
n Type de base:
• Domaine de valeur + opérations
• Exemple: entier, booléens, etc.
n Type abstraits:
• idem → "user defined"

type personne is
nom : string;
insee : string;
age : integer;
end;
type etudiant subtype of personne is
université : string;
numero : integer;
end;

Page 12
12
Programmation objet
Type, Classe, Objet, etc.
n Classe :
• Modèle d'objets (factory)
• Ensemble de variables d'état (attributs)
• description de la réalisation concrète des objets construits à
partir de ce modèle.
• Ensemble d'opérations appelées méthodes
• procédures permettant la consultation et la modification des
variables d'état.
• Les objets sont engendrés à partir d'une classe par le
mécanisme d'instanciation.
• Un exemplaire des variables d'état est créé à chaque
fois qu'une instance de la classe est créé, il représente
l'état de cet objet.
• L'état d'un objet ne peut être manipulé que par le code
de la classe qui lui a servi de modèle.

Page 13
13
Programmation objet
Type, Classe, Objet
n Type :
• Un type définit une interface fonctionnelle commune à un
groupe d'objets.
• Une classe spécifie une réalisation particulière d'un type
donné.
• Plusieurs classes peuvent offrir des réalisations
différentes d'un même type.
• L'ensemble des objets d'un même type peut être
manipulé de manière uniforme quelque soit leurs
classes.

Page 14
14
Programmation objet

n Type Pile
• Opération Push, Pop.
n Classe Pile1
• Implémente le type Pile
• Réalisation à partir d'un tableau
n Classe Pile2
• Implémente le type Pile
• Réalisation à partir d'une liste

Page 15
15
Programmation objet

n Spécialisation : Héritage
• Lorsqu'une classe C1 contient toutes les déclarations et
instructions d'une autre classe C, il est possible de la
spécifier comme une extension de celle-ci ; on dit alors
que C1 est sous-classe de C, ou que C est super-classe
de C1.
• Ce mécanisme permet à une classe de partager les
données et les méthodes de la super-classe dont elle
hérite.
• Une sous-classe réalise une spécialisation de la super-
classe par ajout de ses propres données et méthodes ;
elle peut également redéfinir les méthodes de la super-
classe.
• Définition d'une hiérarchie de classe par le mécanisme
d'héritage.

Page 16
16
Programmation objet
Exemple
n Application bancaire:
• Classe compte:
• attribut solde
• méthodes consulter, créditer et débiter
• débiter vérifie que le solde reste positif.
• Sous-classe compte_avec_découvert:
• idem
+ attribut découvert_autorisé
+ méthodes consulter_découvert_autorisé et
modifier_découvert_autorisé
+ modification (surcharge) de la méthode débiter qui
maintenant vérifie que le solde reste supérieur à la
valeur du découvert autorisé

Page 17
17
Programmation objet
Propriétés
n Modularité et encapsulation:
• L'objet est une notion naturellement modulaire.
• Elle permet d'isoler des comportements, et de dissocier
la spécification de l'interface et sa réalisation.
• Le passage obligé par une interface d'accès permet
• L'évolution transparente de la réalisation
• La protection des données.

è Facilite le développement séparé, et la


réutilisation.

Page 18
18
Programmation objet
Propriétés
n Compatibilité de types, Conformité:
• L'encapsulation permet l'introduction de la notion de
compatibilité de types, vérifiable par la relation de
conformité.
• La relation de conformité d'un type Tb avec un type
Ta, certifie la compatibilité des interfaces des 2
types, et indique qu'une instance du type Tb peut-être
utilisée partout ou une instance du type Ta est
permise.
• Généralement Tb conforme à Ta ssi Tb hérite de Ta.

Page 19
19
Programmation objet
Propriétés
n Polymorphisme:
• Les variables sont typées, elles peuvent donc désignées
des objets de classes différentes (réalisant le même
type, ou des types conformes).
• Le code exécuté dépend de la classe de l'objet sur
lequel la méthode s'applique, ce choix est fait à
l'exécution.
• Exemple:
• Soit une variable de type compte (désignant un
objet de ce type), le code exécuté lors de l'appel
de la méthode débiter dépendra de la classe réelle
de l'objet désigné par la variable à cet instant.

Page 20
20
Programmation objet
Appel de méthode
n Activation, invocation
n Appel de la méthode M sur l'objet O avec
les paramètres p:
• Java : O.M(p)
• C++ : O->M(p)

Page 21
21
Exceptions

n Traitement des situations exceptionnelles


• erreurs: div/0, débordement (aithmétique, tableau,
etc.)
• situations inatendues
n 2 cas :
• Traitement local
• Echappement non local à un bloc de traitement
n Exemple C++, Java:
• mécanisme de transfert dynamique du contrôle vers un
traitant d'exception
• Le traitant définit une portée (try) et attrape (catch)
toute exception levée (throw) dans sa portée.

Page 22
22
public interface Stack { public class ListStack implements Stack {
public void push(Object obj) throws Full; List list;
public Object pop() throws Empty ;
} ListStack() {
list = new List();
}
public class ArrayStack implements Stack {
int free; public void push(Object obj) throws Full {
Object[] array ; list.append( obj);
}
ArrayStack(int size) {
free = 0; public Object pop() throws Empty {
array = new Object [size]; if (! list.empty())
} return list.last();
else
public void push(Object obj) throws Full { throw new Empty();
if (free < array.length) }
array[free++] = obj; }
else
throw new Full();
}

public Object pop() throws Empty {


if (free > 0)
return array[Free--];
else
throw new Empty();
}
}

Page 23
23
public class SuperStack implements Stack {
Stack level1;
Stack level2;

SuperStack() {
level1 = new ListStack();
level2 = new ArrayStack(100);
level1.push(level2);
}

public void push(Object obj) throws Full {


try {
level2.push(obj);
} catch (Full exc) {
level2 = new ArrayStack(100);
level1.push(level2);
level2.push(obj);
}
}

public Object pop() throws Empty {


try {
return level2.pop();
} throw (Empty exc ) {
level2= (Stack) level1.pop();
return level2.pop();
}
}
}

Page 24
24
Exemple2: L'éditeur Graphique

n Objets graphiques de base:


• point, droite, cercle, image, etc.
• fonctions de manipulation: dessin, déplacement, etc.
⇒ Objets Point, Line, Circle, etc.
⇒ Fonctions drawPoint, movePoint, drawLine, etc.
n Objets graphiques composés:
• triangle, rectangle, polygone, etc.
• groupe d'objets
n Objets graphiques génériques
• Manipulation "transparente" des différents types
d'objets.

Page 25
25
Exemple2: L'éditeur Graphique
Approche traditionnelle
typedef enum { typedef struct {
POINT, LINE, CIRCLE, etc. int x, y;
} Gtype; int r;
int couleur;
typedef struct { } Circle;
int x, y;
int color; …
} Point;
typedef struct {
int x1, y1, x2, y2;
int color;
} Line;

Page 26
26
Exemple2: L'éditeur Graphique
Approche traditionnelle
typedef struct { typedef struct {
Gtype type; int nb ;
union { Graphic group [];
Point p; } Group ;
Line l;
Circle c;

};
} Graphic;

Page 27
27
Exemple2: L'éditeur Graphique
Approche traditionnelle
typedef struct { void drawGroup (Graphic g, window w) {
int nb ; for (int i=0; i<g®nb; i++) {
Graphique groupe[]; switch (g→group [i].type) {
} Groupe; case POINT:
drawPoint(g→ group [i].obj, w);
break;
case LINE:
drawLine(g→ group [i].obj, w);
break;
case CIRCLE:
drawCircle(g→group [i].obj, w);
break;

Page 28
28
Exemple2: L'éditeur Graphique
Approche traditionnelle
n Problèmes liés à l'évolution:
• Ajout de types de base:
• Spline, béziers, image (gif, jpeg, etc).
⇒ Modification de Gtype
⇒ Definition des structures et fonctions de manipulation
⇒ Modification du code pour prendre en compte les
nouveaux types

Page 29
29
Exemple2: L'éditeur Graphique
Approche objet
n Définition d'une interface d'objet graphique
générique.
n Chaque classe d'objets graphique implémente
l'interface générique
n Le programmeur ne se soucie plus de la
classe réelle des objets qu'il manipule

Page 30
30
Exemple2: L'éditeur Graphique
Approche objet
interface Graphic { class group implements Graphic {
void draw(window w); int nb ;
void move(window w, int dx, int dy); Graphic group[];
}
class Point implements Graphic { void draw(window w) {
… for (int i=0; i<nb; i++)
} group [i].draw(w);
class Line implements Graphic { }
… …
} }

Polymorphisme ⇒ Choix de la méthode à l'exécution en fonction de la


classe réelle de l'objet

Page 31
31
Java RMI
Remote Method Invocation
n Un RPC objet intégré à Java
• Interaction d'objets situés dans des espaces
d'adressage différents sur des machines distinctes
• Simple à mettre en œuvre : un objet distribué se
manipule comme tout autre objet Java

è Développement de programmes distribués


è Comportement des objets
è Exceptions : quand ? comment ?
è Gestion de la mémoire
è Passage des paramètres, retour des résultats
è etc.

Page 32
32
Objet Local Objet Distant
Définition Un objet local est définit par Le comportement d'un objet
d'objet une classe Java distant est définit par une
interface "Remote"
Implémentation Un objet local est réalisé par Le comportement d'un objet
une classe Java distant est réalisé par une
classe réalisant l'interface
Création Une instance est créée par Création par le serveur, pas
l'opérateur "new" de création par le client
Accès Direct au travers d'une Via une référence sur une
référence d'objet instance proxy Stub
Référence Pointeur sur l'état de l'objet Pointeur sur l'objet proxy
dans la mémoire Stub contenant les
informations permettant la
connexion à l'objet distant
Garbage Lorsque l'objet n'est plus Plus ni références locales, ni
référencé références distantes
Exceptions Système et Application. Le Prise en compte de toutes les
compilateur force la prise de RemoteException's pouvant
toutes les exceptions pouvant être éventuellement générées
être générées.

Page 33
33
Java RMI
Architecture
n Séparation des concepts
• Définition du comportement
Ô Utilisation du service par le client
Ô Codé par une interface Java

• Implémentation de ce comportement
Ô Fourniture du service par le serveur
Ô codé par une classe Java

Page 34
34
Java RMI
Architecture
Programme Client Programme Serveur

Interface RMI Implémentation

! Les interfaces ne contiennent pas de code exécutable

Page 35
35
Java RMI
Architecture
Interface

Programme Client Programme Serveur

Skeleton
Proxy RMI
Implémentation

RMI définit deux classes réalisant la même interface:


• La première classe réalise le service, et elle s'exécute sur le serveur,
• La seconde agit comme un proxy pour le service client, s'exécute sur le serveur.

Page 36
36
Java RMI
Architecture

Objet Client Objet Serveur

Stubs Skeletons

Remote Reference Layer

Transport

Après avoir compris l'architecture globale de RMI, découvrons en les


principaux mécanismes ; La réalisation de RMI est construite autour de
trois couches d'abstractions :
• La première est composée des stubs et skeletons, intercepte les
appels effectués par le client et les redirige vers le service RMI distant.
• La seconde, Remote Reference Layer, interprête les références vers
les services RMI distants. Cette couche connecte l'objet "stub" client à
l'objet "skeleton" exécuté et exporté par le service distant. Il s'agit d'une
connexion Point-à-Point (PTP, ou Unicast).
• La couche de communication est basée sur des connexions TCP/IP.

L'utilisation d'une architecture en couche permet d'améliorer ou de


remplacer chacune d'elles sans affecter le reste du système. Par
exemple, la couche de communication peut-être remplacée par une
réalisation basée sur UDP/IP sans affecter les couches supérieures.

Page 37
37
Java RMI - Architecture
"Stubs" et "Skeletons"
n Proxy Design Pattern
• "Design Pattern", Gamma, Helm, Johnson et Vlissides.

Client
Interface

Proxy Objet réel

• Un objet dans un contexte est représenté par un


autre, le proxy, dans un autre contexte.
• Le proxy transmet (forward) les appels de méthodes
entre les objets participant.

Page 38
38
Java RMI - Architecture
"Stubs" et "Skeletons"
n RMI :
• Stub Ô proxy
• Objet serveur Ô objet réel

• Skeleton
• "helper class" générée pour les besoins de RMI.
• Traduction de la communication avec le stub
Ô Stub serveur

• Seulement avec JDK 1.1, JDK 1.2 utilise la


reflexivité.

Page 39
39
Java RMI - Architecture
Remote Reference Layer
n Définit la sémantique de l'invocation de
méthode sur la couche de transport.

n Fournit l'objet RemoteRef


• méthode invoke( … )

n JDK 1.1
• Unicast, PTP connexion
• Pré-requis : objet serveur instancié et exporté,
éventuellement nommé et enregistré auprès du
"registry" RMI.

Page 40
40
Java RMI - Architecture
Remote Reference Layer
n Java 2
• Support d'objets distants activables
• Objet activable "dormant"
Ô Instanciation de l'objet
Ô Restauration de son état depuis un fihier
Ô Activation
• Autres sémantiques de connexion
• Multicast : Un proxy pourrait émettre une requête
à de multiples objets serveurs et accepter la
première réponse.

Page 41
41
Java RMI - Architecture
Transport Layer
n Gestion de la connexion entre les JVM's
• Basée sur TCP/IP même sur la même machine
• Java Remote Method Protocol (JRMP)
• JDK 1.1 : Utilisation d'objets skeleton
• JDK 1.2 : Optimisée
• JDK 1.3 : Basée sur IIOP de l'OMG
• Internet Inter-ORB Protocol

Page 42
42
Java RMI
Désignation des objets
n Comment un client trouve un objet serveur ?
• Utilisation d'un Naming ou Directory Service
• Cercle vicieux ?
• "well-known host", "well-known port"
• JNDI, RMI Registry

n RMI Registry
• S'exécute sur chaque machine supportant des objets
serveurs
• Port par défaut : 1099
• Noms public Ô URL
• rmi://<hostname>[:<port>]/<service name>

Page 43
43
Java RMI
Fonctionnement

rmiregistry

• •
Ž
Naming Naming
‘ Ž • Œ

server
Client


’ ‘ “ • •
Proxy Skeleton

JVM JVM

Page 44
44
Java RMI
Fonctionnement
n 1 - L'objet serveur s'enregistre auprès du
Naming de sa JVM (méthode bind)
n 2 - Le skeleton (objet proxy serveur) est
créé, il crèe le port de communication et
maintient une référence vers l'objet serveur
n 3 - Le Naming enregistre l'objet serveur,
et le port de communication auprès du
serveur de noms

n L'objet serveur est prêt à répondre à des


requêtes

Page 45
45
Java RMI
Fonctionnement
n 4 - L'objet client fait appel au Naming pour
localiser l'objet serveur (methode lookup)
n 5 - Le Naming récupère les "références"
vers l'objet serveur, ...
n 6 - crèe le Proxy et ...
n 7 - rend sa référence au client
n 8 - Le client effectue l'appel au travers du
Proxy

Page 46
46
Java RMI
Manuel d'utilisation
n Définition de l'interface de l'objet réparti
• interface : "extends java.rmi.Remote"
• methodes : "throws java.rmi.RemoteException"
n Ecrire une implémentation de l'objet
• classe : "extends java.rmi.server.UnicastRemoteObject"
• paramètres sérializable : "implements Serializable"
n Mode d'emploi
• compilation des sources (javac)
• génération des stubs et skeletons (rmic)
• lancement du serveur de noms (rmiregistry)
• lancement du serveur

Page 47
47
Java RMI
Exemple : Interface et Client
package hello; Hello.java

public interface Hello extends java.rmi.Remote {


String sayHello() throws java.rmi .RemoteException;
}

package hello; HelloClnt .java

import java.rmi.*;

public class HelloClnt {


public static void main( String args[]) {
try {
// Récupération d'un proxy sur l'objet.
Hello obj = ( Hello) Naming.lookup("// suldrun /HelloServer ");
// Appel d'une méthode sur l'objet distant.
String msg = obj.sayHello ();
System.out.println(msg );
} catch (Exception exc ) { … }
}
}

Page 48
48
Java RMI
Exemple : Serveur
package hello; HelloServer .java

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

public class HelloImpl extends UnicastRemoteObject implements Hello {


private String msg;
public HelloImpl (String msg) throws java.rmi.RemoteException {
super();
this.msg = msg ;
}

// Implémentation de la méthode distante.


public String sayHello() throws java.rmi .RemoteException {
return "Hello world : " + msg ;
}

Page 49
49
Java RMI
Exemple : Serveur
HelloServer .java

public static void main(String args []) {


// Crée et installe le gestionnaire de sécurité.
System.setSecurityManager(new RMISecurityManager());

try {
// Crée une instance.
HelloImpl obj = new HelloImpl("HelloServer");
// Enregistre l'objet créer auprès du serveur de noms.
Naming.rebind("//suldrun/HelloServer", obj);
System.out. println("HelloServer " + " bound in registry");
} catch (Exception exc) {… }
}
}

Page 50
50
Java RMI
Exemple
# Compilation
cd hello
javac Hello .java HelloImpl .java HelloClnt.java
# Generation des stubs (dans le repertoire ./hello )
cd ..
rmic -d . hello.HelloImpl
# Lancement du serveur de noms
start rmiregistry
# Lancement du serveur d'objets
java hello.HelloImpl

>> HelloServer bound in registry

# Dans une autre fenetre, lancement du client


java hello.HelloClnt

>> Hello world : HelloServer

Page 51
51
Java RMI
Chargement de classe
n RMI permet le passage d'objet par valeur
⇒ Mécanisme de chargement de classe (code)
• Chargement, manipulation de l'objet transmis
• Utilisation d'un serveur web
RMI Registry

Serveur
Client

Web server Web server

Page 52
52
Java RMI
Chargement de classe
n Maintien du lien Objet Ô Classe
• Type et comportement réel de l'objet dans la JVM
distante
n Extension dynamique du comportement
d'une application

n Exemple :
• Un moteur d'exécution de taches.

Page 53
53
Exemple
Définition de l'interface distante
n Spécification des méthodes pouvant être
invoquées par le client
• Détermination des objets utilisés comme paramètre
d'appel ou de retour
compute/Compute.java
package compute;
import java.rmi.Remote;
import java.rmi.RemoteException;
public interface Compute extends Remote {
Object doTask(Task t) throws RemoteException;
}

Page 54
54
Exemple
Définition de l'interface distante
n Définition des interfaces ou des classes
• Type Task utilisé en paramètre de la méthode doTask
de l'interface Compute
• L'interface Task définit l'interface entre le moteur
d'exécution et la tâche à faire, en fournissant le
moyen de démarrer la tâche
compute/Task.java
package compute;
import java.io.Serializable;
public interface Task extends Serializable {
Object execute();
}

Page 55
55
Exemple
engine/ComputeEngine.java
package engine;
import java.rmi.*;
import java.rmi.server.*;
import compute.*;
public class ComputeEngine
extends UnicastRemoteObject
implements Compute {
public ComputeEngine() throws RemoteException {
super();
}
public Object doTask(Task t) {
return t.execute();
}

Page 56
56
Exemple
engine/ComputeEngine.java

public static void main(String args[]) {
try {
Compute engine = new ComputeEngine();
Naming.rebind(name, engine);
System.out.println("ComputeEngine bound");
} catch (Exception exc) {
exc.printStackTrace();
}
}
}

Page 57
57
Exemple
client/ReadDir.java
package client;
import java.rmi.*;
import compute.*;
public class ReadDir {
public static void main(String args[]) {
try {
String name = "//" + args[0] + "/Compute";
Compute engine = (Compute) Naming.lookup(name);
Dir task = new Dir(args[1]);
String dir = (String) engine.doTask(task);
System.out.println("//" + args[0] + "/" + args[1]);
System.out.println(dir);
} catch (Exception exc) {
exc.printStackTrace();
}
}
}

Page 58
58
Exemple
client/Dir.java
package client;
import compute.*;
public class Dir implements Task {
String path;
public Dir(String path) {
this.path = path;
}
public Object execute() {
return readDir(path);
}

Page 59
59
Exemple
client/Dir.java

String readDir(String path) {
try {
File dir = new File(path);
} catch (Exception exc) {
exc.printStackTrace();
}
}
}

Page 60
60
Exemple
RMI Registry
Client

ReadDir Serveur

ComputeEngine

Dir Dir

Web server Web server

Page 61
61
Java RMI
Passage d'objets par copie

Obj2 Obj2<copy>

Obj1 .method( Obj2 ) Obj1


method( Obj2 )

Obj1<stub> Obj1<skeleton>
Java VM Java VM

Page 62
62
Java RMI
Passage d'objets par référence
Obj2

Stub: Obj2 Stub_Obj2

Obj1 .method( Obj2 ) Obj1


method( Obj2 )

Obj1<stub> Obj1< Skeleton>


Java VM Java VM

Page 63
63