Le langage JAVA 1.1 : le résumé

20/11/00
Cours Java 1.1 1
_________________________________________________________
_________________________________________________________
Le langage JAVA 1.1 : le résumé
auteur : Véronique Gaildrat
_________________________________________________________
_________________________________________________________

20/11/00
Cours Java 1.1 2
Table des matières
1.Le langage...............................................................................................................................4
1.1 Syntaxe.......................................................................................................................................4
1.1.1 Expressions...................................................................................................................................... 4
1.1.2 Instructions...................................................................................................................................... 5
1.1.3 Variables ......................................................................................................................................... 6
1.1.4 Types............................................................................................................................................... 6
1.1.5 Tableaux.......................................................................................................................................... 7
1.2 Classes .......................................................................................................................................7
1.2.1 Définition de classes ........................................................................................................................ 7
1.2.2 Variables de classes ......................................................................................................................... 8
1.2.3 Constantes ( mot clef final )............................................................................................................. 8
1.2.4 Interrogation sur les classes.............................................................................................................. 8
1.3 Instances.....................................................................................................................................8
1.3.1 Variables d'instances........................................................................................................................ 8
1.3.2 Création........................................................................................................................................... 9
1.3.3 This................................................................................................................................................. 9
1.3.4 Super............................................................................................................................................. 10
1.3.5 Clones............................................................................................................................................ 10
1.3.6 Comparaison : equals..................................................................................................................... 11
1.3.7 instanceOf...................................................................................................................................... 11
1.4 Contrôle de la visibilité des variables et des méthodes ................................................................11
1.5 Méthodes..................................................................................................................................12
1.5.1 Déclaration de méthodes................................................................................................................ 12
1.5.2 Mode de transmission des paramètres ............................................................................................ 12
1.5.3 Surcharge des méthodes et Constructeurs....................................................................................... 13
1.5.4 Destructeurs [option]...................................................................................................................... 15
1.5.5 Appel des méthodes ....................................................................................................................... 15
1.5.6 Méthodes de classe (mot clef static)................................................................................................ 16
1.5.7 Main.............................................................................................................................................. 17
1.6 Exemple....................................................................................................................................17
2.Héritage (mot clef extends)....................................................................................................18
2.1 Héritage simple.........................................................................................................................19
2.2 Conversion de types ..................................................................................................................19
2.3 Conversion d'objets (typage dynamique) ....................................................................................19
2.4 Polymorphisme - Redéfinition....................................................................................................20
3.Méthodes et classes abstraites................................................................................................20
4.Exceptions.............................................................................................................................21
4.1 Hiérarchie de classes exception..................................................................................................21
4.2 Créer une nouvelle classe exception...........................................................................................21
4.3 Récupérer une exception............................................................................................................21
4.4 Debugger..................................................................................................................................22
4.5 Lever une exception ..................................................................................................................22

20/11/00
Cours Java 1.1 3
4.6 La clause throws.......................................................................................................................22
4.7 La clause finally........................................................................................................................23
5.Input / Output .......................................................................................................................23
5.1 Affichage à l'écran ....................................................................................................................23
5.2 Lecture au clavier......................................................................................................................24
5.3 Entrées/Sorties dans un fichier...................................................................................................25
6.Packages...............................................................................................................................28
7.Interfaces (mot clef implements)............................................................................................30
8.AWT et gestion des événements............................................................................................30
8.1.1 Identification du bouton cliqué....................................................................................................... 31
8.2 Version simple ..........................................................................................................................31
8.3 Version complète (plus complexe) .............................................................................................32
9.Threads.................................................................................................................................35
10. Exemple ............................................................................................................................36

20/11/00
Cours Java 1.1 4
1. Le langage
1.1 Syntaxe
1.1.1 Expressions
Commentaires // fin de ligne commentée
/* commentaire borné aux extrémités */
/** pour javadoc */ pour générer de la doc de façon automatique
Constantes :
-4 // cte entière de type int
4L // entier long de valeur 4
0777 // cte octale
0XFF // hexadécimal
10e45 ou .36E-2 ou 5.62 // cte virgule flottante double
2.56f // cte float
Booléen : true ou false
Caractères :
'a' // caractère a
\n // <RC, LF> \r // <RC>
\t // tab \f // saut de page
\b // back \\ // anti slash
\' // guillemet simple \" // guillemet double
\d // octal \x // hexadécimal
\u // unicode (symboles codés)
Constantes chaînes :
"ceci est une chaîne"
"" // chaîne vide
"ceci est un chaîne avec \" guillemets \" à l'intérieur"
\u2122 // ™ (trade mark)
Opérateurs et expressions :
+
-
*
/// int / int -> int
%// modulo
== // ATTENTION syntaxe du test d'égalité C like !!!!
!= // différent
< <= > >=
&& // ET logique
|| // OU logique
!// NON logique
^// XOR bit à bit
~// NOT bit à bit
<< // décalage à gauche bit à bit
>> // décalage à droite bit à bit
>>> // décalage à droite avec remplissage avec des 0 bit à bit
&// ET bit à bit
|// OU bit à bit

20/11/00
Cours Java 1.1 5
new création d'une nouvelle instance de classe
1.1.2 Instructions
Toute instruction est toujours terminée par un ---> ;
// affectation
i = 1;
// déclaration
int i;
// déclaration avec affectation d'une valeur initiale à la variable
int i = 1;
// initialisation d'une variable d'instance
m.engineStart = True;
// affichage à l'écran d'un message composé de chaînes de carac et de valeurs numériques
System.out.println ("texte entre les guillemets " + entier1 + "...." + string1 + flottant1 + ....);
// bloc d'instructions
{ // dans les structures de contrôle, on peut trouver une instruction
... // ou un bloc d'instructions
}
// instruction conditionnelle
if ( cond )
instruction // ou { bloc d'instructions }
else
instruction; // ou { bloc d'instructions }
// opérateur conditionnel
test ? true_result : false_result; // test true => exécution de true_result, false_result sinon
int smaller = x < y ? x : y;
// branchement conditionnel
switch (variable) // type de base autorisé : byte, char, short, int, long
{case v1 :
{... // accolades si bloc d'instructions
}
break;
case v2 :
instruction;
break;
default : default_result;
}
// boucle for
for (cond. initiales; cond d'arrêt; expression devant faire évoluer vers la cond d'arrêt)
instruction; // ou { bloc d'instructions }
// boucle while
while (cond)
instruction; // ou { bloc d'instructions }
do