Leçon 1 et 2 Leçon 3 Leçon 4 Leçon 5
Chapitre 1 Historique
Les débuts de Java remontent à avril 1991 quand un petit groupe d'employés de Sun ont été déplacés dans un autre département pour travailler à un projet baptisé Green voué à la réalisation d'applications électroniques commerciales.
L'équipe Green était libre de faire ce qu'elle voulait. Sa première mission fut de créer un appareil capable de contrôler plusieurs équipements électroniques à la fois. Un langage fut créé à cette intention, le langage Oak dont les premiers pas remontent à août 1991. Le nom Oak, trop proche d'une autre marque, fut débaptisé Java en 1995.
L'annonce officielle de Java et HotJava date elle du salon SunWorld 1995. Le projet Green était originellement orienté vers la création de systèmes d'exploitation pour Personal Digital Assistant, set-top boxes etc. Le projet initial fut dissout et la technologie recentrée vers le CD-ROM, le multimédia en ligne et les environnements réseau.
Le maître d'oeuvre de Java est James Gosling qui commenca par vouloir étendre le C++ avant de réaliser le premier compilateur Java écrit en langage C. Arthur Van Hoff implémenta le compilateur Java en Java lui-même à la fin 1994.
Chapitre 2 Architecture de Java
L'avantage le plus important de Java est probablement sa portabilité puisqu'il peut tourner sur n'importe quelle machine disposant d'un interpréteur Java. Cette portabilité est fondamentale sur Internet où un nombre important de machines et systèmes d'exploitation différents inondent le marché.
Dans un environnement interprété, le code Java n'est conçu pour aucune plate-forme spécifique mais est une sorte de code intermédiaire qui doit être traduit en code natif machine par un programme particulier faisant office de compilateur. Le code intermédiaire ou bytecode est conçu pour une machine qui n'existe pas ou plutôt une Java Virtual Machine. Cela s'explique par la lenteur habituelle des interpréteurs obligés de décoder chaque ligne de code avant leur exécution. Java pallie cette lenteur par une sorte de première compilation générant du code plus rapide à convertir en code natif.
Cette portabilité va jusqu'à codifier une taille unique pour chaque type de données. Même si Windows 3.1 stocke ses entiers sur 16 bits, Windows 95 sur 32 ou un DEC Alpha sur 64 bits, un entier Java a la même taille mémoire dans toutes ses implémentations.
Petit
Java est tout petit. L'interpréteur de base tient dans 40 KO plus 175 KO pour le support des threads soit 215 KB seulement.
Java est décrit à travers une machine virtuelle ou Java Virtual Machine, un modèle abstrait et logique incluant un jeu d'instructions, un jeu de registres, un stack, un heap et une espèce de segment texte baptisé ici "method area".
JVM est l'équivalent d'un ordinateur virtuel résidant entièrement en mémoire. Cette JVM doit être implémentée sur chaque plate-forme. Une JVM fournit un niveau d'abstraction entre le programme Java compilé et une plate forme matérielle.
L'adressage dans la JVM se fait sur 32 bits permettant l'accès à 4 GB de mémoire. Chaque registre peut contenir une adresse 32 bits. Chaque méthode est limitée à 32 KB.
Le heap est la portion de mémoire dans laquelle sont allouées les instances de classe. L'environnement runtime garde une trace des références à chaque objet et libère automatiquement la mémoire associée à un objet qui n'est plus référencé. Le garbage collector tourne comme thread en tâche de fond et s'active pendant les périodes d'inactivité du processeur.
Strictement parlant, Java est un langage interprété bien que nous venons d'évoquer son aspect compilé. En effet, tout les opcodes de la JVM doivent être interprétés par chacune des plates-formes. L'interprétation s'opère via un navigateur World Wide Web ou un environnement runtime spécial.
Un compilateur Just-in-Time ou JIT compile des méthodes Java en code natif. Il génère du code natif pour une plate-forme et n'est donc plus portable.
Java se veut robuste dans la mesure où le langage, fortement typé, permet moins de "bidouillages" que le langage C par exemple. Des bugs classiques de programmeurs C comme le dépassement de tableau sont impossibles. C et C++ sont plus difficilement portables puisqu'ils permettent l'usage de pointeurs pour directement adresser des portions de mémoire ou ne gèrent pas automatiquement la désallocation de la mémoire. Cela débouche sur des programmes syntaxiquement corrects mais qui peuvent néanmoins provoquer un crash système.
Pour garantir la robustesse de Java, celui-ci a été débarrassé des pointeurs : il est impossible de référencer une adresse mémoire, d'utiliser l'arithmétique de pointeurs pour se déplacer dans des tableaux. De plus, Java vérifie toujours lors de l'utilisation de tableaux que le programmeur ne cherche pas à utiliser des portions non allouées.
La gestion de la mémoire, sa désallocation automatique via un garbage collector sont les garants d'une meilleure stabilité des applications. Le garbage collector fonctionne comme un thread séparé tournant en tâche de fond avec une basse priorité. Il désalloue des pans de mémoire lorsque l'utilisation du CPu est faible ou lorsqu'un besoin de mémoire se fait sentir pour l'application.
La première tâche de l'interpréteur Java est de vérifier la conformité du programme, analyser si le code n'a pas été transformé entre la compilation et l'exécution du code. Un "bytecode verifier" se charge d'observer si une classe n'a pas accès aux registres, ne manipule pas le stack ou n'accède pas au "file system" de manière anormale. De plus, Java utilise pour ses transferts une technique d'encryption basée sur le système de clé publique.
Le chargement d'une classe Java via le réseau s'opère par le biais d'un ClassLoader qui gère tous les mécanismes de sécurité.
Les applets chargées via le réseau sont restreintes au niveau :
Le langage C++ est un compromis entre un langage C de troisième génération et un langage purement orienté objet comme Smalltalk. Même s'il s'inspire de la syntaxe du C++, Java a été réécrit à partir de zero de manière à être totalement orienté objet. Java est un langage plus purement orienté objet que le C++ qui conserve de nombreux aspects de programmation procédurale puisqu'il n'est lui-même qu'une extension du langage C.
L'objet Java appartient à une classe. Cette classe est une collection de variables, de méthodes encapsulées dans un objet réutilisable et chargé dynamiquement en mémoire à l'exécution. Une classe n'est donc qu'une collection de code qui modélise sous forme logicielle le comportement d'objets.
Le concept d'héritage de classe est respecté puisqu'il est possible de dériver une nouvelle classe d'objets à partir d'une classe originale dont on conserve les fonctionnalités en les étendant.
Le chargement automatique de classes Java est essentiel pour son utilisation sur Internet. Cela permet, lors du chargement d'un type de fichier ou document inconnus, de télécharger le code qui permettra de traiter ou visualiser ce fichier.
Par rapport au langage C++, Java apporte de nombreuses différences :
Les opérateurs du langage Java sont identiques à ceux du langage C, des librairies C pouvant aussi être ajoutées à une application Java.
Java a été pensé de manière multitâches mais aussi multithread. Le fait que le bytecode produit par un compilateur Java est très proche du code natif d'une machine rend son interprétation plus efficace que celle d'un interpréteur ordinaire.
Java s'impose de plus en plus comme un standard universel pour le transfert d'informations dynamiques sur le Net. Le World Wide Web statique des simples pages HTML fait place à des applications réellement interactives où le contenu des documents est généré dynamiquement au moment de l'exécution.
Lorsqu'un navigateur Web traditionnel rencontre un nouveau type d'objet pour lequel il n'est pas préparé, il doit céder la main à une application extérieure ou sauver l'objet sur disque, faute d'outil de traitement adéquat. HotJava par contre peut délivrer via Internet un objet et la pièce de code nécessaire à son décodage. La même conception objet est appliquée à la gestion des protocoles de transfert de données. A côté du protocole HTTP, HotJava peut accepter dynamiquement de nouvelles formes de protocoles incluant par exemple de l'encryption. Chaque concepteur d'un protocole propriétaire peut intégrer dans un navigateur HotJava le code nécessaire à son bon fonctionnement. Si le client HotJava ne connaît pas encore le nouvel objet ou le nouveau protocole, il réclame simplement au serveur les portions logicielles requises.
Java peut également être utilisé pour la réalisation d'applications plus classiques en mode "stand-alone", comme moteur gérant le comportement et l'intégration d'objets 3D dans la version 2.0 du VRML ou Virtual Reality Modeling Language ou encore pour la création d'agents intelligents s'acquittant de tâches routinières pour le compte d'un utilisateur. Une classe Java a l'énorme avantage de pouvoir contenir à la fois des données et les méthodes qui permettent de les traiter.
Java est conçu pour la programmation distribuée et est capable d'ouvrir et accéder des objets à distance via différents protocoles.
L'interprétation de programmes Java est une tâche gourmande à laquelle s'attaque mal les processeurs habituels. Aussi, Sun s'est mis en tête de produire des processeurs Java spécialement conçus pour coller avec la fameuse Java Virtual Machine. Sun développe à cet effet un ensemble de spécifications rassemblées sous le terme d'architecture picoJava. Sun promet de produire ses premiers processeurs dès le début de 1997 et d'offrir des contrats de licence picojava pour les sociétés désireuses de produire leurs propres puces Java.
Le bas de gamme de l'offre picoJava s'appelle microJava, coûtera entre 25 et 50 $ et s'adapera spécialement aux applications intégrées du PDA au téléphone cellulaire en passant par les set-top boxes et les Network Computer. Le haut de gamme est baptisé du nom d'ultraJava, un processeur coûtant une centaine de dollars.
Micro ou Ultra, un processeur Java est capable d'exécuter directement du bytecode Java sans devoir le convertir dans un jeu d'instructions propre à un autre CPU et ne réclame donc pas toute la mémoire nécessaire pour la phase habituelle d'interprétation.
Abusivement, trop de commentateurs informatiques tendent à réduire un Network Computer à un simple terminal, voyant l'avènement des NC comme un simple retour en arrière vers un modèle informatique centralisé. Il n'en est rien. Un NC peut être bien plus que cela puisque le seul plus petit dénominateur commun pour un NC est de répondre à un modèle client/serveur ouvert et conforme à des standards Internet comme Java. Pour Oracle, inventeur du terme de Network Computer, un appareil peut porter la mention NC à partir du moment où il répond à chacun des critères du NC Reference Profile. Une série d'applications Java et de documents permettent à un constructeur de vérifier la conformité de son appareil à la norme NC. A côté de celà, Oracle produit également un Oracle NC System Software Suite incluant un système d'exploitation à base de micronoyau baptisé NCOS, l'environnement de développement Java conçu par Sun, un navigateur Web contenant son propre interpréteur Java, un plugin Macromedia Director et quelques logiciels supplémentaires.
Pour mériter l'appellation NC au sens du NC Reference profile, une station doit au minimum disposer des fonctions suivantes :
Tout le reste, disque dur ou lecteur de disquette par exemple, est purement optionnel.
Les exigences TCP/IP sont les plus draconiennes :
Vous aurez compris aisément que votre PC actuel est déjà un NC sans le savoir s'il dispose d'une carte son, fait tourner Windows, un navigateur Web et des couches TCP/IP.
4 Types d’applications Java
4 types d'applications sont générées en Java :
Une classe est composée de deux types d'items : "instance variables" et "methods". Dans le cas d'un objet comme une voiture, les variables d'instanciation pourraient être l'âge du véhicule, sa couleur ou son kilométrage tandis que les méthodes seraient allumer, éteindre ou garer l'auto. Toutes ces variables et méthodes doivent être membres d'une classe et ne peuvent être isolées à la manière d'une variable globale en C.
Le cycle de chargement d'une applet
Tout comme un document HTML, une applet Java réside préalablement sur un serveur Web. Lorsque le navigateur client reçoit une page HTML, il interpréte la balise <APPLET> et télécharge le fichier .class correspondant à cette applet depuis le serveur. L'exécution de l'applet est effectuée en invoquant les méthodes init() et start()
Créer une Applet avec Visual J++
Dans le menu File, choisir New. dans la boîte de dialogue, sélectionnez Text File puis cliquez sur OK. Une fenêtre d'édition vide apparaît. Tapez les lignes de code suivantes dans l'éditeur :
import java.awt.Graphics;
class Salut extends java.applet.Applet
{
public void paint( Graphics g )
{
g.drawString( "Salut à tous!", 50, 25 );
}
}
Source : http://www.netline.be/netline/formations/java/salut.txt
Toujours dans le menu File, sélectionnez l'item Save. Dans la boîte, entrez Salut.java. Dans le menu Build, choisissez Build Salut. Une boîte de dialogue apparaît vous proposant de créer un espace de travail par défaut. Cliquez sur Yes. Dans le menu Build, choisissez cette fois Execute. Dans la boîte Information for running class, encodez Salut et cliquez sur OK. Microsoft Developer Studio lance alors l'exécution du navigateur Internet Explorer 3.0 où vous pourrez admirer le résultat de votre premier programme
Revenons sur chacune des lignes du programme
import java.awt.Graphics;
instruit le compilateur que vous êtes prêt à utiliser la classe java.awt.graphics. le compilateur se charge alors d'inclure la définition de cette classe dans le code que vous venez de réaliser.
class Salut extends java.applet.Applet
déclare une nouvelle classe Salut et signale au compilateur qu'il s'agit d'une sous classe, d'une extension de la classe java.applet.Applet.
public void paint( Graphics g )
public signifie qu'un objet à l'extérieur de cette classe est autorisé à invoquer une méthode.
void signifie que la méthode ne renvoie aucune valeur de retour.
La méthode paint est invoqué avec le passage de l'argument g qui est un objet de la classe Graphics. Cette méthode paint remplace la méthode paint de la classe Applet originale.
g.drawString( "Salut à tous!", 50, 25 );
L'objet g est prié d'invoquer sa méthode drawString avec les arguments "Salut à tous", 50 et 25 de manière à imprimer le texte "Salut à tous" à la position 50, 25.
Au moment d'invoquer l'exécution du navigateur, Microsoft Visual J++ génère automatiquement la page HTML qui va accueillir votre applet :
<html>
<head>
<title>Salut</title>
</head>
<body>
<applet code=Salut width=200 height=200>
</applet>
</body>
</html>
Source : http://www.netline.be/netline/formations/java/salut.htm
La syntaxe de la balise <APPLET> est la suivante
<APPLET CODEBASE=url CODE=appletClassFile WIDTH=n HEIGHT=n ALT=alternateText NAME=appletInstanceName ALIGN=alignment VSPACE=n HSPACE=n> <PARAM NAME=parameter1 VALUE=value1> <PARAM NAME=parameter2 VALUE=value2> . . <PARAM NAME=parameterN VALUE=valueN> Alternate HTML </APPLET>
|
Attributes Requis |
Valeurs |
|
CODE |
Un nom de fichier de classe valide |
|
WIDTH |
Largeur de l'applet en pixels |
|
HEIGHT |
Hauteur de l'applet en pixels |
|
Attributs optionnels |
Valeurs |
|
CODEBASE |
Un URL valide pointant sur le répertoire où réside les fichiers .class de l'applet |
|
ALT |
Texte alternatif à afficher sur les navigateurs non compatibles Java. |
|
NAME |
Un nom pour l'applet qui lui permet de dialoguer avec d'autres applets sur la même page HTML |
|
ALIGN |
Alignement de l'applet : left, right, top, texttop, middle, absmiddle,baseline, bottom, absbottom. |
|
VSPACE |
Espacement vertical. |
|
HSPACE |
Espacement horizontal. |
|
PARAM |
Paramètres à passer à l'applet. |
Il vous est bien sûr loisible de créer vous-même cette page HTML à partir d'un éditeur quelconque.
Le tout devrait vous donner ceci dans votre navigateur
L'environnement de travail Visual J++ vous donnant lui ceci :
Créer une application texte avec Visual J++
Java peut être utilisé pour créer des applications "stand-alone" qui n'ont pas besoin d'un navigateur Web pour fonctionner. Ces applications ont besoin, pour fonctionner, d'un interpréteur disponible pour votre plate-forme.
Reprenons le même exemple que tout à l'heure. Le code source devient :
class Salut2
{
public static void main( String args[] )
{
System.out.println( "Salut à tous" );
}
}
Source : http://www.netline.be/netline/formations/java/salut2.txt
Ici, la classe Salut2 n'est pas explicitement mentionnée comme étant l'extension ou la sous-classe d'une classe existante. Quand une classe est crée sans spécifier la classe dont elle hérite, c'est que la classe Object est considérée comme superclasse par défaut.
On aurait tout aussi bien pu écrire
class salut2 extends Object
public static void main( String args[] )
public signale qu'un objet extérieur à la classe Salut2 peut invoquer la méthode main()
static instruit le compilateur que la méthode fait appel à la classe elle-même et non à une instance de cette classe. celà permet à la méthode d'être appelée sans qu'un objet Salut2 n'ait été créé préalablement.
La méthode main prend un argument, args[], qui est un objet de type String. Cet objet gère les arguments qui sont passés dans la ligne de commande.
Comme en C ou en C++, la méthode main est obligatoire pour définir le point d'entrée dans l'application pour l'interpréteur
System.out.println( "Salut à tous" );
Cette ligne est chargée d'imprimer le texte "Salut à tous" sur le périphérique de sortie standard (stdout) généralement l'écran.
Reprenez les mêmes étapes que tout à l'heure, Edit - Save - Build -Execute. Cette fois, ce n'est plus Internet Explorer 3 qui est chargé d'interpréter votre application, mais un petit interpréteur, JView, fourni par Microsoft avec le Visual J++.
"jview salut2
Microsoft (R) Command-line Loader for Java (tm) Version 1.00.6211
Copyright (C) Microsoft Corp 1996. All rights reserved.
Salut à tous
Si vous êtes lassé de l'environnement graphique Visual J++, vous pouvez invoquer directement le compilateur à partir de l'invite d'une boîte MS-Dos. Le compilateur s'appelle JVC.EXE et accepte les arguments suivants :
"jvc /?
Microsoft (R) Visual J++ Compiler Version 1.00.6229
Copyright (C) Microsoft Corp 1996. All rights reserved.
Usage: JVC [options] <filename>
/cp <classpath> set class path for compilation
/cp:p <path> prepend path to class path
/cp:o[-] print classpath
/d <directory> root directory for class file output
/g[-] full debug information (g:l, g:d)
/g:l[-] generate line numbers <default=none>
/g:t[-] generate debug tables <default=none>
/nowarn turn off warnings <default=warn>
/nowrite compile only - do not generate class files
/O[-] full optimization (O:I,O:J)
/O:I[-] optimize by inlining <default=no opt>
/O:J[-] optimize bytecode jumps <default=no opt>
/verbose print messages about compilation progress
/w{0-4} set warning level <default=2>
/x[-] disable extensions <default=enabled>
Notre second programme, déjà bien plus utile, va vous donner des informations sur votre environnement de travail Java avec la méthode System.getProperty(String key)
Source : http://www.netline.be/netline/formations/java/systeme.txt
class systeme
{
public static void main( String args[] )
{
System.out.println("Version Java : "+ System.getProperty("java.version" ));
System.out.println("Url vendeur : "+ System.getProperty("java.vendor.url" ));
System.out.println("Version classe : "+ System.getProperty("java.class.version" ));
System.out.println("OS : "+ System.getProperty("os.name" ));
System.out.println("Architecture : "+ System.getProperty("os.arch"));
System.out.println("Sep fichier : "+ System.getProperty("file.separator" ));
System.out.println("Sep path : "+ System.getProperty("path.separator" ));
System.out.println("Sep ligne : "+ System.getProperty("line.separator" ));
}
}
Lancé via une boîte Dos avec la commande jview systeme, le programme une fois compilé donne ceci:
Version Java : 1.1
Url vendeur : http://www.microsoft.com/
Version classe : 45.3
OS : Windows NT
Architecture : x86
Sep fichier : \
Sep path : ;
Sep ligne :
Table des variables de System.gePropertyt
|
Key |
Information Returned |
|
java.version |
Java version number |
|
java.vendor |
Java vendor-specific string |
|
java.vendor.url |
Java vendor URL |
|
java.class.version |
Java class version number |
|
os.name |
Operating system name |
|
os.arch |
Operating system architecture |
|
file.separator |
File separator (such as /) |
|
path.separator |
Path separator (such as :) |
|
line.separator |
Line separator |
Java accepte trois types de commentaires :
L'identifieur est le nom donné à une variable, une classe ou une méthode pour la désigner auprès du compilateur. En Java, chaque identifieur doit commencer par une lettre, l'underscore (_) ou le dollar ($). Les caractères suivants peuvent aussi inclure les chiffres de 0 à 9. Les caractères comprennent toutes les lettres de A à Z, minuscules et majuscules plus les caractères Unicode au-dessus de 0x00C0.
Les mots-clés ou keywords sont des identifieurs utilisés par le langage Java lui-même.
|
abstract |
boolean |
break |
byte |
|
|
case |
catch |
char |
class |
|
|
continue |
default |
do |
double |
else |
|
extends |
false |
final |
finally |
float |
|
for |
if |
implements |
import |
|
|
instanceof |
int |
interface |
long |
native |
|
new |
null |
package |
private |
protected |
|
public |
return |
short |
static |
super |
|
switch |
synchronized |
this |
threadsafe |
throw |
|
transient |
true |
try |
void |
while |
byvalue, cast, const, future, generic, goto, inner, operator, outer, rest, et var sont réservés.
Il y a sommairement deux types de données dans le langage Java, les nombres et les caractères. Les nombres sont divisés en entiers et virgule flottante plus le booléen incluant les valeurs 0 et 1 pour False et True. Les caractères se réfèrent à une valeur quelconque du jeu de caractères Unicode.
Un entier peut être introduit sous trois formes : décimale, octale ou hexadécimale. Un entier en base dix ne peut commencer par un 0. En base 8, les entiers sont précédés d'un 0. En base 16, les valeurs de 0 à 9 et de A à F sont précédées de 0x.
Les entiers sont stockés sur 32 bits acceptant toute valeur entre -2.147.483.648 et 2.147.483.648.
Si des valeurs plus élevées doivent être représentées, il faut utiliser les entiers de type long sur 64 bits auxquels on ajoute le suffixe l ou L pour les distinguer. Le byte est stocké sur 8 bits tandis que le short est stocké sur 16 bits.
Voici un exemple de déclarations d'entiers :
byte bcount;
short sNumber;
int nRoues;
long lHumains;
|
Type |
Contains |
Size |
Max |
Min |
|
boolean |
true,false |
1 bit |
- |
|
|
char |
Unicode char. |
16 bits |
\u0000 |
\uFFFF |
|
byte |
signed integer |
8 bits |
-128 |
127 |
|
short |
signed integer |
16 bits |
-32768 |
32767 |
|
int |
signed integer |
32 bits |
-2147483648 |
2147483647 |
|
long |
signed integer |
64 bits |
-9223372036854775808 |
8223372036854775807 |
|
float |
floating point |
32 bits |
±3.40282347E+38 |
±1.40239846E-45 |
|
double |
floating point |
64 bits |
±1.79769313486231570E+308 |
±4.94065645841246544E-324 |
Les nombres à virgule flottante peuvent être représentés en notation standard ou scientifique 3.1416 ou 2.99E8 par exemple.
Un float en simple précision est stocké sur 32 bits et s'écrit avec le suffixe f ou F. Un float en double précision est stocké sur 64 bits et se distigue par le suffixe d ou D.
Le mot float sert à déclarer les nombres en simple précision sur 32 bits tandis que double déclare les nombres à double précision sur 64 bits.
Exemple :
float pi;
double dvirgule;
Un booléen est défini par les mots-clés true et false et se déclare avec le mot clé boolean.
Exemple :
boolean StopOuEncore;
Un caractère peut être explicitement défini entre '. Les caractères spéciaux sont précédés du signe backslash \.
|
Line feed |
\u000a |
\n |
|
Carriage return |
\u000d |
\r |
|
Tab |
\u0009 |
\t |
|
Backspace |
\u0008 |
\b |
|
Form feed |
\u000c |
\f |
|
Backslash |
\u005c |
\\ |
|
Single quotation mark |
\u0027 |
\' |
|
Double quotation mark |
\u0022 |
\" |
|
Octal bit pattern |
\ddd |
|
|
Hex bit pattern |
\xdd |
|
|
Unicode |
\udddd |
Les caractères étant de type Unicode et non ASCII sont des entiers non signés sur 16 bits et se déclarent avec le mot clé char.
Une String est une collection de n'importe quel nombre de caractères entourés de guillemets ("). La gestion des chaînes est pratiquement identique à celle du C++ à une grande exception près : une fois qu'une chaîne a été déclarée son contenu ne peut plus changer. Pour modifier cette chaîne, il faut créer un objet StringBuffer qui sera initialisé avec une chaîne puis transformé.
String thisString=new String("Strng");
//cree la chaine initiale
StringBuffer modif=new StringBuffer(thisString);
modif.insert(4,'i');
//insere le caractere i en 4e position de l'objet // StringBuffer
String fString=new String(modif);
Une chaîne de caractère particulière est la chaîne args[] qui contient l'ensemble des arguments passés à une application Java via la ligne de commande. Attention, le premier argument est contenu dans args[2]tandis que la variable args.length contient le nombre d'arguments de la ligne de programme.
Source : http://www.netline.be/netline/formations/java/argument.txt
class Argument
{
public static void main (String args[])
{
int i;
for (i=0;i<args.length;i++)
System.out.println("Bonjour "+args[i]);
}
}
L'exécution donne ceci :
>>jview argument 1 2 3 4 5
Bonjour 1
Bonjour 2
Bonjour 3
Bonjour 4
Bonjour 5
Les tableaux ou Arrays sont des listes d'objets identiques. Exemple :
int i[]; // tableau à une dimension
char c[][]; // tableau à deux dimensions
La taille des tableaux n'est pas comprise dans la déclaration comme en C ou C++ mais doit être explicitement allouée avec la commande new pour autoriser la vérification du dépassement de tableau ( boundary checking).
int [] myArray=new int[10];
long TowerOfHanoi[][]={{10,9,8,7,6,5,4,3,2,1},{},{}};
Voici la liste exhaustive des opérateurs et séparateurs du langage Java :
|
+ |
- |
! |
% |
^ |
& |
* |
| |
|
~ |
/ |
> |
< |
( |
) |
{ |
} |
|
[ |
] |
; |
? |
: |
, |
. |
= |
|
++ |
-- |
== |
<= |
>= |
!= |
<< |
>> |
|
>>> |
+= |
-= |
*= |
/= |
&= |
| = |
^= |
|
%= |
<<= |
>>= |
>>>= |
| | |
&& |
|
- |
négation |
|
~ |
complément de bits |
|
++ |
incrémentation |
|
-- |
décrémentation |
source : http://www.netline.be/netline/formations/java/unary.txt
class Unary
{
public static void main ( String args[ ])
{
int i=0;
int j=5;
int k=255;
int l = 10;
i++;
j--;
~ k;
-l;
System.out.println("i="+i+" j="+j+" k="+k+" l="+l);
}
}
donnera ceci à l'exécution
"jview Unary
Microsoft (R) Command-line Loader for Java (tm) Version 1.00.6211
Copyright (C) Microsoft Corp 1996. All rights reserved.
i=1 j=4 k=-256 l=-10
|
- |
soustraction |
|
+ |
addition |
|
* |
multiplication |
|
/ |
division |
|
% |
modulo |
|
& |
Bitwise AND |
|
| |
Bitwise OR |
|
^ |
Bitwise XOR |
|
<< |
Left shift |
|
>> |
Right shift |
|
>>> |
Zero fill right shift |
Left shift
n << s donne la valeur de n décalé à gauche de s bits. Cela revient à multiplier n par 2 à la puissance s.
Right shift
n >> s donne le même résultat que n/2 exposant s.
Zero fill right shift
Dans l'expression n >>> s, si n est positif, le résultat est identique à n>>s, si n est négatif, le résultat est égal à l'expression (n>>s)+(2<<~s) pour empêcher la propagation du signe négatif
0xff00 & 0xf0f0 = 0xf000
0xff00 ^ 0xf0f0 = 0x0ff0
0xff00 | 0xf0f0 = 0xfff0
Source : http://www.netline.be/netline/formations/java/binary.txt
class Binary
{
public static void main ( String args[ ])
{
int i=1;
int j=2;
int k=3;
int l=4;
i=i+j;
j=j*k;
k=l-k;
l/=2;
System.out.println("i="+i+" j="+j+" k="+k+" l="+l);
}
}
donnera ceci à l'exécution
"jview binary
Microsoft (R) Command-line Loader for Java (tm) Version 1.00.6211
Copyright (C) Microsoft Corp 1996. All rights reserved.
i=3 j=6 k=1 l=2
|
< |
plus petit que |
|
> |
plus grand que |
|
<= |
plus petit ou égal |
|
>= |
plus grand ou égal |
|
== |
égal |
|
!= |
différent de |
Source : http://www.netline.be/netline/formations/java/relation.txt
class Relation
{
public static void main ( String args[ ])
{
int i=1;
while (i++<10)
{
System.out.println("i="+i+"\n");
}
}
}
L'exécution donne le résultat suivant :
i=2
i=3
i=4
i=5
i=6
i=7
i=8
i=9
i=10
|
! |
négation |
|
& |
ET logique |
|
| |
OU logique |
|
^ |
XOR logique |
|
&& |
ET évaluation |
|
== |
Egal |
|
!= |
Différent |
|
|| |
OU évaluation |
|
&= |
ET assignation |
|
!= |
OU assignation |
|
^= |
XOR assignation |
|
?: |
Ternaire |
ET
|
Item 1 |
Item 2 |
Résultat |
|
1 |
1 |
1 |
|
1 |
0 |
0 |
|
0 |
1 |
0 |
|
0 |
0 |
0 |
OU
|
Item 1 |
Item 2 |
Résultat |
|
1 |
1 |
1 |
|
1 |
0 |
1 |
|
0 |
1 |
1 |
|
0 |
0 |
0 |
XOR
|
Item 1 |
Item 2 |
Résultat |
|
1 |
1 |
0 |
|
1 |
0 |
1 |
|
0 |
1 |
1 |
|
0 |
0 |
0 |
L'allocation de tableaux doit passer par l'opérateur new de la sorte avec au minimum une dimension allouée :
int x[] = new int[15];
char c[] = new char[10][20];
float y[] = new float[4][];
La concaténation de chaînes se fait au moyen des opérateurs + et +=
|
if-else |
|
|
switch |
|
|
break |
|
|
continue |
|
|
return |
|
|
for |
|
|
while |
|
|
do-while |
|
|
label |
if (boolean) statement
else statement
while (test)
...
do
{
...
}
while (test)
switch (x)
{
case 'a' :
...
break;
...
default:
...
}
for (i=0;i<10;i++)
...;
hors:
if (i==0)
break hors;
else
continue hors;
Une méthode est l'équivalent d'une fonction en C ou C++. Elle se déclare exactement de la même manière : returnType name(parameters) { // body } sauf l'absence du point virgule en fin de déclaration.
Chaque méthode doit renvoyer une valeur à moins d'avoir été déclarée comme void. Exemple :
int surface ( int longueur, int largeur )
{
return longueur * largeur ;
}
La même méthode, insérée dans sa classe, donnerait ceci :
Class Rectangle
{
int i;
int surface ( int longueur, int largeur )
{
return longueur * largeur ;
}
}
Une méthode peut être précédée des modifieurs protected, private ou public. Protected signifie que la méthode est uniquement disponible pour sa classe d'origine et ses classes dérivées. Public signifie que la méthode est disponible pour n'importe quelle classe. Private est utilisé lorsque seule la classe où la méthode a été déclarée peut utiliser celle-ci et même pas les sous-classes.
Un autre modifieur est friendly. Une méthode friendly est accessible uniquement pour la classe courante et celles qui en sont dérivées. Par défaut, c'est le modifieur retenu pour les classes où d'autres modifieurs n'ont pas été utilisés.
Une version spéciale de la méthode private est apelée private protected. Elle désigne des méthodes accessibles pour une classe et ses sous-classes mais pas pour le reste des classes inscrites dans un package.
Une méthode peut être "surchargée" en en déclarant plus d'une version avec des paramètres différents. Exemple :
int surface (int longueur, int largeur);
float surface (float longueur, float largeur);
Le compilateur détermine quelle méthode invoquer en fonction des paramètres passés à cette méthode.
Le modifieur static indique qu'une variable ou une méthode est identique pour toutes les classes. Une variable déclarée comme statique sera la même pour toutes les instances d'une classe. Exemple :
static int version = 1;
Variables et méthodes statiques ont l'avantage de pouvoir être référencées sans qu'une instance spécifique de la classe ne soit créée. C'est par exemple le cas de la méthode System.Out.println où Out est une variable statique qui vous permet de faire appel à la méthode println sans avoir créé au préalable un objet de la classe System.
La méthode de création en Java est une méthode qui porte le même nom que la classe qu'elle doit initialiser et qui n'a pas de valeur de retour.
Exemple :
class Point
{
protected int abscisse, ordonnée;
public Point ( int x , int y)
{
abscisse = x;
ordonnée = y;
}
}
Avant de pouvoir faire appel à une classe, il faut passer par l'opérateur new qui permet de créer une instance de celle-ci.
Exemple :
class Test
{
public static void main (String args[])
{
Point pt = new Point (5,6)
}
}
La méthode finalize permet à un objet de s'en aller proprement (fermeture de fichiers par exemple) avant que le "garbage collector" automatique ne retire l'objet de la mémoire.
void finalize()
{
...
}
Un package est un groupe de classes réunis dans un seul fichier. Les membres d'une classe qui ne sont pas explicitement déclarés comme public, private ou protected ne peuvent être vus que par les classes du même package.
Le fichier à convertir en package doit simplement être préfixé de la sorte :
package nom_du_package
Pour utiliser une classe appartenant à un package, trois moyens sont disponibles :
monpackage.maclasse x = new monpackage.maclasse(1,2)
import monpackage.maclasse
class test {
maclasse x= new maclasse(1,2)
...
}
import monpackage.*
class test {
maclasse x= new maclasse(1,2)
...
}
L'héritage de classe permet d'utiliser une classe existante pour en dériver une autre sans devoir repartir de zéro. A partir d'une classe d'objets comme voiture, il est possible de créer une classe particulière, la 4x4 qui hérite de toutes les propriétés d'une voiture et à laquelle on n'aura plus qu'à ajouter quelques spécifités. Le mot clé extends permet de signaler au compilateur qu'une classe héritera des propriétés d'une autre. Exemple :
class Quatrequatre extends voiture
{
...
}
Les classes abstraites sont des classes dont les méthodes n'ont pas encore été complétées. C'est le travail des sousclasses de ces classes abstraites de finaliser les méthodes. La classe elle-même est considérée comme abstraite et ne peut être initialisée. Constructeurs, méthodes statiques et méthodes privées ne peuvent être abstraites.
Le mot clé abstract est utilisé comme suit :
abstract returnType methodName(parameters)