Ntic.

 
Le concept objet est né il y a environ 20 ans, et mis en oeuvre par le langage de 
programmation SIMULA(Langage de simulation) en Norvège .

La technologie Objet est basée sur trois éléments majeurs : 
      

• Les Objets 

• Les Messages 

• Les Classes 

Introduction aux Objets :
    Le concept objet logiciel est né du besoin de modéliser des objets du monde réel. 
    Un objet est un "paquet" logiciel qui contient une série de procédures 
    et de données reliées. 
    Dans l'approche orientée objet les procédures sont des méthodes 
    et les données des variables ou attributs. 

Représentation commune d'un objet :

Tout objet du mode réel peut être représenter par un objet, qu'il s'agisse d'un objet vivant, 
    ou d'un objet construit.

Par exemple, prenons un véhicule industriel à automatiser.
- Un véhicule possède plusieurs comportements : avancer, reculer, charger des éléments, ...
- Un véhicule possède des caractéristiques propres : Vitesse, poids, taille, résistance, ...

Pour représenter ce véhicule dans l'approche objet :
- Les comportements seront représentés par des méthodes.
- Les caractéristiques seront représentées par des variables.

Exemple

En Conclusion :

 L'on peut dire que chaque objet est un module indépendant, et qu'il est donc possible de définir autant de module que l'on souhaite, ce qui les rends indépendants les uns des autres.

Post Scriptum :

Pourquoi un programme ou un utilisateur sur AS/400 est appelé Objet ?

Sur un objet, le fait que les méthodes soient placées AUTOURS des données, indiquent qu"elles sont là pour protéger les données rendant leur manipulation impossible de l'extérieur, elles sont les seules (les méthodes) habilitées à cette manipulation. On appelle cela l'encapsulation. (regardez une liste de compilation RPG .....).

L'OS/400 est un des seul système d'exploitation à protéger aussi fortement les données qu'il stocke.

Sur la plupart des OS, la notion de type ou d'extension existe, impliquant un comportement de ce dernier, mais avec des OS comme Unix ou Windows, il est possible :

• d'éditer un exécutable ou un profil utilisateur (sur unix)
  sur OS/400, la méthode "open" n'existe pas, sauf sur l'objet fichier (base de données)
  
• de changer l'extension d'un fichier (introduction de virus)
  pas sur OS/400, un fichier ne peut pas devenir un programme, etc..
  
• de créer ses propres extensions (sans traitement particulier associé)
  

Exemple de message entre deux objets: Faire déplacer un véhicule automatique vers un emplacement : 

Emetteur

Véhicule A DéplacerVers Emplacement 12 Objet Méthode Paramètre Message

Récepteur

Dans l'exemple ci-dessus, le récepteur est l'objet véhicule automatique, l'émetteur peut être un objet d'une application X.

Conclusion :

