pause-café
rendez-vous technique
Pause-Café est une réunion technique
destinée aux informaticiens sur plateforme IBM i.
destinée aux informaticiens sur plateforme IBM i.
Elle a lieu 3 à 4 fois par an : en Bretagne et sur internet.
Pause-café #13
Octobre 1997
Les grandes nouveautés de la V4 sont liées au serveur WEB et à la sécurité 1/ ICS, serveur WEB. le serveur WEB (HTTP) de l'AS/400 est renommé ICS : Internet Connection Server, il est toujours gratuit Il est livré avec un programme HTML.CGI d'administration, ce qui permet la configuration à partir d'un navigateur. il intègre de nouvelles directives et un nouvel objet *VLDL permettant de stocker une liste d'utilisateurs autorisés ainsi qu'une clé associée (mot de passe) il ne s'agit PAS d'utilisateurs au sens OS/400 mais plutôt d'utilisateurs Internet.
dans les directives HTTP nous allons pouvoir écrire :
ici mesdocuments-sec est le nom de la directive de protection
(comme on écrirait un nom de sous programme)
puis on associe cette directive à un ou plusieurs répertoires
Protection mesdocuments-sec {
ServerID s44r7480
PasswFile qgpl/motdepas
AuthType Basic
Mask All@*
Userid webdoc
}
.../...
Protect /mesdocuments/* mesdocuments-sec
pass /mesdocuments/* /html/doc/*
ServerID : nom du serveur dans la fenêtre d'authentification passwFile : %%QPGMR%% indique qu'il s'agit d'un profil OS/400 (ici Qpgmr) un-nom fait référence à un objet *VLDL il existe deux cdes CRTVLDL et DLTVLDL plus des APIs une liste de validation contient une série de profils avec le mot de passe associé encrypté. - ce ne sont pas forcément des profils OS/400 - grace aux APIs c'est utilisables par les applications AuthType : pour l'instant Basic est la seule valeur admise Mask : à gauche du @ indique All ou un groupe d'utilisateurs à droite * ou une série d'adresses IP UserID : indique sous quel profil OS/400 le job va s'exécuter.
Exemple avec un groupe d'utilisateurs
il faut créer un fichier des groupes (ASCII dans IFS)
grp1 : user1,user2,user3
grp2 : user4,user5,user6 ............................
: :
puis on associe écrit : seules les adresses IP :
: 10.2 ety 10.3 sont :
Protection mesdocuments-sec { : autorisées. :
ServerID s44r7480 : :
PasswFile qgpl/motdepas : pour une adresse 10.3 :
GroupFile /web/grp/ficgroupe.GRP : l'utilisateur doit :
AuthType Basic : faire partie du groupe :
Mask grp1@10.3.*,grp2@10.2.*<---: grp1, pour 10.2 du :
Userid qpgmr : groupe grp2. :
} : :
:..........................:
.../...
Protect /mesdocuments/* mesdocuments-sec
pass /mesdocuments/* /html/doc/*
2/5769 NC1 : ICSS serveur WEB facturable (on parle de 2000 Fr) intégrant la technologie SSL (Secure Socket Layer) version 3. le dialogue sur le WEB est alors crypté (le serveur est déclaré certifié) et interdit le "snuffing" = écoute de la ligne. 3/ Un dispositif à base de serveur de fichier intégré (ex FSIOP) et de logiciel (5769 FW1) permet de monter un FIREWALL sur AS/400. Rappel sur la notion de FIREWALL : il s'agit d'une machine dite "BASTION", car elle est la seule exposée aux risques de l'internet (ce qui explique le FSIOP) sur cette machine on installe un PROXY (soft effectuant les requêtes sur le WEB sous son adresse IP pour le compte de ses clients) ==> sécurité en sortie. plus un filtrage IP indiquant quelles adresses IP peuvent entrer et pour quelle application (port TCP) ==> sécurité en entrée.
4/ de nouveaux outils TCP/IP, mais déja disponibles via PTF pour le support de la NetworkStation : - BOOTP = attribution d'une adresse IP fonction de l'adresse carte(MAC) - TFTP = Trivial FTP, Plus léger que FTP peut fonctionner sans mot de passe - REXEC = Remote EXEC, l'AS/400 serveur de commande TCP/IP de nouveaux points d'exit sont associés à ces outils Et enfin on annonce des modèles pour faire du commerce en ligne NET.COMMERCE, pour en savoir plus visitez le site http://www.internet.ibm.com/commercepoint/net.commerce
Voici les principales annonces concernant la base de données DB2/400 V4. Elles vont toutes vers plus de conformité au standard SQL. - Sécurité (droits) à la colonne : ...................................................................... : Grant Select, : : update(notel, adr1, adr2) : : on table personp1 : : to pdupont; : :....................................................................: ici on accorde le droit de lecture (toutes colonnes) et le droit de modifier les colonnes N° de tel et adresses à PDupont. les commandes DSPOBJAUT et EDTOBJAUT montrerons les autorisations de niveau zone, mais ne permetterons pas la modification. les droits seront vérifiés aussi bien en SQL qu'en RPG/COBOL
- Check Contraints ou contraintes de domaine : il s'agit d'établir un contrôle sur une zone (doit être > à , <> de ...) devant être TOUJOURS vérifié. les contrôles demandés aujourd'hui (CHEKC, RANGE, VALUES) ne sont vérifiés que dans un monde transactionnel (gestionnaire écran) les nouvelles contraintes seront vérifiés dans toutes les conditions ............................................................ : ADDPFCST FILE(PERSONP1) TYPE(*CHKCST) CST(SALAIRE_CST) : : CHKCST(Salair > 6663,67 and prime < salair) : :..........................................................: en SQL ............................................................ : Alter table PERSONP1 add constraint SALAIRE_CST : : Check (Salair > 6663,67 and prime < salair) : :..........................................................:
- Procédures cataloguées écrites en SQL : Aujourd'hui les procédures cataloguées sont écrites en RPG/COBOL et enregistrées en SQL par CREATE PROCEDURE ......................................................................... : Create Procedure bib/p1 : : (in nomatin DEC(6, 0), : : in newcoef DEC(3, 0), : : out codert int) : : language SQL : : P1: : : Begin : : Declare coeflu DEC(3, 0); : : Declare Exit handler for SQLExecption Set codert=SQLCODE; : : Select coef from personp1 into coeflu where nomat = nomatin; : : if newcoef > coeflu then : : update personp1 set coef = newcoef : : where nomat = nomatin; : : end if; : : End : :.......................................................................:
- SQl atomique il s'agit d'une série d'ordres SQL devant être considérés comme un tout (donc transmis ensembles si vous travaillez en Client/Serveur) ......................................................... : Begin Atomic : : Update fichier1 : : SET ... where ... : : Update fichier2 : : SET ... where ... : : End : :.......................................................: - Expressions conditionnelles un expression en SQL représente un traitement sur une plusieurs zones (concaténation/extraction, calcul, ...) il s'agit ici, de pouvoir donner des conditions à ces traitements :
................................................................... : Select cours, texte, case dispo : : when 1 then 'lecture' : : when 2 then 'Impression' : : when 3 then 'Les deux' : : end AS Disponible : : from AF4MBRP1 : :.................................................................: ........................................................................... : Select noart, qtecde, puart, case : : when codepays <> 'F' then puart : : when dep = 97 then puart *1,09 : : else puart *1,206 : : end as TTC : : from cdecli : :.........................................................................: - CAST = fonction de changement de type CAST(expression as type(lg))
- valeur par défaut : a/ Default user = la valeur par défaut est le profil en cours ....................................................................... : Create table histo (quand DATE not null with default, : : qui CHAR(10) not null with default user) : :.....................................................................: b/ mot-clé default dans les ordres INSERT et UPDATE ....................................................................... : Insert into HISTO (quand, qui) : : values(current date, default) : :.....................................................................: - réseau DRDA et DDM annoncés sur TCP/IP JDBC avec le support de JAVA sur l'AS/400
- disponibilité SAVE WHILE ACTIVE ammélioré Support maintenant des commandes CLRPFM, RMVM, ... pendant une sauvegarde. remote journaling Il sera possible de déclarer un récepteur de journal DISTANT facilitant ainsi les solutions de BACKUP - performmances Construction des indexs en parallèlle (intégré au produit sous licence DB2 Symmetric Multiprocessing) Utilisation de plusieurs indexs par fichier afin de mieux traiter les sélections complèxes basées sur des ET et des OU.
les seuls éléments disponibles dès la V4R10 sont :
Save WHile Active ammélioré
et la construction d'indexs en parallelle
les autres dispositifs sont annoncés :
"Future V4 Release"
* JAVA * HTML = Hypertexte Markup Language - langage constitué de "tags" (comme UIM dont il est trés proche), chaque marque (tag) définit : . la présentation (centré, soulignement,..) . les liens hypertexte . la référence à des images (GIF, JPEG) ou à des fichiers sons . les zones de saisies, boutons poussoirs etc... exemple : <HTML> <HEADER> <TITLE>VOLUBIS Conseil et formation sur AS/400</TITLE> </HEADER> <H1>VOLUBIS : Conseil et formation sur AS/400</H1> <hr> <br><IMG ALIGN=middle SRC="file://localhost/d:/internet/volubis/doc.jpg"> <H3>Formez vous à la version 3.70 .</H3> Quelques sites du monde AS/400 <UL> <LI><A HREF="http://www.as400.ibm.com">IBM Rochester</A><P> <LI><A HREF="http://www.news400.com">NEWS/400 Magazine</A><P>
Pour le client :
- l'affichage des images est par défaut immédiat.
- cliquer sur un lien hypertexte établit une nouvelle connexion vers
le serveur référencé.
- remplir une zone de saisie ou utiliser un bouton rend la main au serveur.
Celui-ci doit alors appeler un programme chargé de récuperer la saisie,
de la traiter et de constituer dynamiquement la page HTML constituant
le résultat.
Le standard de récupération des données saisies est appellé CGI
pour Common Gateway Interface.
Le couple HTML/CGI ayant montré ses limites (pour qu'un nouveau tag puisse être utilisé il faut qu'il soit reconnu par une majorité de clients) SUN a concu un nouveau langage : JAVA . Il s'agit d'un langage semi-compilé et qui fonctionne avec un RUNTIME cela permet le téléchargement d'une partie de code vers un client (explorateur internet) quelques soit son OS, pourvu qu'il soit compatible JAVA (possédant le RUNTIME) On parle de Machine Virtuelle JAVA (JVM) SUN met à disposition un Kit de developpement : le JDK le dernier JDK porte le N° 1.1 et apporte : - De nouveaux outils - plus d'interface graphique - le support de JDBC (équivalent ODBC pour JAVA, d'ailleur un pont JDBC/ODBC est assuré)
Quelque principes :
JAVA est un langage interprété
le type de source est .java
Pour être exécuté il doit quand même être traduit dans un codage binaire
(byte code)
le pseudo compilateur est JAVAC
JAVAC essai.java
le source (essai.java) devient alors essai.class
il peut être exécuté par l'interpréteur java
JAVA essai.class
Un "programme" JAVA peut aussi être intégré dans une page HTML, on parle
d'Applet.
un programme peut être en mode caractère, une applet est forcément en mode
graphique
Après avoir "compilé" le source il faut inclure l'applet dans une page HTML
par <applet code=essai.class" width=xxx height=yy>
on peut envoyer des paramètres :
<param Name=nom-du-paramètre Value=vvvvvv>
</applet>
puis, soit lancer un utilitaire: Appletviewer
soit lancer un navigateur Internet
Exemples :
Saisir le texte suivant (notepad ira très bien)
[les commentaires commencent par //]
public class bonjour {
// définition du programme principal et des paramètres recus
public static void main(String[] args) {
system.out.println("bonjour !)
}
}
dans une doite DOS, saisir
C:>JAVAC bonjour.java
puis
C:>JAVA bonjour.class
bonjour ! <-- ligne résultat
C:>
pour une Applet :
import java.applet.Applet;
import java.awt.Graphics;
public class bonjourapp extends Applet {
public void paint(Graphics g) {
g.drawString("Bonjour !", 50, 25);
}
}
sauvegarder dans bonjourapp.java et compiler (JAVAC), puis saisir :
<html>
<head>
<title>Bonjour tout le monde</title>
</head>
<body>
<p>Ci-dessous, le test de l'applet Java (entre les deux lignes)</p>
<hr>
<applet code="bonjourapp.class" width="250" height="80"></applet><hr>
</body>
</html>
il s'agit du source d'une page HTML (mettons bonjour.html)
vous pouvez vérifier votre applet par :
appletviewer bonjour.html
ou bien lancer votre navigateur et saisir comme URL
"file://votre-répertoire/bonjour.html"
De nombreux exemples et applets sont livrés avec le JDK
(disponible à "java.sun.com")
vous pouvez aussi regarder la suite KONA toute en JAVA de Lotus
à www.kona.lotus.com
et enfin Le site JAVA www.gamelan.com
Les bases du langage + chaque instruction se termine par ";" + types de variables int binaire non signé long binaire non signé (4 octets) float virgule flottante char UN Caractère boolean logique (indicateur) Exemples int x; // il est possible de déclarer plusieurs variables // il est possible de fournir une valeur initiale int a, B=12, C=1;
Les types ci-dessus sont dits primitifs, pour déclarer des types plus complexes il faudra passer par la notion d'objets. heureusement Java est fourni avec de nombreux objets : String [variable de type chaîne de caractères] StringBuffer [variable à longeur variable] On appelle un sous-programme liée à la définition de l'objet et charger des manipulations sur cet objet, une méthode. Quelques méthodes de l'objet String : length : donne la longueur charat(i) : retourne le caractère de rang i (en base 0) equals : compare deux chaînes indexof(xxx) : donne la position de la chaîne xxx dans la variable substring(debut,lg) : extraction (= %SST) trim : supprime les blancs aux extrémités touppercase : donne l'équivalent MAJUSCULE "+" : opérateur de concaténation
conditions [Attention, = est l'ordre d'affectation]
opérateurs : >, <, <=, >=, == (égal à), != (différent de)
! (négation), && (ET), || (OU)
Opérateur Ternaire
test ? instruction-si-vrai : instruction-si-faux
ex: system.out.println("il y a " + nbr + "participant"
+ (nbr > 1) ? "s" : " ")
[participant prend un "s", s'il y a plus d'une personne]
IF
if (x > 0) x = 1 else x = 0 ;
pour réaliser une série d'instruction
if (x > 0) {
y = 1;
system.out.println("Maintenant, Y égal UN");
}
SWITCH (équivalent du SELECT RPG)
switch x {
case 0: instruction1;
case 2: instruction2;
// Attention au break qui provoque la sortie anticipée de la boucle
break;
default: instruction3
}
Itérations
WHILE : le test est réalisé en début de boucle
while condition instruction ;
ou bien
while condition {
instruction1;
instruction2;
}
DO : le test est réalisé en fin de boucle
do {
instruction1
instruction2;
} while condition
FOR :
for(initialisation, test-de-fin, incrémentation)
for(A=1; A>15; A++) {
...
...
}
break permet une sortie anticipée
continue permet de sauter un tours de boucle
___________________________________________________________________________
Vous avez remarqué la similitude avec le C :
I++ incrémente
I-- décrémente
I += 2 signifie I = I + 2 (qui est lui aussi, admis)
les opérateurs arithmétiques sont : + , - , * , / .
Les Objets P R O G R A M M A T I O N O R I E N T E E O B J E T S Pour simplifier la programmation et tendre vers plus de qualité, différentes méthodes ont étés implémentées: - programmation structurée / programmation modulaire - règle de visibilité (associée à la programmation modulaire) Avec des langages comme le C ou PASCAL, chaque sous programme possède ses propres variables qui ne sont partageables que si elles sont déclarées en tant que variables GLOBALES ou en tant que paramètres. En pascal on parle de procédure (sous programme exécutant une action) fonction (sous programme renvoyant une valeur) Ces notions sont implémentées sur AS/400 avec ILE/RPG-IV
il est possible de déclarer des structures complexes,
cela ce fait en deux phases (exemples en C)
1/ déclaration de la structure théorique, il s'agit d'un "modèle".
Struct enreg
{
int numero ;
int qte ;
float prix ;
}
2/ pour lui donner une éxistence réelle, il faut déclarer une variable
struct enreg article (article est une variable de "type" enreg)
pour manipuler le prix on écrit article.prix
Les concepts de la programmation orientée objet utilisent ces principes:
Il s'agit de déclarer un nouveau type d'entité (un objet)
Qui regoupe la définition de donnée(s) et les procédures associées dans
une même structure (on parle d'ENCAPSULATION)
Les données gardent le nom de VARIABLES.
les procédures associées aux données sont appellées METHODES.
les données sont "protégées", le seul moyen d'y accéder (en lecture comme
en écriture) est d'utiliser leurs méthodes.
| \ Ajouter / |
OBJET: | \ / |
| | Données: | |
CDECLI | lister | N° client article | |
| | date quantité |livrer |
(commande client | | | |
| / \ |
| / Modifier \ |
Les objets dialoguent entre eux par l'intermédiaire de messages
un message est une demande, à un objet, d'exécution d'une de ces méthodes.
ex: cdecli.lister
Si une méthode à besoin d'informations complémentaires, elles seront
fournies sous forme de paramètres.
ex: cdecli.ajouter(4015, A1, 10/12/94, 132,25)
(ici la méthode "ajouter" calcule le n° de commande)
Prenons l'exemple d'un objet "personne" en Java.
une personne est indentifiée par son nom
sa société
en JAVA :
class personne {
// deux variables publiques (accessibles)
public String nom;
public String societe;
// une méthode sans paramètres
public void presentation(){
system.out.println("je m'appelle" + nom);
system.out.println("je travaille chez " + societe);
}
}
implémentation : personne p1, p2; p1 = new personne(); p2 = new personne(); p1.nom = "Durand"; p2.nom = "Dupont"; p1.societe = "France Télécom"; p1.presentation: Ici la notion d'objet n'a pas beaucoup de sens puisque les variables sont publiques. il nous faut déclarer les variables privées et déclarer une méthode chargée de leur initialisation ==> un Constructeur. la méthode sera reconnue comme constructeur, car elle porte le même nom . il peut y avoir plusieurs constructeurs pour une même classe, il seront reconnus selon le nombre de paramètres (on appelle cela une signature)
class personne {
private String nom;
private String societe;
// Il FAUT que cette fonction soit publique
public personne (String unnom) {
nom = unnom.toupperacse();
societe = new String("?");
}
public personne (String unnom, String unesociete) {
nom = unnom.toupperacse();
societe = unesociete;
}
public void presentation()
system.out.println("je m'appelle" + nom);
if (societe.equals("?"))
system.out.println("je suis en recherche d'emploi");
else
system.out.println("je travaille chez " + societe);
}
}
Implémentation :
personne p1, p2;
p1 = new personne("Durand");
p2 = new personne("Dupont", "BT");
p1.presentation;
Il est préférable de définir des méthodes permettant d'accèder aux variables
soit en consultation, soit en modification, une fois l'objet créé.
On appelle de telles méthodes des accesseurs :
par exemple : donnesonnom : pour renvoyer le nom de la personne
quittesasociete : pour mettre ? dans societe
embauche : pour renseigner la societe
Et l'on va définir l'absence de société par une constante figurative plutôt
que par un ?. On appelle cela une variable de classe que l'on va rendre
statique c'est à dire non modifiable par programme.
class personne {
private static final String chomeur = "?";
private String nom;
private String societe;
// Une méthode privée pour la vérification
private verifsociete (String Socnom) {
if (Socnom.length > 32 || Socnom.equals(chomeur) ) {
system.out.println("societe incorrecte");
System.exit(1);
}
}
// Constructeurs
// Il FAUT que ces fonctions soit publiques
public personne (String unnom) {
nom = unnom.toupperacse();
societe = new String("?");
}
public personne (String unnom, String unesociete) {
nom = unnom.toupperacse();
societe = unesociete;
}
// 2 accesseurs en consultation
public donnesonnom () { return nom; }
public donnesasociete {
if (societe.equals(chomeur) )
return new String("inconnue");
else
return societe;
}
// 2 accesseurs en modification
public quittesasociete() {
if (societe.equals(chomeur) ) {
presentation
system.out.println("societe incorrecte");
System.exit(2);
}
societe = chomeur
}
public embauche (String nouvelleboite) {
if (! societe.equals(chomeur) ) {
presentation
system.out.println("il faut d'abord partir")
System.exit(3);
}
societe = verifsociete(nouvelleboite).touppercase
}
// procédure simple (exécute une action)
public void presentation()
system.out.println("je m'appelle" + nom);
if (societe.equals("?"))
system.out.println("je suis en recherche d'emploi");
else
system.out.println("je travaille chez " + societe);
}
}
La définition de l'objet est appellée Classe.
la métaphore la plus souvent utilisée est le moule à gauffres
Un objet chargé en mémoire (en cours d'éxécution) est appellé INSTANCE :
les gauffres !
C'est ce qui explique que l'on emploie la méthode .equal pour les objets
String :
En effet pour deux objets String S1 et S2
if (S1 == S2) donne false !
Car vous demandez si S1 est le MEME OBJET QUE S2, ce qui est faux,
ils contiennent seulement la même chose (!)
S1 : Objet String S2 : Objet String
| |
| |
| |
.......................... ..........................
: \ / : : \ / :
: \ ______________ / : : \ ______________ / :
: | | : : | | :
: | Bonjour | : : | Bonjour | :
: | | : : | | :
: |____________| : : |____________| :
: / \ : : / \ :
:........................: :........................:
il faut écrire if S1.equals(S2)
Si cela vous paraît naturel, vous êtes fin prêt pour la POO.
Une classe d'objet peut être définie par rapport à une classe existante. On parle de HIERARCHIE de classes.(qu'il faudra donc connaître !!!) Une classe définie par rapport à une classe existante, bénéficie automatiquement de toutes ces méthodes. C'est l'HERITAGE. exemple: soit une classe commande (classe générique ou banalisée) soit une classe cdecli fille de la classe commande cdefour fille de la classe commande Si sont définies, au niveau de la classe commande, les méthodes: ajouter, solder, modifier, ces méthodes sont aussi attribuées aux classes cdecli, cdefour. Les classes filles peuvent avoir des méthodes qui leur soient propres (fonction de liste, par exemple)
Il pourrait paraître plus judicieux de définir une méthode "lister" au
niveau de la classe "PARENTE" (ici commande)
et (tout en héritant de cette méthode) de redéfinir les PARTICULARITES
au niveau de chaque instance.
la méthode portera donc le même nom ("lister") tout en ayant une exécution
propre à la classe cdecli ou cdefour. ON parle de SURCHARGE.
Si vous avez besoin de redéfinir, pour une instance donnée, non pas les
méthodes, mais les variables sur lesquelles ces méthodes vont être
appliquées, on emploie alors le terme de POLYMORPHISME.
les méthodes devant être capables de travailler sur des données de "forme"
différentes.
C'est un concept très utilisé dans le monde scientifique, probablement
moins justifié dans le monde de la gestion.
Héritage en JAVA :
JAVA possède une classe "Point" permettant de stocker un point en 2D
ajoutons une troisième dimension.
import java.awt.*
public class Point3D extends Point {
public int z;
public Point3D(int x, int y, int z) {
// super fait référence à la classe parente
super.x = x;
super.y = y;
// this fait référence à l'objet en cours
this.z = z;
}
//attribution de nouvelles coordonnées
public move (int x, int y, int z) {
this.z = z;
super.move(x, y);
}
// déplacement (x, y, z sont donnés en + ou en -)
public void translate (int x, int y, int z) {
this.z += z;
super.translate(x, y)
}
}
AWT = Abstract Windowing Toolkit.
routines implementées dans JAVA de facon à gérer l'interface graphique
en toute indépendance du système d'exploitation :
- boutons, cases à cocher, ..,
- zones de saisie, boites de dialogue
- menus déroulants
Tout est objet en Java, vous devez donc créer un objet bouton puis ajouter
ce bouton dans l'applet Java :
import java.applet.*;
import java.awt.*;
public class essaibouton extends Applet {
boutonok = new button("Ok")
public void init () {
add (boutonok)
}
}
Pour mettre en forme (aligner) ces objets vous devez utiliser des
objets conteneurs qui possèdent chacun leurs propres caractèristiques
Panel = conteneur d'objets
Layout = Méthode du panel indiquant une organisation visuelle
FlowLayout = organisation de gauche à droite puis de haut en bas
(c'est l'organisation par défaut)
Gridlayout = organisation en lignes / colonnes
BorderLayout = organisation en alignement sur les bordures
North = bordure Haute
West = bordure gauche , etc ...
Le principe est de définir un nouvel objet Panel par groupe d'objets
graphiques, puis d'utiliser une méthode xxxLayout pour chaque panel
afin de définir l'alignement et enfin d'ajouter les objets graphiques
de base (boutons, zones de texte, etc ...)
Extrait d'un programme JAVA :
//configurer la rangée 1
Panel ran1 = new Panel();
CheckboxGroup option = new CheckboxGroup();
Checkbox quickpick = new Checkbox ("Choix rapide", option, true);
Checkbox personnel = new Checkbox ("Personnel", option, false);
//configurer la rangée 2
Panel ran2 = new Panel();
Label numbersLabel = new Label ("Votre sélection : ", Label.RIGHT);
...
Gridlayout grille = new Gridlayout(5, 1, 10, 10);
ran1.setlayout(grille);
Heureusement tous les outils récents sont des outils Visuels, citons :
Visual J++ de Microsoft(souvent accusé de générer du code propriétaire)
Visual café de Symantec
VisualAge for JAVA d'IBM (la version Béta est disponible gratuitement)
Il reste à associer un code aux actions de l'utilisateur :
par objet.addActionListener(classe)
En général c'est le même programme qui contient le code de traitement
ce qui s'écrit :
objet.addActionListener(this)
Le programme de traitement doit contenir une méthode
void Public actionPerformed(Actionevent Evnt) {
// le méthode suivante retourne le libellé de l'objet concerné
// ou le contenu s'il s'agit d'une zone de saisie
String lib = evnt.GetActionCommand();
// le méthode suivante retourne le nom de l'objet
Objet obj = evnt.GetSouce();
}
ce langage est actuellement très jeune, les outils doivent évoluer
pour masquer la complexité due à l'approche objet.
il faut noter en faveur de ce langage (en comparaison au C) que l'on ne
manipule JAMAIS explicitement de pointeurs, qu'il ne peut donc pas y
avoir de faute de protection générale ni d'objets restant en mémoire.
les concepteurs de JAVA ont implémenté un "garbage collecteur"
ou ramasse-miette qui récupère la place des objets inutilisés.
Vous pouvez télécharger le kit de dévelloppement chez SUN (JDK 1.1.1)
et analyser les différents exemples qui sont fournis.