Le langage JAVA
- commentaire
- // ligne de commentaire
- x += 5 ; // commentaire
- x += /* commentaire */ 5;
- /** commentaire de documentation (utilisée
par JavaDoc) */
- constante
- entier :
- Décimal 132 -132 ou 132L pour un
long mais pas 0132 (ne pas commencer par un zéro)
- Hexadécimal 0XE3A4 0x3D6
- Octal 0132
- réel : 1.32 1.32e4 1.32E4 sont
des "double", 1.32F 1.32f des "float"
- booléen : true false
- caractère (Unicode): 'A' '\n' newline
'\t' tabulation ... '\0132' '\0xA2'
- chaîne de caractères : "chaine"
"une ligne\ndeux !"
- null : valeur d'une variable qui ne référence
aucun objet.
- identificateur
- nom qui référence/nomme
une classe, une interface, une méthode, une variable,
un package
- commence par une lettre ou $ ou _, puis
est suivi de lettres ou chiffres ou caractères nationaux
(accentués)
- Java distingue la casse majuscule/minuscule.
- convention :
- nom de classe ou interface : ChienDeRace
- méthode ou variable : toutouBatard
- constante (variable final) : MEDOR_QUI_MORD
- type
- type de base :
- pour les valeurs et variables non objets
- entier : byte (8 bits) short (16) int
(32) long (64)
- réel flottant : float (32) double
(64)
- char (16 bits Unicode)
- boolean
- type référence :
- type pour référencer les
objets
- à chaque classe correspond un type
référence de même nom
- les types tableaux sont des types références
- déclaration
de variable
- déclaration : int i ; int i,,j
; int i = 2, j = 3;
<type> <identificateur> [= <valeur d'initialisation>]
;
- visibilité d'une variable dans
le bloc {} où elle est définie
- 3 sortes de variables :
- variable de classe = attribut de la classe
(1 seule pour toute la classe)
- variable d'instance = attribut d'une instance
de la classe (1 par instance/objet)
- variable locale = déclarée
dans une méthode
- initialisation:
- une variable locale DOIT être initialisée
obligatoirement !
- les variables de classe et d'instance
non initialisées recoivent la valeur 0 pour un entier
ou un réel, null pour une chaine, false pour un boolean.
- expression, instruction : comme en C
- mêmes opérateurs sauf :
- . signifie opérateur d'accés
aux attributs ou méthodes d'un objet ou d'une classe :
Chien.nom
- + est aussi la concatenation de String
: "abc" + "def"
- instanceof teste l'appartenance d'un objet
à une classe (ou si un objet implémente une interface)
et retourne un boolean : milou instanceof Chien
- précédence
des opérateurs : les opérateurs les + prioritaires
à l'évaluation sont vers le haut du tableau
|
. |
[] |
() |
|
|
|
|
++ |
-- |
! |
~ |
instanceof |
|
|
* |
/ |
% |
|
|
|
|
+ |
- |
|
|
|
|
|
<< |
>> |
>>> |
|
|
|
|
< |
> |
<= |
=> |
|
|
|
== |
!= |
|
|
|
|
|
& |
|
|
|
|
|
|
^ |
|
|
|
|
|
|
&& |
|
|
|
|
|
|
|| |
|
|
|
|
|
|
?: |
|
|
|
|
|
|
= |
op= |
|
|
|
! évaluation de droite à gauche
! |
|
, |
|
|
|
|
|
- Lorsque l'on effectue
des opérations sur des variables de types différents,
le type du résultat est celui de l'opérande occupant
le plus de place en mémoire :
- int est converti vers long ou double sans
problème, ou vers float (avec perte de préçision
possible)
- float vers double
- long vers double sans problème,
ou vers float (avec perte de préçision possible)
- les déclarations de variable locale
peuvent se faire n'importe où dans un bloc { }
- cast (transtypage) , convertion de type
comme en C : float f = 3.56F ; int i = (int) f ;
- instructions comme en C :
- if else, for, while, do while, switch,
break, continue, return
- attention aux tests qui doivent être
de type boolean
- tableau
- un tableau est une objet qui contient
une collection d'éléments de même type qui
sont accessible par un ou plusieurs index entiers (commencant
à partir de la valeur 0)
- déclaration :
- char tab [] ; char [] tab ; int [][] mat
; int mat [][];
- <type> [] <identificateur>
;
- <type> <identificateur> []
;
- instanciation (création) :
- tab = new char [7]; mat = new int [5]
[6] ; float tab2 [] = new float [7] ;
boolean grille [] [] = { { false, true, false}, {true, false,
false}};
- <nom> = new <type> [<taille>];
instanciation
- <type> <nom> [] = new <type>
[<taille>]; déclaration/instanciation
- <type> <nom> [] = { <liste
des éléments du tableau }; déclaration/instanciation/initialisation
- accès aux éléments
comme en C
l'accès en dehors des indices valides provoque une exception
IndexOutOfBoundException
- longueur du tableau : tab.length
1ere dimension : mat.length, seconde mat[0].length
- un tableau est une variable d'instance,
exemple mat.
- comme tout objet java, elle hérite
des méthodes et attributs de la classe Object.
- mat instanceof int[][] est true
- la classe de mat2 est int[][]
- déclaration de classe
- classe = modéle/type pour des objets,
qui précise les attributs (états de l'objet) et
méthodes (comportements)
- public class Chien {
public String couleur;
public void aboie () { System.out.println("Houah!
Houah!"); }
};
[<modificateurs d'accès>] class <nomClasse>
[<extends> <SuperClasse>] [implements <interfaces>]
{ <attributs> <méthodes> }
- modificateurs d'accès = visibilité,
....
extends précise que la déclaration de la présente
classe hérite d'une autre (super)classe
implements précise que la déclaration de la présente
classe implémente certaines interfaces (il s'agit d'une
forme d'héritage multiple)
- les attributs sont les champs/caractéristiques,
sur l'exemple : couleur
les méthodes sont les messages/fonctions/actions applicables,
sur l'exemple : aboie
- package, import
- import java.io.* ;
System.out.printl("valeur de pi = " + java.lang.Math.PI);
- La librairie standard de Java est organisée
en arborescence de package, qui sont des sous-ensembles fonctionnels
de classes et d'interfaces.
- L'accès à un package ou
une Classe d'un package se fait en donnant le chemin dans cette
arborescence, chaque nom de package (sous-package) étant
séparé par un point.
- l'instruction import permet "d'importer"
un ou plusieurs packages : les classes importées peuvent
être alors nommées sans leur "chemin".
- L'étoile dans un import ne désigne
que tous les sous-packages directement en dessous du package
nommé : java.awt.* ne désigne pas java.awt.color.*
- il est possible de déclarer un
package en ajoutant à tous les fichiers sources concernés
le 1ère ligne :
package <nomDePackage>;
- objet
- Création d'un objet : new
Chien milou ; milou = new Chien() ; Chien médor = new
Chien() ;
[<nomClasse>] <variable> = new <nomClasse>(<paramètres>)
;
- l'opérateur new crée une
instance d'une classe en faisant appel à une méthode
constructeur s'il y a, et renvoie une référence
sur l'objet instancié
instanciation = créer un objet à partir d'une classe
objet = instance de classe qui posséde une "copie"
des attributs et méthodes de la classe
- accès aux variables et méthodes
d'un objet :
- milou.couleur = "blanc" ;
médor.couleur = milou.couleur ;
médor.aboie();
- <nomObjet>.<variable> pour
accéder à un attribut sous réserve de visibilité
et des modificateurs
- <nomObjet>.<méthode>([<paramètres
effectifs>]) pour envoyer un message à
cet objet ou encore appeler/exécuter une méthode
sur l'objet désigné : dans l'exemple, le message
aboie est envoyé à médor, ce qui provoque
l'exécution de la méthode nommé; le mode
passage des paramètres est par valeur pour les types simples
et par référence pour les tableaux, chaines de
caractères et objets.
- destruction d'un objet :
- automatique dès que l'objet n'est
plus référencé par aucune variable ou aucun
autre objet.
- la méthode finalise() est appelée
avant la destruction de l'objet : elle peut être redéfinie.
- attribut
- variable d'instance :
- définit l'attribut d'une seule
instance d'une classe : donc un attribut attaché à
chaque objet de la classe
- par exemple couleur de la classe Chien
- [<modificateurs>] <type> <nomVariable>
[= <valeur>] ;
où modificateur peut être final, public, private,
protected, private protected, volatile, transcient
- variable de classe :
- définit l'attribut de la classe
: donc un attribut attaché à la classe qu'elle
posséde 1 ou plusieures instances ou aucune,
- public class BergerAllemand {
static public String couleur = "marron"
;
public String nom ;
public void aboie () { System.out.println("Houah!
Houah!"); }
};
- static [<modificateurs>] <type>
<nomVariable> [= <valeur>] ;
où modificateur peut être final, public, private,
protected, private protected, volatile, transcient
- méthode
- méthode d'instance :
- définit un comportement de l'objet,
un traitement qui ne peut être déclanché
qu'en envoyant un message à un objet de la classe
- par exemple aboie de la classe Chien
- [<modificateur>] <type> <nomMéthode>
([<paramètres formels>]) { <corps de la méthode>
}
- méthode de classe :
- public class Chien {
public String couleur;
public static int nombreDePattes () { return
4; }
}
- définit un comportement de la classe,
un traitement qui peut être déclanché sans
instance de la classe à la classe elle-même : System.out.println("nombre
de pattes d'un chien : " + Chien.nombreDePattes() );
- [<modificateur>] static <type>
<nomMéthode> ([<paramètres formels>])
{ <corps de la méthode> }
- ne peut affecter que des variables de
classe (donc static)
- généralités :
- une méthode définit un comportement
comme une procédure ou une fonction
- le type de la valeur renvoyé peut-être
void, un type simple ou une référence d'objet.
Sauf pour void, la valeur est renvoyé par une instruction
return <valeur> ; dans le corps de la méthode
- le mode passage des paramètres
est par valeur pour les types simples et par référence
pour les objets, donc tableaux et chaines de caractères.
- signature et surcharge :
- public class Chien {
public void aboie () { System.out.println("Houah!
Houah!"); }
public void aboie (int nbre) { for (int i =
0 ; i < nbre ; i++ ) System.out.println("Houah!");
}
public void aboie (String aboiement) { System.out.println(aboiement
+ " " + aboiement); }
};
les accès sont alors : milou.aboie(); médor.aboie("Grrrr");
milou.aboie(5);
- la signature d'une méthode est
constituée du nom de la méthode, du nombre et du
type de ses paramètres, et du type qu'elle renvoie.
- la surcharge d'une méthode dans
une classe consiste à définir des méthodes
de même nom mais de signature différente au niveau
des paramètres.La surcharge est une forme de polymorphisme.
- constructeur
- une méthode constructeur est une
méthode appelée au moment de la création
d'une instance par l'opérateur new.
- public class Chien {
public String couleur;
public Chien () { couleur = "inconnue";
}
public Chien (String c) { couleur = c; }
}
Chien médor = new Chien() ; Chien milou; milou = new Chien("blanc");
- [<modificateur>] <nomClasse>
([<paramètres formels>]) { <corps de la méthode
constructeur> }
où les modificateurs peuvent être public, private,
protected, ou sans.
- généralités :
- Un constructeur ne retourne pas de valeur
- Un constructeur ne peut pas être
appelé sauf par l'opérateur new.
- Un constructeur peut être surchargé
ou redéfini.
- le constructeur par défaut est
:
- soit implicite, c'est à dire non
défini : il initialise alors les attributs
- soit explicite, c'est à dire défini
: il doit alors être sans paramêtre
- application, applet
- la compilation d'un fichier source (nommé TelleClasse.java)
contenant la classe TelleClasse produit un fichier (exécutable
en bytecode) de nom TelleClasse.class. La commande est : javac
TelleClasse.java
- application
Java :
- c'est un programme autonome qui exécute
un ou plusieurs fichier .class, et dont un (celui qui est lancé
en premier) doit posséder une méthode : public
static void main (String args []) { <corps du "programme
principal"> }
- la ligne de commande d'éxécution
est : java ClasseContenantMain argument0 argument1 ....
- Les arguments, s'il y en a, sont des String
et sont indexés à partir de 0.
- applet Java :
- ne peut être exécuter que
par un navigateur Web compatible Java, ou la commande appletviewer
du JDK.
- import java.awt.*;
public class MonApplet extends java.applet.Applet {
public void paint( Graphics g) { g.drawString("Hello
Word !", 10, 20); } }
- Une applet doit être composée
d'au moins une sous-classe de Applet et éventuellement
d'autres classes auxilliaires.
- Pour charger une applet dans une page
HTML :
<applet
code="nomApplet.class"
codebase="chemin d'accès commencant par http://"
width=valeur
height=valeur>
attention ! navigateur sans java
</applet>
- Elle ne possède pas de méthode
main() mais d'une ou plusieures méthodes parmi les méthodes
init() start() stop() destroy() paint() héritées
de la super-classe Applet :
- init() est lancée par le Navigateur
dès que le chargement de l'applet est terminé,
- start() est lancée après
init() et à chaque re-chargement de la page html,
- paint() est lancée à chaque
fois que l'applet est rendue visible; cette méthode peut
récupérer le paramètre Graphics utile pour
dessiner,
- stop() est lancée quand la navigateur
change de page ou quand l'applet se termine ou avant destroy()
- destroy() est lancée à la
fermeture du navigateur.
- la classe Applet hérite de la classe
Panel, composant graphique.
- héritage, sous-classe,
super-classe
- public class Chien {
public String couleur;
public String nom ;
public Chien () { couleur = nom = "inconnu";
}
public void aboie () { System.out.println("Houah!
Houah!"); }
public void aboie (int nbre) { for (int i =
0 ; i < nbre ; i++ ) System.out.println("Houah!");
}
}
public class ChienDeRace extends Chien {
public String race;
public ChienDeRace (String r) { race = r; }
public void aboie () { System.out.println("Wouf!
Wouf!"); } // c'est plus distingué un chien de race
!
}
- la classe ChienDeRace hérite de
la classe Chien : la classe Chien est la super-classe de la classe
ChienDeRace, et la classe ChienDeRace est une sous-classe de
la classe Chien, ce qui constitue une hièrarchie.
- Une classe n'hérite que d'une super-classe
: c'est l'héritage simple.
- la sous-classe hérite de tous les
attributs et méthodes de sa super_classe.
- redéfinition
de méthode :
- A l'appel d'une méthode, celle-ci
est d'abord recherchée dans la classe de l'objet; si elle
n'y est pas définie, elle est recherchée dans sa
super-classe, et ainsi de suite dans la hiérarchie de
classe.
- une méthode héritée
d'une super-classe peut-être redéfinie dans une
sous-classe. Cette redéfinition masque la méthode
héritée.
- C'est une forme de polymorphisme.
- au niveau de la sous-classe, l'accès
aux méthodes et attributs ainsi que la redéfinition
de méthode (ou constructeur) dépends des modificateurs
d'accès de ses attributs et méthodes dans la super-classe.
- si un constructeur est définit
dans une sous-classe :
- si il n'appelle pas explicitement le constructeur
this() ou super (), alors un appel à super() est effectué,
- Si le constructeur appelle this() ou super(),
ce doit être sa 1ère instruction.
- SIMPLIFIONS : un constructeur par défaut
explicite doit exister dans la super-classe.
- modificateur d'accès
- final
- variable locale final = constante
- attribut/variable d'instance final = constante
- méthode d'instance final = méthode
non surchargeable et non redéfinissable
- classe final = ne peut avoir de sous-classe
- static
- attribut static = variable de classe =
existe en un seul exemplaire quelque soit le nombre d'instanciation
(ou sans instanciation)
- méthode static = méthode
de classe = méthode "sans envoi de message"
appliquée à la classe et non à un objet.
- code static = static { instructions }
initialise les variables static d'une classe
- public
- public = la variable ou la méthode
(ou le constructeur) ou la classe est accessible partout
- variable d'instance : rarement public
sauf si final.
- private
- les variables ou les méthodes (ou
constructeurs) ne sont accessibles que par les membres internes
de la classe
- protected
- protected = les variables ou les méthodes
(ou constructeurs) ne sont accessibles que par les membres internes
de la classe, de ses sous-classes et des classes du même
package.
- classe protected = accessible que par
ses sous-classes et des classes du même package.
- private
protected
- les variables ou les méthodes ne
sont accessibles que par les membres internes de la classe, de
ses sous-classes.
- pas de modificateur d'acces :
- acces package = les variables ou les méthodes
(ou constructeurs) ou classes ne sont accessibles que par les
membres internes de la classe, et des classes du même package.
- abstract :
- une méthode abstraite ne contient
pas de corps, mais doit être implémentée
dans les sous-classes,
- une classe est abstraite si elle contient
au moins une méthode abstraite ; elle ne peut pas être
instanciée, mais ses sous-classes non abstraites le peuvent.
- une interface est par défaut abstraite.
- autre modificateurs :
- native : méthode écrite
en C dans un fichier externe
- synchronized : variable à accès
en exclusion mutuelle pour les threads
- transcient
- volatile
- this, super
- deux autres constructeurs pour la classe
Chien :
public Chien (String n) { couleur = "inconnu";
nom = n ;}
public Chien (String n, String c) { this(n)
; couleur = c; }
- une autre méthode et deux autres
constructeurs pour la classe ChienDeRace :
public void compte (int nbre) { if (nbre ==
2) this.aboie(); else super.aboie(nbre); } // un chien de race
sait compter !
public ChienDeRace (String n, String c, String
r) { super(n, c); race = r; }
public ChienDeRace (String n, String r) { race
= r; super.nom = n; }
- this fait référence à
l'objet en cours, super fait référence à
la super-classe de l'objet en cours et sont utilisable :
- suivi d'un point pour accéder à
une méthode ou un attribut de l'instance,
- en passage de paramètre à
une méthode,
- en valeur de retour.
- this(<paramètres>) appelle
une méthode constructeur, et ne peut être utilisée
qu'en première instruction dans un corps de constructeur.
- super(<paramètres>) appelle
une méthode constructeur déclarée par la
super-classe de l'objet en cours, et ne peut être utilisée
qu'en première instruction dans un corps de constructeur.
- interface
- public interface AnimalSavant { public
void compte(int nbre) ; }
public class Chien implements AnimalSavant {
public String couleur;
public Chien () { couleur = "inconnu";
}
public void aboie () { System.out.println("Houah!");
}
public void compte (int nbre) { for (int i
= 0 ; i < nbre ; i++ ) this.aboie(); }
}
// dans la classe Grenouille, l"implémentation de
l'interface AnimalSavant est différente !
- une interface ne comporte que des constantes
et des méthodes abstraites. Elle n'est pas"classe
abstraite"
- Une classe peut implémenter une
ou plusieures interfaces, c'est à dire définir
le corps de toutes les méthodes abstraites. C'est
l'héritage multiple de Java.
- [<modificateurs d'accès>]
interface <nomInterface> [implements <interfaces>]
{
<constantes> <méthodes abstraites>
}
- les modificateurs d'accés de l'interface
peuvent être public ou (sans) package ;
- les constantes sont explicitement ou implicitement
static et final :
[<modificateurs>] <type> <nomVariable> = <valeur>;
[<modificateurs>] static final <type> <nomVariable>
= <valeur> ;
- les méthodes sont explicitement
ou implicitement abstraites :
[<modificateur>] <type> <nomMéthode>
([<paramètres formels>]);
[<modificateur>] abstract <type> <nomMéthode>
([<paramètres formels>]);
- Une classe qui implémente une interface
doit définir le corps de toutes ses méthodes
abstraites.
- les sous-classes d'une super-classe qui
implémente une interface, héritent (et peuvent
redéfinir) des méthodes implémentées.
- Une interface peut hériter (par
extends) d'une autre interface et en implémenter (par
implements) d'autres.
- exception
- try { int x=System.in.read(); System.out.println("caractère
lu :" + (char)x); }
catch (IOException e) {System.out.println(e.getMessage());}
- public char litUnChar() throws IOException
{ int x=System.in.read(); return (char)x ;}
- L'exécution de certaines instructions
ou méthodes peuvent lever des (erreurs d'exécution)
exceptions. Celles-çi sont organisées en classe,
par exemple, la classe RuntimeException regroupe les incidents
du genre : division par 0 (ArithmeticException), en dehors des
bornes d'un tableau (IndexoutOfBoundsException), méthode
appliquée à une référence nulle (NullPointerException),
...
- try ... catch, capture d'exception
:
- try { bloc d'instructions pouvant lever
des exceptions }
catch {type_d_exception e) { traitement de e} // définit
l'exception à capturer et son traitement
catch {autre_type_d_exception e) { traitement de e}
- dès qu'une exception est levée
dans le corps de try, le traitement de ce corps est terminé
et catch définit le traitement de l'exception capturée.
- finally dans un
try ... catch :
- try { bloc d'instructions pouvant lever
des exceptions }
catch {type_d_exception1 e) { traitement1 de e}
catch {autre_d_exception2 e) { traitement2 de e}
finally { corps toujours exécuté }
- le traitement du corps de la clause finally
est toujours exécuté qu'une exception ait été
levée et donnée lieu à un traitement "catch",
ou qu'aucune erreur ne soit survenu au cours du corps de try.
- throws, décaler/propager
une exception :
- [<modificateur>] <type> <nomMéthode>
([<paramètres>]) throws <liste d'exceptions>
{ <corps de la méthode pouvant lever des exceptions
> }
- les exceptions listées sont propagées/transmises
à la méthode appelante si elles sont levées
dansle corps de la méthode traitée.
- Donc une exception peut être propagée
jusqu'à une méthode appelante qui la capture et
la traite.
- Il n'est pas obligatoire de capturer ou
propager les exceptions (unchecked) non contrôlées
: les Error et RunTimeException. Mais une exception levée
non propagée et non capturée finit par provoquer
l'arrêt de la "méthode du programme principal".
- Les Exceptions de la classe des IOException
doivent être obligatoirement capturées ou propagées.
- Il est possible de créer des nouvelles
sous-classes d'Exception et de générer/lever de
telles exceptions par l'instruction throw.
- classe
abstraite :
- une méthode abstraite ne contient
pas de corps, mais doit être implémentée
dans les sous-classes non abstraites : abstract nomDeMéthode
(<arguments>); ce n'est qu'une signature
- une classe est abstraite si elle contient
au moins une méthode abstraite ; elle ne peut pas être
instanciée, mais ses sous-classes non abstraites le peuvent.
- abstract class NomDeClasseAbstraite {
... }
une classe abstarite est déclarée avec le modificateur
abstract.
- une classe est abstraite ne peut être
instanciée.
- une classe est abstraite peut contenir
des méthodes non abstraites et des déclarations
de variables ordinaires.
- Une classe abstraite peut être dérivée
en une sous-classe :
- abstraite si une ou plusieures méthodes
ne sont pas implémentées par la classe fille,
- abstraite si toutes les méthodes
abstraites sont implémentées dans la classe fille.
- thread
:
- un thread est un processus "léger",
c'est à dire que plusieurs threads partagent le même
espace d'adressage, les mêmes variables d'instances.
- class Chien implements Runnable {
String nom ;
....
public void run() { // vie de chien
while (true)
{ dors(); mange(); aboie(); }
}
- le code exécuté par le thread
doit se trouver dans une méthode run(), en :
- créant une sous-classe de la classe
Thread
- en implémentant l'interface Runnable
: cas général !
- le thread est "lancé"
en instanciant un objet Thread dont le code est celui de la classe
spécifié, puis par l'appel de la méthode
start() :
- class Chien implements Runnable {
Thread vieDeChien;
Chien( String nom) {
vieDeChien =
new Thread(this);
vieDeChien.start();
...
- cast
de type référence :
- le cast ou transtypage de "classe"
permet de modifier le type apparent de référence,
mais pas l'objet.
- class Chien extends Mammifere { ...}
Chien milou = new Chien();
Mammifere telAnimal = milou; // cast
implicite
milou = (Chien)telAnimal; // cast explicite
milou = telAnimal; // erreur à
la compilation
- il est toujours possible de convertir
un type dans un type moins spécialisé de la branche
d'héritage : le cast est implicite.
- Si un objet est bien d'un type spécialisé
dans l'arbre d'héritage, alors il est possible, par un
cast explicite, de le convertir dans ce type spécialisé.
Classes et Interfaces
de Base
- classe Object :
- c'est la super-classe de toutes les classes
JAVA
- méthodes :
- getClass() renvoie des informations sous
la forme d'un objet de la classe Class
- equals(Object autreObjet) retourne true
si les 2 références autreObjet et this désignent
le même objet.
- toString() "par défaut"
renvoie le nom de la classe suivi de @ suivi de la valeur de
hachage de l'objet
- finalize() est appelée avant la
destruction automatique (ssi aucune référence sur
l'objet) d'un objet ; elle est à re-définir.
- clone() instancie un nouvel objet qui
est une copie de this. Uniquement si la classe de l'objet implémente
l'interface Clonable.
- classe Class :
- permet d'accéder aux informations
sur les classes.
- il existe un objet Class pour toute classe
utilisée.
- méthodes :
- getName() retourne le nom (String) de
la classe
- getSuperClass() renvoie des informations
(de type Class) sur la super-classe de la classe
- toString() = getName() + "class"
ou "interface" selon le cas
- newInstance() produit une nouvelle instance
du type de l'objet
- opérateur :
- objet instanceof classe retourne true
si l'objet est appartient à cette classe (directement
ou par héritage)
- classe System :
- permet d'accéder aux ressources
du système
- dont la variable static out, canal de
sortie (affichage) de type PrintStream (qui posséde les
méthodes println et print)
d'où la facilité d'affichage d'un Objet par le
message :
- System.out.print(referenceAlObjet)
- System.out.println(referenceAlObjet) avec
ajout d'un passage à la ligne
- classe Runtime
:
- permet d'accéder à l'environnement
d'exécution.
- classes conteneur de types de données :
- Ce sont des classes qui fournissent une
version objet des types simples, par exemple : la classe Integer
pour int
- méthodes communes :
- Integer(valeur) constructeur d'un objet
à partir d'une valeur
- toString() renvoie une chaîne "ascci"
représentant la valeur
- valueOf() renvoie la valeur en type simple,
par exemple un int pour Integer
- classe Boolean
- classe Character
:
- static boolean isLowerCase(char car),
donc utilisable sous la forme Character.isLowerCase('a')
- static boolean isUpperCase(char car)
- static boolean isDigit(char car)
- static char toLowerCase(char car)
- static char toUpperCase(char car)
- classe Integer
:
- attributs final static MIN_VALUE et MAX_VALUE
- static int parseInt(String s)
- long longValue()
- float floatValue()
- double doubleValue()
- classe Long
- classe Float :
- attributs final static MIN_VALUE, MAX_VALUE,
NEGATIVE_INFINITY, POSITIVE_INFINITY, NaN ("Not a Number")
- boolean isNaN()
- boolean isInfinite()
- int intValue()
- float floatValue()
- double doubleValue()
- classe Double
- classe Math :
- classe finale composée de méthodes
uniquement static
- attributs final static E et PI
- méthode à résultat
int :
- abs(int)
- round(float)
- min(int,int), max(int,int)
- méthode à résultat
long :
- abs(long)
- round(double)
- min(long,long), max(long,long)
- méthode à résultat
float :
- abs(float)
- min(float,float), max(float,float)
- méthode à résultat
double :
- random()
- abs(double), ceil(double), floor(double),
- sin(double), cos(double), tan(double)
- asin(double), acos(double), atan(double)
- exp(double), log(double), sqrt(double)
- pow(double,double), min(double,double),
max(double,double)
- classe String :
- classe qui implémente les chaines
constantes = tableau constant de caractères
- constructeurs :
- String("abc")
- String(char tab[])
- String(StringBuffer s)
- méthodes :
- int length()
- char charAt(int indice) retourne le caractère
à la position indiquée (1er caractère à
l'indice 0)
- int indexOf(int car) indice de la 1ére
occurence du caractère
- int indexOf(int car, int posDepart) indice
de la 1ére occurence du caractère après
la position indiquée
- int lastIndexOf(int car) indice de la
derniére occurence du caractère
- boolean equals(String a_comparer)
- int compareTo(String a_comparer) retourne
une valeur positive si this est > à String a_comparer,
Oà si =, sinon une valeur négative
- String subString(int posDepart, int posFin)
- String toUpperCase()
- String valueOf(nombre) retourne une chaine
représentant le nombre
- classe StringBuffer
:
- comme String mais la chaine est de longueur
variable et évolutive
- constructeurs :
- StringBuffer(String)
- StringBuffer(int longueur)
- méthodes :
- int length()
- String toString()
- char charAt(int indice) retourne le caractère
à la position indiquée (1er caractère à
l'indice 0)
- StringBuffer append(String mot)
- StringBuffer append(Object)
- StringBuffer insert(int posDepart, String
s)
- interface Enumeration
:
- ensemble de méthodes pour éffectuer
une énumération sur une liste, une itération
des divers éléments d'une liste.
- Un tel objet ne peut servir que pour une
itération.
- 2 méthodes :
- hasMoreElements() retourne true s'il reste
des éléments à itèrer
- nextElement() retourne une référence
sur un nouvel objet de l'énumération
- classe Vector :
- un vecteur implémente une liste/tableau
de taille variable d'objets
- constructeurs :
- Vector() crée un vecteur vide
- Vector(int nombre) crée un vecteur
vide de capacité précisé.
- attributs :
- elementCount nombre d'éléments
du vecteur
- méthodes :
- isEmpty() retourne true si le vecteur
est vide
- size() retoune le nombre d'éléments
du vecteur
- addElement(Objet) ajoute un élément
à la fin du vecteur
- insertElementAt(Objet, int position) ajoute
un élément à la position spécifiée
(le 1er élément est en 0)
- contains(Objet) retourne true s'il l'Objet
se trouve dans le vecteur
- ElementAt(int position) retourne l'élément
à la position spécifiée
- indexOf(Objet) retourne la position de
la 1ére occurence de l'Objet dans le vecteur
- removeElementAt(int position) supprime
l'élément à la position spécifiée
- elements() retourne une Enumeration du
vecteur
- classe StringTokenizer
:
- découpe une chaîne de caractères
en "mots" selon certains séparateurs ; les séparateurs
sont précisés ou par défaut : espace, tabulation,
retour-chariot et newline
- constructeurs :
- StringTokenizer(String chaine) découpe
la chaîne selon les séparateurs par défaut
- StringTokenizer(String chaine, String
Séparateurs) découpe la chaîne selon les
Séparateurs précisés
- méthodes :
- countTokens() retourne le nombre de "mots
à séparer" qui reste dans la chaine
- hasMoreTokens() retourne true s'il reste
des "mots à séparer" dans la chaine
- nextToken() retourne un nouveau "mot"
(String ) séparé de la chaine String
- interface
Set
- Set est une interface qui modèlise
les fonctionnalités des ensembtes :
- isEmpty() méthode qui détermine
si l'ensemble est vide
- contains() détermine si un élément
est dans l'ensemble
- containsAll() détermine si une
collection d'élément est incluse dans l'ensemble
- add() ajoute un élément
à l'ensemble
- ...
- TreeSet et HashSet sont 2 classes qui
implémente l'interface Set :
- TreeSet est un arbre d'éléments
ordonnés selon l'ordre ascendant
- HashSet est une table d'élément
accessible par une clef de recherche.
- interface
Comparable
- L'interface Comparable modélise
les objets qui possèdent un ordre total :
- la seule méthode est compareTo(autre)
qui renvoie un entier positif si l'objet est supérieur
à l'autre, 0 s'ils sont égaux, et négatif
sinon.
- Cette interface permet d'utiliser des
collections d'objets ordonnés comme TreeSet
AWT
Abstract Widget Toolkit
- héritage des widgets
- classe Component
:
- La plupard des Classes de l'AWT hérite
de la classe abstraite Component.
- méthodes :
paint(Graphics g) est la méthode appelée à
chaque fois que le contenu du composant doit être redessiné
(la 1ére fois, quand il fut masqué puis démasqué,
...); elle est à re-définir en spécifiant
tout ce qui doit être dessiné.
repaint() provoque un appel à paint(), donc redessine
le contenu du composant.
getGraphics() renvoie le contexte graphique de type Graphics
du composant : c'est à dire la trousse pour dessiner actuelle
setVisible(boolean visible) affiche ou masque le composant
setEnabled(boolean actif) active ou non le composant, c'est à
dire le rend sensible aux événements.
getSize() donne la dimension actuelle du composant, retourne
le type Dimension qui est utilisable ainsi : getSize().height
et getSize().width
getPreferedSize() donne la taille "idéale" du
composant, retourne le type Dimension
setSize(Dimension d) redimensionne le composant à la dimension
indiquée
setSize(int largeur, int hauteur) redimensionne le composant
move(int coordX, int coordY) déplace le composant au point
indiqué (coin haut et gauche)
setForeground(Color couleur) définit la couleur d'avant-plan
(de dessin) du composant
setBackground(Color couleur) définit la couleur de fond
setCursor(Cursor curseur) définit le curseur
- classe Container
:
- classe abstraite pour les composants qui
contiennent et gérent d'autres composants
- Chaque container posséde un gestionnaire
de placement par défaut, layout ou "geometry manager",
qui range les composants graphiques fils dans le container.
Il est possible de ne pas les utiliser en placant chaque composant
à l'aide de la méthode setLocation(int coordX,
coordY)
- méthodes :
setLayout(LayoutManager manager) spécifie le geometry
manager qui rangera (arrangera) les composants contenus.
add(composant) ajoute un composant dans le container.
- classe Frame :
- "cadre" : fenêtre top-level
conteneur d'une application avec barre de titre et des boutons
de fermeture, plein écran, iconification.
- le layout par défaut est BorderLayout
- contructeurs :
Frame() crée une fenêtre sans titre
Frame(String titre) crée une fenêtre avec titre
- méthodes :
setTitle(String titre) spécifie le titre
setMenuBar(MenuBar) applique une barre de menu en haut du cadre
setResizable(boolean) détermine si le cadre peut être
redimensionné par l'utilisateur
- les événements générés
par le composant Frame sont :
- WindowOpened, WindowClosing, WindowClosed,
WindowIconified, WindowDeiconified, WindowActivated, WindowDeactivated.
- classe Panel :
- "panneau" : composant conteneur
d'autres composants
la classe Applet hérite de Panel
- le layout par défaut est FlowLayout
- contructeurs :
Panel() crée un Panel
Panel(LayoutManager manager) crée un Panel avec le geometry
manager spécifié
- les Layout :
- 5 gestionnaires de placement, geometry
manager, qui rangent des composants graphiques dans un container.
Il est possible de ne pas les utiliser en placant chaque composant
dans un Panel à l'aide de la méthode setLocation(int
coordX, coordY)
- FlowLayout :
- range de gauche à droite et de
haut en bas.
- FlowLayout() range les composants en les
centrant avec un "vspacing et hspacing" (espace vertival,
respectivement horizontal) de 5 pixels.
FlowLayout(int aligne) range les composants en les alignant selon
aligne : FlowLayout.LEFT, FlowLayout.CENTER, FlowLayout.RIGHT
avec un vspacing et hspacing de 5 pixels.
FlowLayout(int aligne, int hspacing, int vspacing) range selon
l'alignement et le vspacing et le hspacing spécifiés.
- GridLayout :
- range dans une grille/matrice de gauche
à droite et de haut en bas
- GridLayout(int ligne, int colonne) range
les composants dans la grille de rangement
GridLayout(int ligne, int colonne, int hspacing, int vspacing)
idem avec le vspacing et le hspacing spécifiés.
- BorderLayout :
- divise un composant container en 5 zones:
North, East, South, West, Center
- BorderLayout() crée 5 zones
- BorderLayout(int hspacing, int vspacing)
idem avec un espacement spécifié.
- la méthode add est par exemple
add("North", composant)
- CardLayout : range comme une pile de cartes,
- GridBagLayout : range dans une grille de cases de tailles variées.
- classe Label :
- étiquette : affiche un petit texte/message
- constructeurs :
Label() crée une étiquette sans texte
Label(String texte) crée une étiquette avec texte
aligné à gauche
Label(String texte, int aligne) crée une étiquette
avec texte aligné selon aligne : Label.LEFT, Label.CENTER,
Label.RIGHT
- méthodes :
setText(String texte) spécifie le texte
getText() retourne le texte de l'étiquette
setAlignment(int aligne) spécifie l'alignement
getAlignment()
- classe Button :
- bouton : permet le déclanchement
d'action
- constructeurs :
Button() crée un bouton sans texte
Button(String texte) crée un bouton avec texte centré
- méthodes :
setLabel(String texte) spécifie le texte du bouton
getLabel() retourne le texte du bouton
setActionCommand(String texte) spécifie le nom de l'action
du bouton
getActionCommand() retourne le nom de l'action du bouton
addActionListener(ActionListener écouteur) met un "écouteur"
d'événement sur le bouton
removeActionListener(ActionListener écouteur) supprime
un "écouteur" d'événement sur
le bouton
- Button envoie un événement
Action quand on clique dessus
- interface ActionListener :
- les événements sont des
actions ou des effets indirects d'action de l'utilisateur du
GUI (Interface Graphique Utilisateur) : clic de souris, frappe
de touche, fenêtre masquée par une autre, ...qu'il
faut gérer : en mettant en place un "écouteur"
de l'événement souhaité sur le composant
graphique considéré, puis définir le comportement
(les instructions à éxécuter, le handler
d'événement) lorsque l'événement
surviendra.
- ActionListener est une interface pour
écouter et traiter les ActionEvents
- Par exemple, bouton.addActionListener(composant)
met un écouteur (d'ActionEvent) sur le bouton, le "handler"
sera assurée au niveau du composant désigné
qui implémente l'ActionListener; pour un bouton,l'ActionEvent
est provoquée par un clic de souris (bouton enfoncé
puis relaché).
- la classe qui implémente l'interface
ActionListener doit définir la méthode :
public void actionPerformed(ActionEvent e) { ... qui est le "handler"
getActionCommand() est une méthode de ActionEvent récupère
le nom de la commande d'action associé au composant par
exemple un bouton (par défaut son label).
- classe TextField
:
- champ texte pour saisir et/ou afficher
du texte modifiable
- constructeurs :
TextField() crée un champ sans texte
TextField(int nombre) crée un champ sans texte d'une largeur
de nombre caractères
TextField(String texte) crée un champ avec texte
TextField(String texte, int nombre) crée un champ avec
texte et d'une largeur de nombre caractères
- méthodes :
setText(String texte) spécifie le texte du champ
getText() retourne le texte contenu dans le champ
getColumns() retourne la largeur du champ en nombre caractères
setColumns() définit la largeur du champ en nombre caractères
setEditable(boolean modifiable) spécifie si le texte du
champ est modifiable
isEditable() retourne un boolean qui indique si le texte du champ
est modifiable
setEchoChar(char masque) spécifie le caractère
de masquage de la saisie (pour les passwords)
echoCharIsSet() retourne un boolean qui indique si le masquage
est en vigueur
getEchoChar() retourne le caractère de masquage
addActionListener(ActionListener écouteur) met un "écouteur"
d'événement sur le composant
removeActionListener(ActionListener écouteur) supprime
un "écouteur" d'événement
- classe TextAera
:
- éditeur de texte pour saisir et/ou
afficher du texte modifiable sur plusieures lignes, muni de barres
de défilement et de comportements prédéfinies
: sélection de texte à la souris, raccourci clavier
copier/coller, ...,
- constructeurs :
TextAera() crée un éditeur sans texte
TextAera(int ligne, int largeur) crée un éditeur
sans texte d'une largeur en nombre de caractères et d'un
nombre de lignes spécifiés.
TextAera(String texte) crée un éditeur avec texte
TextAera(String texte, int ligne, int largeur) crée un
éditeur avec texte et d'une largeur et d'un nombre de
lignes spécifiés.
- méthodes :
insertText(String texte, int position) insère le texte
à la position indiquée
replaceText(String texte, int départ, int fin) remplace
les caractères entre les positions indiquées par
le texte spécifié
et les mêmes méthodes que TextField
- classe Canvas :
- canevas : c'est une planche à dessin
ou à afficher les images
- doit être héritée
pour bénéficier de la méthode :
- méthodes :
paint(Graphics contexteGraphique) : il faut re-dessiner tout
ou partie après que le recouvrement du Canvas par une
autre fenêtre.
update(Graphics contexteGraphique) : repeint le fond avec la
couleur de background puis re-dessine tout
repaint(Graphics contexteGraphique) : réclame update dès
que possible.
- classe Graphics
:
- contexte graphique : "un crayon,
un pinceau, un stylo" et leurs caractéristiques :
couleur, fonte, ... qui permettent de dessiner, écrire,
...
- constructeur :
Graphics()
- méthodes :
create() crée un nouveau contexte graphique à partir
des caratéristiques de this
dispose() libère le contexte graphique
setColor(Color couleur) change la couleur de dessin
getColor() retourne la couleur de dessin en cours
setFont(Color couleur) change la fonte
getFont() retourne la fonte en cours
clipRect( int coordX, int coordY, int largeur, int hauteur) définit
la zone de dessin au rectangle spécifié
clearRect( int coordX, int coordY, int largeur, int hauteur)
efface le rectangle spécifié en repeignant avec
la couleur de fond
copyArea(int coordX, int coordY, int largeur, int hauteur, int
destX, int destY) copy la zone spécifiée au point
destination désigné.
drawString(Strong chaine, int coordX, int coordY) dessine la
chaine à partir de la position indiquée
drawLine(int x1, int y1, int x2, int y2) dessine une ligne entre
les 2 points précisés
drawOval( int coordX, int coordY, int largeur, int hauteur) dessine
le rectangle de coin haut-gauche spécifié
drawRect( int coordX, int coordY, int largeur, int hauteur) dessine
un ovale à l'intérieur du rectangle spécifié
fillRect( int coordX, int coordY, int largeur, int hauteur) remplit
un rectangle spécifié de la couleur de dessin
boolean drawImage(Image image, int coordX, int coordY, [int hauteur,
int largeur,] ImageObserver observer) dessine l'image spécifiée;
l'observer peut suivre le chargement de l'image sinon this; drawImage
renvoie false si le chargement se s'est pas fait totalement.
- classe Color :
- variables static :
black, white, gray, darkGray, lightGray, blue, red, yellow, green,
orange, cyan, magenta, pink
- contructeur :
Color(int rouge, int vert, int bleu) instancie un objet Color
avec les intensités de rouge, vert et bleu sur 8 bits
chacun.
- interface MouseListener
:
- MouseListener défint l' "écouteur"
d'événement Souris : press, release, click, enter,
exit.
addMouseListener installe un écouteur MouseListener sur
un composant
- les méthodes à (toutes)
définir sont :
- public void mousePressed(MouseEvent e)
définit le traitement quand survient l'événement
qui indique qu'un bouton de la souris est pressé dans
l'aire du composant.
- public void mouseReleased(MouseEvent e)
...événement bouton de souris "relaché"
dans l'aire du composant.
- public void mouseClicked(MouseEvent e)
...événement bouton de souris "pressé-relaché"
- public void mouseEntered(MouseEvent e)
... événement souris "entre" dans l'aire
du composant.
- public void mouseExited(MouseEvent e)
... événement souris "sort" de l'aire
du composant.
- mouseEvent.getX() donne la coordonnée
x de la souris au moment de l'événement.
mouseEvent.getY() donne la coordonnée y.
- interface MouseMotionListener
:
- MouseMotionListener définit l'
"écouteur" d'événement mouvement
de Souris : drag, move.
addMouseMotionListener installe un écouteur MouseMotionListener
sur un composant
- les méthodes à (toutes)
définir sont :
- public void mouseMoved(MouseEvent e) définit
le traitement quand survient l'événement qui indique
que la souris bouge dans l'aire du composant sans bouton enfoncé.
- public void mouseDragged(MouseEvent e)
définit le traitement quand survient l'événement
qui indique que la souris bouge dans l'aire du composant avec
au moins un bouton enfoncé. La souris peut sortir de l'aire
du composant tant qu'un bouton est enfoncé.
- mouseEvent.getX() donne la coordonnée
x de la souris au moment de l'événement.
mouseEvent.getY() donne la coordonnée y.
- interface KeyListener
:
- KeyListener définit l' "écouteur"
d'événement Clavier : press, release, type.
addKeyListener installe un écouteur KeyListener sur un
composant
- les méthodes à (toutes)
définir sont :
- public void keyPressed(KeyEvent e) définit
le traitement quand survient l'événement qui indique
qu'une touche du clavier est enfoncé si le composant a
le focus Clavier.
- public void keyReleased(KeyEvent e) ...événement
touche du clavier "relachée".
- public void keyTyped(KeyEvent e) ...événement
touche caractère (et non une touche flèche, ...)
tapé
- keyEvent.getKeyCode() donne le code de
la touche frappée au moment de l'événement;
par exemple KeyEvent.VK_3 pour le "3", KeyEvent.VK_A
pour le "a" et le "A" , KeyEvent.VK_DOWN
pour la flèche bas, ...
- keyEvent.getKeyChar() donne le caractère
de la touche frappée au moment de l'événement.
- classe Dialog :
- "boîte de dialogue" :
fenêtre conteneur de composants pour dialoguer avec l'utilisateur
; en particulier, elle peut être modale : non-recouvrable
par une autre fenêtre tant que la fenêtre dialogue
n'est pas fermée.
- contructeurs :
Dialog(Frame cadre, boolean modale) crée une boîte
de dialogue sans titre associée au cadre et modale ou
non.
Dialog(Frame cadre, String titre, boolean modale) crée
une boîte de dialogue avec titre associée au cadre
et modale ou non.
- méthodes :
Pour beaucoup les mêmes que Frame, car Dialog et Frame
héritent de Window.
setModal(boolean modale) détermine si la boîte de
dialogue est modale ou non.
- classe WindowAdapter
:
- la classe WindowAdapter est une classe
"écouteur" pour les fenêtres Frame, Dialog,
...
- les Classes Adapters évite l'implémentation
de toutes les méthodes abstraites d'une interface Listener.
- L'interface WindowListener déclare
8 méthodes abstraites qui sont, dans la classe WindowAdapter
définies avec le corps {};
- méthodes :
- windowActivated(WindowEvent e) quand la
fenêtre devient active
- windowClosed(WindowEvent e) quand la fenêtre
est en train d'être fermée (par exemple : clic sur
le boton de fermeture)
- windowClosed(WindowEvent e) quand la fenêtre
est fermée
- windowIconified(WindowEvent e) quand la
fenêtre est "iconisée"
- windowDeiconified(WindowEvent e) quand
la fenêtre est "dé-iconisée"
- En Pratique, il faut créer une
sous-classe Ecouteur de WindowAdapter et re-définir les
méthodes souhaitées : par exemple, public void
windowClosing(WindowEvent e) { ... };
et dans le composant à l'"écoute" d'un
évènement "fermeture de fenêtre",
mettre en place l'écoute : addWindowListener(objetEcouteur);
- classe Checkbox,
CheckboxGroup:
- cases à cocher et boutons radios
: sont cochables et de-cochables, peuvent être plusieures
(indépendantes ou exclusives ) et permettent le déclanchement
d'action :
- les cases à cocher sont indépendantes,
- les boutons radios sont en exclusion mutuelle,
c'est à dire qu'un seul au plus peut être coché.
- constructeurs :
- Checkbox(String texte) crée une
case à cocher (initialisée à non cochée)
avec texte associé
Checkbox(String texte, boolean cochée) crée une
case à cocher avec texte associé, cochée
ou non selon la valeur booléenne
- CheckboxGroup() crée un groupe
de boutons radios
Checkbox(String texte, CheckboxGroup groupe, boolean cochée)
crée une bouton radio avec texte associé, cochée
ou non selon la valeur booléenne, faisant partie du groupe
indiqué
- méthodes :
setLabel(String texte) spécifie le texte de la case à
cocher (ou bouton radio)
getLabel() retourne le texte de la case à cocher
getState() retourne true si la case est cochée
setState(boolean cochée) coche ou non la case selon la
valeur booléenne
addActionListener(ActionListener écouteur) met un "écouteur"
d'événement sur la case
removeActionListener(ActionListener écouteur) supprime
un "écouteur" d'événement sur
la case
- envoie un événement Action
quand son état change