L'approche orientée objet consiste donc en un certain nombre d'objets interagissant entre eux par le biais de messages.

    Un objet peut avoir plusieurs représentations dans une action particulière. 
    Par exemple, il est possible d'avoir plusieurs véhicules automatiques dans une usine. 
    Pour gérer ce genre de situation, il n'est pas pensable de dupliquer en terme de code 
    autant de fois le même objet  que l'on doit avoir de représentations.

    Une classe est un modèle qui définit les méthodes et les variables 
      à inclure dans un type d'objet particulier.
    On ne décrit ces méthodes et ces variables qu'une seule fois. Les objets appartenant 
    à cette classes, que l'on appelle instance de la classes, ne contiennent que 
    des valeurs propres à leurs variables

	Dans cette représentation, trois véhicules automatiques représentent des instances 
    de la classe Véhicule Automatique.
    Chaque véhicule possède ces propres valeurs. Exemple Le premier a une vitesse maxi de 
    20 Km/h le second de 12Km/h ...
    

	Un objet est donc une instance d'une classes donnée. L'ensemble du code 
    est contenu dans la classe. Dans l'approche objet, l'on crée des classes, et ce sont 
    les instances de classes qui sont exécutées. 
    

    L'objectif est de pouvoir définir des classes en fonction de la définition 
    d'autres classes.
    L'héritage est un mécanisme par lequel on définit une classe d'objet comme étant un cas 
    particulier d'une classe plus générale.
    On appelle sous-classes les cas particuliers d'une classe, 
    et super-classe la classe générale de ces cas particuliers.
    

 Exemple 

    Les classes peuvent être imbriquées à l'infini, et l'héritage s'accumule 
        automatiquement. Cette structure est arborescente et s'appelle une 
        hiérarchie de classe. 
    C'est grâce à l'héritage que l'on obtient une réelle "réutilisabilité" du code, 
    une maintenance facilité et surtout une grande évolutivité. Toutes les sous-classes  
    héritent d'une nouvelle fonctionnalité écrite dans la super-classe.

	La surcharge est le mécanisme qui permet d'utiliser le même nom de méthode dans 
    la même classe ou dans desclasses différentes mais liées, pour effectuer 
    des actions différentes.

	Un langage de programmation classique exigerait de donner des noms uniques à toutes 
    les commandes logicielles permettant de dessiner les formes de l'exemple précédent 
    (dessinerCercle, dessinerCarre, ...).
    Dans une approche objet, chaque forme est représentée par une classe différente. 
    Grâce à la surcharge, on pourra utiliser le même nom pour les méthodes permettant 
    de dessiner, à l'intérieur de chacune des classes.

	Il devient donc possible d'avoir un programme générique qui appelle la 
    méthode dessiner quelque soit la forme.
    Ce mécanisme permet donc de mettre au point le programme générique sans connaître 
    la totalité des formes disponibles.

Introduction au Polymorphisme : 
    

	On appelle polymorphisme le fait de dissimuler des procédures différentes 
    derrière la même interface.
    Le polymorphisme caractérise la possibilité de définir plusieurs fonctions de même nom 
    mais possédant des paramètres différents (en nombre et/ou en type), si bien que la bonne 
    fonction sera choisie en fonction de ses paramètres lors de l'appel.
    

	Le polymorphisme rend possible le choix automatique de la bonne méthode  
    à adopter en fonction du type de donnée passée en paramètre.
    

	Exemple : un jeu d'échec comportant des objets fou,
    roi, tour,... 

	La méthode mouvement() pourra, grâce au polymorphisme, effectuer le mouvement approprié 
    le mouvement approprié d'une pièce grâce au type de pièce qui lui sera fourni en paramètre.

Concept avancé : 
    De façon à assurer l'intégrité du fonctionnement d'une classe, d'une méthode ou 
    de la valeur d'une variable,le concept objet permet de spécifier le niveau d'isolement. 
    C'est à dire que l'on peut interdire de modifier une méthode ou une variable , 
    d'appeler une méthode...
    

• Les classes :
• public : Classe accessible par tout les objets
• protected : Classe visible par les objets de son paquetage
• abstract : Classe abstraite ne pouvant être instancié
• final : Classe ne pouvant être super-classe
• Les méthodes :
• Public : Méthode visible par tous les objets
• Private : Méthode non visible par les objets
• Protected : Méthode visible pour une sous-classe mais non modifiable
• Static : Méthode ne pouvant être surchargé
• final : Méthode ne pouvant être surchargée
• Les variables :
• Public : Accessible et modifiable
• Private : non accessible
• Protected : non modifiable
• Static : Constante
• final : Constante

SQL3, dernière norme SQL, introduit de nouveaux concepts :

•  les types de données LARGES ou BLOB: images, video, ...(jusqu'à 2GO sur AS/400)
• les DATALINK (ou URL) [extension DB2 ]
• les fonctions définies par l'utilisateur (UDF)
• les types définis par l'utilisateur (UDT)
  
  

  ils sont créés par : 
                  CREATE DISTINCT TYPE IMAGE AS BLOB(512K)            
                  CREATE DISTINCT TYPE EUROS AS DECIMAL(9, 2)            
                  CREATE DISTINCT TYPE FRANCS AS DECIMAL(9, 2)            
  
  * Oracle admet les types composés (structure)
  
  vous pouvez maintenant créer une table par            
             
                  CREATE TABLE VOITURES            
                         (CODE CHAR(10) NOT NULL PRIMARY KEY,            
                          PRIXf FRANCS NOT NULL, PRIXe EUROS,            
                          PHOTO IMAGE)            
             
              la particularité de ces types est qu'ils sont fortement typés             (considérés comme des objets)
                 c'est à dire que l'on ne PEUT PAS COMPARER DES FRANCS et DES EUROS.            
             
                WHERE PRIXF > PRIXE   est syntaxiquement invalide !!!            
                WHERE PRIXF > 10000 aussi !            
             
             seules des FONCTIONS supportant ces types sont habilitées à les manipuler.            
              on parle alors de SGBDR-OO (ou orientés objet)            
             
             Avec DB2/400 le système assure une convertion avec le type d'origine (CAST ou le-type)  : 
             
              WHERE PRIXF > FRANCS(10000)
             
             pour la comparaison prixe / prixf le plus simple est d'écrire des fonctions            
              une fonction de convertion francs/euros              une fonction de convertion euros/francs            
             
             
              create function af4test/franc_euros (VALEUR FRANCS)   returns EUROS 
                LANGUAGE SQL RETURNS NULL ON NULL INPUT   STATIC DISPATCH            
              
                   BEGIN
                     DECLARE VALEUROS DECIMAL ( 9 , 2 ) ; 
                    SET VALEUROS = CAST(VALEUR as decimal(9,2) ) / 6.55957;  
                    RETURN CAST(VALEUROS as euros); 
                 END; 
           

Déclaration d'une classe : 

    Représentation d'une classe
    

...
poids
vitesseMaxi
puissanceFisc
puissanceDin
...

...
passerVitesse
accelérer
freiner
ouvrir
...

    Syntaxe de la déclaration d'une classe : 
    [<modificateurs d'accès>] class <nom de la classe> [<extends ou implements>] 
    [<nom super-classe ou de l'interface>]
        

Option facultative
mots clés java qui affectent l'accessibilité de
la classe
public : classe visible et modifiable
protected : classe visible non modifiable
private : classe non visible

class

<extends> <nom de la super-classe>

Exemple : Déclaration de la classe voiture
    class Voiture(){}
    
    Toutes les classes héritent automatiquement d'une classe maître  : la classe Object.
    
    

    Représentation des instances de classes

...
poids=1200
puissanceFisc=6
puissanceDin=110
vitesseMaxi=190
vitesseCourante=5
marque="Peugeot"
...

...

...
poids=800
puissanceFisc=4
puissanceDin=60
vitesseMaxi=140
vitesseCourante=4
marque="Renault"
...

...

    Pour créer une instance, il faut utiliser l'opérateur new et un des constructeurs 
      de la classe.
    Exemple : Voiture monAuto = new Voiture();

Destruction d'un objet : 
	La création d'un objet provoque une allocation mémoire. Les langages objets 
	existant avant java (C++,...), obligent le développeur à gérer la mémoire : 
	Allocation, libération.
	La machine virtuelle java gère la mémoire de façon automatique et dynamique. 
	L'utilisation de l'opérateur new provoque une allocation mémoire. 

	Un processus appelé ramasse-miettes (Garbage Collector), s'occupe de 
	libérer la mémoire.
	Tous les objets qui ne sont plus utilisés dans les programmes sont détruits.

      

Cette opération s'effectue à l'aide de l'opérateur ".". Pour accéder à une variable 
    ou une méthode d'un objet,
    il suffit de placer un point (.) entre l'identificateur de l'objet et la variable 
    ou la méthode.
    
    Syntaxe : 
    <nom de l'objet>.<nom de la variable>;
    <nom de l'objet>.<nom de la méthode>([<paramètres>]);
    
	Exemple : 
	Voiture monAuto = new Voiture();
	monAuto.passerVitesse(2);
	System.out.println(monAuto.vitesseCourante);

Attributs et Méthodes d'une classe
	Une classe contient deux types d'éléments : 
		- Des Attributs ( = variables )
		- Des Méthodes ( = procédures ou fonctions)
	
	Les attributs
	Un attribut est une valeur de donnée d'un objet ou d'une classe, qui représente 
	un état de cet objet ou de cette classe.
	On distingue deux types de variables
		- Variables d'instance
		- Variable de classe
	
	Variable d'instance : 
		La valeur d'une variable d'instance n'est connue que de l'instance dans 
		laquelle elle se trouve.
    	Syntaxe : 
    	<modificateur d'accès> <type> <nom de la variable> [= <valeur>];
    	
    	Exemple : 
    	public int vitesseCourante = 0 ;
    	public double vitesseMaxi ;
    	public String marque ;
    	
	Variable de classe : 
		La valeur d'une variable de classe est la même pour toutes les instances 
		de cette classe.
		En clair il s'agit d'une constante.
    	Syntaxe : 
    	static <modificateur d'accès> <type> <nom de la variable> = <valeur> ;
    	
    	Exemple : 
    	static public int nombreDeRoues = 4 ;
    	static public String avertissement = "RESTEZ CONCENTRÉ";
    	

	Les méthodes
	Une méthode représente un comportement de l'objet.
	Les méthodes de notre classe voiture pourraient être
		- passer une vitesse
		- accélérer
		- ralentir
		- freiner
		- démarrer
	
	Il y a deux types de méthodes : 
		- Les procédures : Bloc d'instructions qui ne retourne pas de valeur
		- Les fonctions : Bloc d'instructions qui retourne une valeur
	
	La déclaration de la méthode va définir son rôle : procédure ou fonction
    	Syntaxe d'une procédure: 
    	[<modificateur d'accès>] void <nom de la méthode>([<paramètres>]){
    		<Séquence d'instructions>
    	}
    	
    	Exemple : 
    	public void demarrer(){
    		<séquence instructions>
    	}
    	public void passerVitesse(){
    		int vitesse = vitesseCourante;
    		vitesse++;
    		vitesseCourante = vitesse;
    	}

    	Syntaxe d'une fonction: 
    	<modificateur d'accès> <type de retour> <nom de la méthode>([<paramètres>]){
    		<Séquence d'instructions>
    		return <valeur>
    	}
    	Exemple : 
    	public int prochaineVidange(){
    		int nbVidange = nbKmCourant/nbKmMax;
    		if(nbVidange==0)nbVidange = 1;
    		return (nbKmMax*nbVidange)-nbKmCourant;
    	}
    	
	
    

    Une classe java peut contenir une ou plusieurs méthodes appelées constructeurs. 
    Un constructeur est une méthode appelé par la JVM au 
    moment de l'instanciation de la classe, 
    c'est à dire à l'utilisation de l'opérateur new.
    Cette méthode va permettre notamment d'initialiser les variables.
    La déclaration d'une méthode constructeur ne différe pas d'une méthode classique, 
    mais impose quelques règles.
    	- Le nom du constructeur doit être identique au nom de la classe. 
    		(Respecter la casse)
    	- Un constructeur ne retourne pas de valeur.
    	- Il ne faut pas utiliser le mot clé void qui est implicite.

    Syntaxe d'une fonction: 
    <nom de la classe>([<paramètres>]){
    
    Exemple : 
    	public class Voiture(){
    		public int vitesseCourante = 0;
    		public String marque;
    		
    		Voiture(){}
    		
    		Voiture(String nouvelleMarque){
    		  marque = nouvelleMarque;
    		}
    	}
    	Dans l'exemple, on trouve deux constructeurs. Ces deux constructeurs vont 
    	permettre différentes façons d'instancier la classe voiture.
    	
    	public Voiture auto1 = new Voiture();
    	public Voiture auto2 = new Voiture("Peugeot");
    
Méthode Destructeur ou de finalisation : 
    
    

    De la même façon qu'il existe un type de méthode appelée par la JVM lors de 
    l'instanciation de la classe,il existe une méthode particulière qui est appelée par 
    la JVM lors de la destruction de l'objet, c'est à dire au moment ou le ramasse-miettes 
    détruit l'objet..
    Cette méthode va permettre notamment de libérer toutes les références à 
    d'autres objets .... La méthode s'appelle finalize. 
    Cette méthode est déclarée dans la classe object. Comme toutes les 
    classe héritent de la classe object, il faut redéfinir de façon exact cette méthode : 
    
    protected finalize()throws Throwable{
    }
    
    

    Par convention (et non par obligation!!), les développeurs java s'interdisent 
    d'acccéder directement à un attribut.
    Pour chaque attribut, il est conseillé de définir deux méthodes
    	- La méthode get retourne la valeur de l'attribut.
    	- La méthode set permet d'attribuer une valeur à l'attribut.
    L'intérêt de ces accesseurs résident dans la sécurité. Il devient facile de contrôler 
    la mise à jour des attributs de votre classe de façon à interdire certaine valeur 
    (par l'intermédiare de la méthode set).
    De plus si pour des raisons fonctionnelles, un attribut doit obéir à une règle 
    de gestion avant d' être mise à disposition des autres objets, il vous suffit 
    de modifier la méthode get.
    Il est conseillé de définir les attributs avec le mot clé private et 
    de créer les accesseurs. 
    Exemple : 
    	public Class Voiture(){
    	  private int vitesseCourante = 0;
    	  private String marque;
    	  
    	  public int getVitesseCourante(){
    	  	return vitessCourante;
    	  }

    	  public void setVitesseCourante(int nouvelleVitesse){
    	  	vitessCourante = nouvelleVitesse;
    	  }
    	}
    

La surcharge de méthode consiste à déclarer dans une même classe plusieurs méthodes 
    qui portent le même nom, mais avec des paramètres différents. 
    Le meilleur exemple de surcharge des méthodes, est la déclaration de 
    plusieurs constructeurs. Cela permet, lors de la création de l'instance de pouvoir 
    disposer de méthodes qui vont construire l'objet de manières différentes.

Héritage : 
    L'héritage permet à une classe d'hériter de l'ensemble des méthodes et 
    attributs d'une autre classe sans avoir à réécrire le code de cette classe.
    Une classe héritée est une super-classe, alors qu'une classe qui 
    hérite est appelée sous-classe
    Exemple : 
    
    	- La classe A est la super classe de la classe B et de la classe C
    	- La classe B et C sont des sous-classes de la classe A
    	- La classe D et E sont des sous-classes de la classe B, 
    		qui est elle même une sous-classes de la classe A
    	- La classe A est une sous-classe de la classe Object
    	
    	Syntaxe : 
    	<modificateurs d'accès> class <nom de la classe>() 
    		extends <nom super-classe> {}
	
	Exemple:
	 public class Voiture() extends Vehicule{}

Polymorphisme : 
Le polymorphisme est la possibilité pour deux objets, ayant un lien d'héritage, 
de posséder la même méthode avec des implémentations différentes.
      

    Le mécanisme d'héritage impose à la JVM de remonter la hiérarchie de classe 
    pour trouver les méthodes qui ne sont pas présentes dans la classe en cours. 

Les packages : 
    	Pour faciliter la réutilisation du code existant, Java propose de regrouper 
    	les classes dans des packages.
    	Les classes sont des fichiers, et les packages des répertoires.
    	L'objectif des packages est d'ordonner les classes de façon logique.
    	Exemple par les classe du JDK : 
    		java.io.* : Classes gérant les entrées-sorties
    		java.net.* : Classes gérant les accès réseaux
    		java.util.* : Classes utilitaires
    	
 
    	Quand vous voulez utiliser les fonctionnalités d'une classe dans vos programmes, 
    	il faut indiquer au compilateur java dans quel package se trouve cette classe.
    	Cette opération se fait par le mot clé import.
    	
    	Exemple : 
    	
    	import java.util.*;
    	public class Voiture() extends Véhicule{}
    	
    	Création de ces propres package : 
    	Pour déclarer un package, il suffit d'indiquer le mot clé package avant 
    	de déclarer la classe.
    	
    	Exemple : 
    	
    	package volubis;
    	import java.util.*;
    	public class Voiture() extends Véhicule{}
    	

La modélisation objet consiste à créer une représentation informatique des éléments du monde réel auxquels on s'intéresse, sans se préoccuper de l'implémentation, ce qui signifie indépendamment d'un langage de programmation. Il s'agit donc de déterminer les objets présents et d'isoler leurs données et les fonctions qui les utilisent. Pour cela des méthodes ont été mises au point. Entre 1970 et 1990, de nombreux analystes ont mis au point des approches orientées objets, si bien qu'en 1994 il existait plus de 50 méthodes objet. Toutefois seules 3 méthodes ont véritablement émergées:

• La méthode OMT de Rumbaugh
  La méthode BOOCH'93 de Booch
  La méthode OOSE de Jacobson (Object Oriented Software Engineering)

A partir de 1994, Rumbaugh et Booch (rejoints en 1995 par Jacobson) ont unis leurs efforts pour mettre au point la méthode unifiée (unified method 0.8), incorporant les avantages de chacunes des méthodes précédentes.
La méthode unifiée à partir de la version 1.0 devient UML (Unified Modeling Language), une notation universelle pour la modélisation objet. (ainsi que celles d'autres analystes).

UML 1.0 est soumise à l'OMG (Object Management Group) en janvier 1997, mais elle ne sera acceptée qu'en novembre 1997 dans sa version 1.1, date à partir de laquelle UML devient un standard international.

Modélisation des données : Diagramme de classe

Dans cette partie nous allons présenter les notations de base de la méthode UML :

Note

Une note est un commentaire placé sur un diagramme. Elle est attachée au diagramme plutôt qu'à un élément du modèle (à moins qu'elle ne soit stéréotypée pour être une contrainte - la notion de stéréotype sera présentée plus tard).

Exemple :

Classe

Une classe est le descripteur d'un ensemble d'objets qui ont une structure, un comportement et des relations similaires.

Voici les différentes notations graphiques d'un classe, en fonction du niveau de détail exigé :

Exemple :

Visibilité

Un attribut (ou une opération) est représenté par une chaîne de caractères, qui peut être qualifiée par les différentes propriétés d'un attribut d'élément du modèle.

Voici les différents visibilité d'un élément :

• + Public
• # Protégé
• - Privé

Associations

Les associations binaires sont représentées par des lignes connectant les symboles des classes. Les associations ternaires (et plus) sont représentées par un diamant connecté par des lignes aux symboles des classes.

La terminaison d'une association où elle se connecte à une classe est appelée "rôle d'association".
La plupart de l'information intéressante à propos d'une association, est attachée à ses rôles (entre autres, la cardinalité).

Exemple 1

Exemple 2

Éléments du schéma :

• Nom d'association : "Travaille pour"
• Classe d'association : "Travail"
• Nom des rôles d'association : "Employeur et Employé"
  

Cardinalités

Exemple de cardinalité

• 1
• 0..*
• 1..*
• 0..1
• 2..5
• 1..3,7..10,15,19..*

Quelques commentaires :

• Les intervalles doivent être notés en ordre croissant : "1..3,7,10" est préférable à "7,10,1..3".
• Deux intervalles continus doivent être combinés en un seul intervalle : "0..1" est préférable à "0,1".
• Les notations suivantes sont équivalentes : "*" , "0..* ", "*..*"
  

Contraintes

Une contrainte est une relation sémantique entre des éléments du modèle qui spécifie les conditions et les propositions qui doivent être respectées (sinon le système décrit par le modèle est invalide, avec des conséquences qui sont en-dehors des attributions d'UML). Certains types de contrainte (comme une contrainte d'association "ou") sont prédéfinis dans UML, les autres doivent être définis par les utilisateurs.

Une contrainte est représentée par un texte entre crochets ( {} ). UML ne prescrit pas le langage dans lequel la contrainte doit être écrite.

Exemple 1 :

Exemple 2 :

Les éléments dérivés

Un élément dérivé est un élément qui peut être calculé à partir d'un autre, mais qui est montré pour la clarté, ou qui est inclus pour des raisons de conception même si il n'apporte aucune information sémantique.

Notation

Un élément dérivé est représenter en plaçant un `slash` (/) devant le nom de l'élément dérivé, comme un attribut ou un nom de rôle.

Exemple

Généralisation et Héritage

La généralisation ou héritage est une relation de classification, ordonnée, entre un élément plus général, et un élément plus spécifique qui est pleinement consistante avec le premier élément et qui ajoute des informations supplémentaires, complémentaires.

Comparaison des méthodes de modélisation de donnée

Points communs entre les différentes méthodes

<h3>Liste des cours AF400 (&copy; Volubis)</h3>
<ul>
  <li>&pound;C01.120 <em>(module &pound;cursuspgm)</em> ESPACE ADRESSABLE UNIQUE</li>
  <li>&pound;C01.130 <em>(module &pound;cursuspgm)</em> INIT OS/400 (notion d'objet,  biblioth&egrave;que)</li>
  <li>etc...</li>
</ul>

<!  DOCTYPE AF400 [
        
        <!ELEMENT    COURS   (TEXTE,TYPE,SRCFIL?,SRCLIB?,SRCMBR?,CHEMIN?,SUJET,MOT_DIRECTEUR,DATE) >
        <!ELEMENT    TEXTE     (#PCDATA)
        <!ELEMENT    TYPE       (#PCDATA) >
        <!ELEMENT    SRCFIL   (#PCDATA) >
        <!ELEMENT    SRCLIB    (#PCDATA) >
        <!ELEMENT    SRCMBR (#PCDATA) >
        <!ELEMENT    CHEMIN   (#PCDATA) >
        <!ELEMENT    SUJET   (#PCDATA) >
        <!ELEMENT   MODIRECTEUR   (MOTCLE1,MOTCLE2?,MOTCLE3?,MOTCLE4?,MOTCLE5?) >
        <!ELEMENT    DATE   (#PCDATA) >
 
       <!ELEMENT    MOTCLE1   (#PCDATA) >
       <!ELEMENT    MOTCLE2   (#PCDATA) >
       <!ELEMENT    MOTCLE3   (#PCDATA) >
       <!ELEMENT    MOTCLE4   (#PCDATA) >
       <!ELEMENT    MOTCLE5   (#PCDATA) >

       <!ATTLIST COURS NOM CDATA #REQUIRED>
       <!ATTLIST COURS MODULE CDATA #REQUIRED>
]>

<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 
<xsd:annotation> 
 <xsd:documentation xlm:lang="fr"> 
   XML Schema pour la lsite des cours AF400. 
 </xsd:documentation> 
</xsd:annotation>

<xsd:element name="AF400" type="AF400Type"/> 

<xsd:complexType name="AF400Type"> 
 <xsd:sequence> 
     <xsd:element name="COURS" type="CoursType" minOccurs="1"/> 
 </xsd:sequence> 
</xsd:complexType>

<xsd:complexType name="CoursType"> 
 <xsd:sequence>
     <xsd:element name="TEXTE" type="xsd:string"/>
     <xsd:element name="TYPE" type="xsd:string"/>
     <xsd:element name="SRCFIL" type="xsd:string"/>
     <xsd:element name="SRCLIB" type="xsd:string"/>
     <xsd:element name="SRCMBR" type="xsd:string"/>
     <xsd:element name="CHEMIN" type="xsd:string"/>
     <xsd:element name="SUJET" type="xsd:string"/>
     <xsd:element name="MOT-DIRECTEUR  type="MotType"/>
     <xsd:element name="DATE" type="xsd:string"/> 
 </xsd:sequence> 
< /xsd:complexType>

<xsd:complexType name="MotType"> 
 <xsd:sequence> 
     <xsd:element name="MOTCLE1 type="xsd:string" minOccurs="1"/>
     <xsd:element name="MOTCLE2 type="xsd:string"/>
     <xsd:element name="MOTCLE3 type="xsd:string"/>
     <xsd:element name="MOTCLE4 type="xsd:string"/>
     <xsd:element name="MOTCLE5 type="xsd:string"/>
 </xsd:sequence> 
< /xsd:complexType>

Le standard HTML est un langage SGML (comme UIM sur l'AS/400) qui est interprété complétement par la navigateur sur le poste client:

par exemple

voici un texte en <b>GRAS</b> dont une partie est <font color="#FF0000">
rouge</font><br>(suivi d'un passage &agrave; la ligne)

s'affiche :

voici un texte en GRAS dont une partie est rouge
(suivi d'un passage à la ligne)

Pour Utiliser CGI en RPG, vous disposez des API suivantes (GAP4 Uniquement)

• QtmhGetEnv lire le contenu d'une variable d'environnement
• QtmhRdStin   lire STDIN (le flot en entré)
• QtmhCvtDb découper STDIN suivant le format d'un fichier BD
• QtmhWrStout écrire dans STDOUT (le flot en sortie)
  vous devez gnérer un flot commencant par :
  
  - "content-type : text/html", suivi par du flot HTMLà afficher.
  - "location : http://uuuuuuu", uuuuu étant l'adresse du fichier à afficher (l'url)
  

Net.Data est basé sur la notion de section, une section représenatnt soit un page HTML
(un fichier Net;Data contenant donc plusieurs pages) ou une fonction à exécuter (SQL principalement)

Exemple :

%{================================================================%}
%{=                MACRO NET.DATA                                =%}
%{=                                                              =%}
%{= affichage d'une liste sans sélection (sans page d'appel)     =%}
%{=                                                              =%}
%{= But général : afficher la liste des appellations    (BDVIN1) =%}
%{================================================================%}             

%{****************************************************************%}
%{* SQL1: génère la liste des appellations dans un  tableau HTML *%}
%{****************************************************************%}
%function (DTW_SQL) Fsql1() {

   %{* Requête SQL *%}
   %{*--------------*%}
      select Appellation, Region_code from BDVIN1.Appellations
             order by Appellation
             fetch first 50 rows only

   %{* traitement du résultat *%}
   %{*------------------------*%}
   %report{
     <table border ="1"> 
     <tr> 
     <th><b>Appellation</th>
     <th>Region_code</th>
     </tr>
     {* pour chaque ligne retournée *%}
     %{*-----------------------------*%} 
          %row{
               <tr>
               <td>$(V1)</td>
               <td>$(V2)</td>
               </tr>
          %} 
    </table>
    %}
%}

%{****************************************************************%}
%{*   PAGE1: page HTML liste des appellations (utilise SQL1)     *%}
%{****************************************************************%}
%html (page1) {
  <html>
   <body>
     <p align="center">
     <font size="5" face = "Arial"><b>LISTE des APPELLATIONS<br></b></font>
     </p>
        @Fsql1()
     <BR>
   </body>
 </html>
%}

Affiche la liste des 50 premieres appellations vinicoles, trièes par nom.

• page1 est la page HTML à afficher, (@Fsql1 sera remplacé par le résultat produit, c'est à dire la liste elle même.
• Fsql1 est la fonction SQL, lancant l'ordre Select et mettant en page le résultat.