I. Lancement eclipse▲
Dans ce cours, nous verrons les étapes nécessaires pour écrire un programme en JAVA.
- Création d'un projet
- Création d'un package (conseillé)
- Création d'une classe
Appuyer sur File > New > Project comme l'illustre le schéma ci-dessus.
Il faut à ce niveau donner un nom à votre projet. En conséquence, je le nomme" MyFirstProject "
Je vais ensuite créer mon package. Un package est une manière d'ordonner les classes par " groupe ". Un package peut aussi être vu comme un répertoire.
Je clique droit sur le package. Puis je sélectionne New>Class.
Je dois entrer le nom de ma classe.
Une classe est un modèle de quelque chose que nous voulons construire. Par exemple, je vais créer une classe Sportif qui va réunir l'ensemble des instructions destinée à la construction d'un sportif. Pierre est un objet qui a été instancié à partir de la classe Sportif. Pierre va détenir les propriétés de la classe Sportif. En résumé, la classe est la définition. Et l'objet est une instanctiation de la classe. Nous verrons en détail ce concept fondamental de la programmation orientée objet dans le chapitre suivant.
II. Programmation Java▲
package
monpackage;
public
class
MyFirstProgramme {
public
static
void
main
(
String[] args) {
System.out.println
(
"Nous apprenons Java!"
);
}
}
Exécution : Nous apprenons Java !
Notre premier programme nous permet d'afficher le message " Nous apprenons Java! ". Nous allons essayer
de comprendre chaque instruction.
package : il indique le nom du package à laquelle la classe appartient. Ici, il s'appelle
" monpackage ".
public class : indique le nom de la classe. Le fichier contenant ce programme devra s'appeler
MyFirstProgramme.java
Convention Java : Le nom de la classe doit être identique à celui du fichier.
public static void main(String[] args)static : la méthode main de la classe MyFirstProgramme
n'est pas liée à une instance (objet) particulière de la classe.
void indique que la méthode ne retourne rien.
String [ ] args : il permet de récupérer les arguments passés au programme lors de son lancement.
System.out.println("") : permet d'afficher le texte contenu entre " ".
public static void main indique au compilateur qu'il s'agit de la méthode principale.
III. Les types de données ▲
En java, il faudra utiliser stocker des données de différent type dans vos objets. Chacune de ces données ont une spécification différente (taille, déclaration, valeur minimum, valeur maximum). Pour cela, nous allons étudier les quatre types de données qui existent en JAVA.
-
Entier
-
Flottant
-
Caractère
-
Booléen
III-A. Les floattants▲
Ils sont utilisés pour représenter des nombres réels. Ils existent deux types de réel.
Le type | Taille en octets | Valeur |
---|---|---|
float | 4 | -1.4 * 10-45 à +3.4 * 1038 |
double | 8 | 4.9 * 10-324 à +1.7 * 10308 |
Notation : double mondouble = 78.9;
float monfloattant = -34.4f;
float monflottant ; monflottant = 27.4 ;
Cette affectation va générer une erreur de compilation car il faut placer 'f' à la suite du nombre.
La création et l'initialisation se réalisent de la manière suivante :
float monflottant ;
monflottant = 27.4f ;
III-B. Les entiers▲
Ils sont utilisés pour représenter des nombres entiers relatifs. Ils existent quatre types d'entiers. Le tableau ci-dessous nous donne les informations concernant chaque entier.
Le type | Taille en octets Taille en octet | Valeur |
---|---|---|
byte | 1 | -128 à +127 |
short | 2 | -32768 à +32767 |
int | 3 | -2 147 483 648 à +2 147 483 |
long | 4 | -263 à +263 -1 |
Notation : +546 456 -167
III-C. Le type char▲
Ils sont utilisés pour représenter des caractères. Il permet de stocker un seul caractère. Lorsque je déclare une variable de type char, il ne me sera donc pas possible d'affecter deux caractères. La déclaration suivante va générer une erreur de compilation :
char moncaractere = 'ja' ;
Il faudra donc écrire le code suivant :
char moncaractere = 'j' ;
Nous venons de voir qu'il n'est pas possible de stocker une chaîne de caractère dans une variable de type char.
III-D. Le type boolean▲
Le type de donnée booléen a été introduit par le langage Java. Ce type de variable pourra prendre deux états :
- true (vrai) : indiquant que la condition est respectée
- false (faux) : indiquant que la condition n'est pas respectée
La création et l'initialisation se réalisent de la manière suivante :
2.
3.
4.
boolean
monbooleant;
monbooleant=
true
;
boolean
monbooleanf;
monbooleanf =
false
;
III-E. Déclaration et Initialisation de variable▲
La déclaration d'une variable se réalise de la manière suivante :
Type + nom de la variable ;
Exemple : int monArgent ;
L'initialisation d'une variable se réalise de la manière suivante:
Nom de la variable = valeur affectée.
Exemple : monArgent = 3444 ;
Il est aussi possible d'initialiser une variable au moment de sa déclaration.
int nombreDeCopies = 34 ; char x = 'j';
Remarque : Java ne permet l'utilisation d'une variable si elle n'a pas été initialisée auparavant.
2.
int
nbEleve ;
nbEleve++
;
Le compilateur va générer une erreur car la variable nbEleve n'a pas été initialisée ;
Il n'est donc pas possible de l'incrémenter.
2.
3.
int
nbEleve;
nbEleve =
0
;
nbEleve =
nbEleve +
4
;
III-F. Expression constante : final ▲
Java permet de déclarer une constante. C'est-à-dire, une donnée qui ne pourra en cas être modifiée durant l'exécution. La constante pourra être initialisée une seule fois.
2.
3.
final
int
AGE =
20
; //correct
final
int
NBPROF ;
NBPROF =
12
; //correct
Convention Java : il faut écrire en majuscule le nom d'une constante déclarée final.
V. Les opérateurs▲
Ils existent différents types d'opérateurs en Java.
V-A. Les opérateurs arithmétiques ▲
Opérateur | Rôle | Exemple |
---|---|---|
+ | Addition | int total = nombre1+nombre2 ; |
- | Soustraction | int total = nombre1- nombre2 ; |
* | Multiplier | int total = nombre1 * nombre2 ; |
/ | Division | int total = nombre1 / nombre2 ; |
++ | incrémentation | total++ ; est équivalent à total=total+1 ; |
-- | Décrémentation | total-- ; est équivalent à total=total-1 ; |
+= | Addition et affectation | total+=5 ; est équivalent à total=total+5 ; |
-= | Soustraction et affectation | total-=3 ; est équivalent à total=total-3 ; |
*= | Multiplication et affectation | total*=4 ; est équivalent à total=total*4 ; |
/= | Division et affectation | total /=3 ; est équivalent à total=total/3 ; |
% | Modulo | Total= total%2 ; Renvoie le reste de la division 5%2 renvoie 1 |
= | Affectation | total =4 ; La variable total reçoit 4. |
V-B. Les opérateurs de comparaison ▲
Opérateur | Rôle |
---|---|
== | Test d'égalité |
!= | Est différent de |
> | Est supérieur de |
< | Est inférieur de |
>= | Est supérieur ou égal |
<= | Est inférieur ou égal |
Les opérateurs de comparaisons renvoient " true " ou " false ".
Exemple : Je vais comparer l'égalité de deux nombres :
2.
3.
4.
int
nb1 =
2
;
int
nb2=
3
;
boolean
monboolean=(
nb1==
nb2);
System.out.println
(
monboolean);
Le résultat de l'affichage est " false ", car 2 n'est pas égal à 3 ;
V-C. Les opérateurs logiques ▲
Opérateur | Rôle |
---|---|
& & | Et logique |
|| | Ou logique |
& | Et binaire |
| | Ou binaire |
Les opérateurs logiques renvoient " true " ou " false ".
V-D. L'opérateur de cast ▲
En java, le programmeur est libre de forcer la conversion d'une expression dans un type de son choix à l'aide de l'opérateur cast.
Syntaxe : (type de cast ) nombre1 / nombre2
Le résultat de l'opération nombre1 divisé par nombre 2 va être convertit dans le type de choix.
Exemple d'application :
2.
3.
4.
5.
6.
int
nb1 =
2
;
int
nb2 =
3
;
double
mondouble =
(
double
)nb1/
nb2;
float
monfloat =
(
float
)nb1/
nb2;
System.out.println
(
" 2/3 en conversion vers un double vaut "
+
mondouble);
System.out.println
(
" 2/3 en conversion vers un float vaut "
+
monfloat);
Le résultat de l'exécution vaut :
2.
2/3 en conversion vers un double vaut 0.6666666666666666
2/3 en conversion vers un float vaut 0.6666667
VI. Les conditionnelles▲
VI-A. L'instruction if▲
L'instruction if sera utilisée pour faire un test boolean et dans le cas positif, une ou plusieurs instructions seront exécutées.
La syntaxe est la suivante :
if
(
condition)
{
Instruction A ;
Instruction B ;
}
Note : Il est possible de mentionner plusieurs conditions.
Voyons un exemple pour mieux comprendre.
int
a =
5
; int
b =
6
; int
c =
10
;
if
((
a<
b) &
(
b<
c) ) {
a =
1
;
b =
2
;
c =
3
;
}
System.out.println
(
"
\n
a= "
+
a +
"
\n
b= "
+
b +
"
\n
c="
+
c);
Le code suivant affichera :
2.
3.
a= 1
b= 2
c= 3
Comme nous venons de le voir dans l'exemple ci-dessus, la première condition et la deuxième sont vraies.
Donc les instructions contenues dans le bloc du 'if' seront exécutées.
Dans le cas où l'un des deux blocs ( a < b) ou (b < c) n'est pas vrai,
alors les instructions n'auraient pas été exécutées.
VI-B. L'instruction if - else ▲
Comme nous venons de le voir, l'instruction 'if' permet d'exécuter une ou plusieurs instructions dans le cas où la condition est respectée.
Or, il peut arriver que l'on souhaite lancer d'autre instruction dans le cas négatif. L'instruction 'if - else ' répond à cette problématique.
La syntaxe est la suivante :
if
(
condition)
{
Instruction A ;
Instruction B ;
}
else
{
Instruction C ;
Instruction D ;
}
Voyons un exemple :
int
age =
7
;
if
(
age>
17
)
{
System.out.println
(
"Vous êtes majeur"
);
}
else
{
System.out.println
(
"Vous êtes mineur"
);
}
À l'exécution, le résultat d'affichage sera : Vous êtes mineur
En effet, la première condition n'est pas valide puisque 7 n'est pas supérieur à 17.
C'est pourquoi, le deuxième bloc sera affiché.
VI-C. L'instruction switch ▲
L'instruction switch permet de déclencher un traitement en fonction d'une condition.
Elle est similaire à plusieurs if imbriqués. Il est conseillé d'utiliser un switch plutôt que plusieurs if imbriqués. Ceci peut être justifié pour des raisons de performance.
La syntaxe est la suivante :
switch
(
condition) {
case
1_
cas : instruction_1 ;
break
;
case
2_
cas : instruction_2 ;
break
;
case
3_
cas : instruction_3 ;
break
;
case
4_
cas : instruction_4 ;
break
;
default
: instruction_default ;
}
Le bloc default
Nous remarquons la présence d'une case nommée 'default'. Celui-ci n'est pas obligatoire. Elle a pour rôle d'exécuter un bloc d'instruction par défaut si et seulement si aucun cas prédéfini auparavant ne répond à la condition.
Le bloc switch
L'instruction switch est couplée à l'instruction break. Dans le cas où on oublie le break à la fin du bloc d'instruction, alors l'instruction suivante sera exécutée.
Caractéristique des étiquettes
Les étiquettes utilisées devront obligatoirement être des expressions constantes. Pour être plus précis, elle doivent comme type int, short,byte, ou bien char. Il est possible de mentionner plusieurs étiquettes pour le même cas.
Exemple d'application
Un enseignant souhaite obtenir une appréciation en fonction de la moyenne obtenue par l'étudiant.
int
note =
13
;
switch
(
note) {
case
10
: System.out.println
(
"C'est juste!"
); break
;
case
11
: System.out.println
(
"Encore un peu d'effort!"
); break
;
case
12
: System.out.println
(
"C'est bien"
); break
;
case
13
: case
14
: System.out.println
(
"C'est bien, il faut continuer."
); break
;
case
15
: case
16
: case
17
: System.out.println
(
"Très bien."
); break
;
case
18
: case
19
: System.out.println
(
"Excellent travail."
); break
;
case
20
: System.out.println
(
"C'est parfait.Bravo."
); break
;
default
:
System.out.println
(
"C'est pas bon. "
);
}
Dans ce cas, la note de l'étudiant vaut 13. Que va-t-il se passer ?
Le programme affichera : C'est bien, il faut continuer.
VI-D. Synthèse ▲
Nom de l'instruction | Avantage | Utilisation | Exemple |
---|---|---|---|
If | Elle permet de tester une condition et exécute un bloc d'instruction. | Il faudrait utiliser un "if" si on souhaite exécuter un seul bloc d'instruction | int age = 16 ;
Si je souhaites juste tester la valeur de la variable "age" et exécuter une action.
if ( age) > 18 { ...} Dans les autres cas, aucune instruction ne sera exécutée.
|
if - else | Il permet de tester une ou plusieurs conditions et offre la possibilité de réaliser une série d'instruction dans le cas négatif. | Utilisation est conseillée si on souhaite exécuter deux blocs d'instruction. Le premier bloc dans le cas où la condition est respectée. Le second bloc dans le cas contraire. | Si je souhaites réaliser une autre action dans le cas où la variable age est inférieure à 18. Alors, il faudra absolument utiliser « if-else »
if ( age) > 18 {} else {} |
switch | Il permet de tester une condition. En fonction de la condition, il est possible d'exécuter 1 ou plusieurs instructions. Il est capable d'exécuter une action par défaut si les conditions prédéfinies ne sont pas conformes. | Utilisation est conseillée si on souhaite exécuter un ou plusieurs blocs en fonction de différent cas. Il est plus performant que plusieurs if imbriqués. |
Si je souhaites réaliser une action pour chaque valeur de la variable « age », je dois utiliser un switch. Sélectionnez 1. 2. 3. 4.
|
VII. Les répétitives▲
VII-A. L'instruction for▲
L'instruction for a pour rôle d'exécuter la même instruction plusieurs fois.
C'est-à-dire, on va définir le nombre exact de répétition.
Il va falloir configurer la boucle en lui précisant le nombre de départ, le nombre d'arrivée et le pas d'incrémentation ou décrémentation.
La syntaxe est la suivante :
for
(
nom_compteur ; condition à vérifier ; incrémentation ou décrémentation)
{
Instruction 1
;
Instruction 2
;
…
Instruction n ;
}
Voyons un exemple :
int
debut;
int
fin =
14
;
for
(
debut =
4
; debut <
fin; debut++
)
{
System.out.println
(
"Numéro : "
+
debut);
}
Voici l'affichage :
2.
3.
4.
5.
6.
7.
8.
9.
10.
Numéro : 4
Numéro : 5
Numéro : 6
Numéro : 7
Numéro : 8
Numéro : 9
Numéro : 10
Numéro : 11
Numéro : 12
Numéro : 13
Notre programme détient deux variables 'debut' et 'fin' respectivement initialisées à 4 et 14.
La condition précise que le message pourra être affiché si et seulement si la valeur de la variable 'debut' est strictement inférieur à la valeur de la variable 'fin' (debut < fin).
Après chaque affichage, la valeur de la variable 'debut' est incrémentée (debut++).
Dés que la variable 'debut' vaut 14, le programme sera interrompu.
14 n'est pas strictement inférieur à 14, la condition n'est plus valide.
VII-B. L'instruction While▲
L'instruction while a pour rôle d'exécuter un bloc d'instruction si et seulement si la condition est respectée.
La condition est testée dés le départ avant d'entrer dans le bloc d'instruction.
Elle est capable d'exécuter un bloc d'instruction une ou plusieurs fois.
Contrairement à l'instruction 'if' qui ne pouvait exécuter le bloc d'instruction une seule fois.
La syntaxe est la suivante :
while
(
condition)
{
Instruction 1
;
Instruction 2
;
Instruction n ;
}
Exemple d'application :
int
nombre1 =
0
;
int
nombre2 =
8
;
while
(
nombre1<
nombre2)
{
System.out.println
(
"Affichage : "
+
nombre1);
nombre1++
;
}
Voici l'affichage :
2.
3.
4.
5.
6.
7.
Affichage : 1
Affichage : 2
Affichage : 3
Affichage : 4
Affichage : 5
Affichage : 6
Affichage : 7
Le programme va d'abord vérifier que la condition mentionnée (nombre1 < nombre2) est respectée. Dans le cas positif, on exécute le bloc d'instruction.
Il ne faut pas oublier de mentionner l'incrémentation ou la décrémentation du compteur (ici nombre1). Tant que la variable nombre1 est inférieure à la variable nombre2, on va afficher le message.
Ici on s'arrête à 7 car 8 n'est pas strictement inférieur à 8.
VII-C. L'instruction do while ▲
L'instruction " do while " a pour rôle d'exécuter un bloc d'instruction plusieurs fois.
Contrairement à l'instruction " while ", elle va exécuter l'instruction une seule fois avant de tester la condition.
Si la condition est respectée, elle va continuer l'exécution.
La syntaxe est la suivante :
do
{
Instruction n ;
}
while
(
condition);
Exemple d'application :
int
compte =
1000
;
do
{
compte=
compte+
600
;
}
while
(
compte<
0
);
System.out.println
(
"Le solde du compte vaut "
+
compte);
Le résultat de l'affichage est :
Le solde du compte vaut 1600
Tant que le solde du compte est débiteur, nous voulions incrémenter de 600.
Or comme nous utilisons l'instruction do-while, le compte a été crédité une fois avant de tester la condition. (1000+600 = 1600).
Voilà la plus grande particularité de cette instruction. Son exécution a été stoppée car 1600 est supérieur à 0, donc la condition mentionnée par le bloc " while " n'est pas respectée.
VII-D. Synthèse ▲
Nom de l'instruction | Avantage |
---|---|
for | Permet d'exécuter un bloc d'instruction une ou plusieurs fois. Le nombre d'exécution est connu d'avance. |
while | Teste la condition. Si celui-ci est valide exécute les instructions. Si celui-ci n'est pas valide alors aucune instruction n'est exécutée. Le nombre d'exécution n'est pas connu. |
do while | Exécute une fois les instructions avant de tester la condition. Si la condition est valide, les instructions sont exécutées. Dans le cas contraire, il arrête son exécution. |
VIII. Programmation orienté objet ▲
La programmation orientée objet est la représentation du monde réel. Dans ce paradigme, tout est objet.
C'est-à-dire, je suis un objet de type rédacteur, le lecteur est un objet de type lecteur, l'ordinateur est un objet de type ordinateur.
Il définit un ensemble de règle qui permet à chaque objet de communiquer entre eux.
Ces objets pourront posséder des attributs (rapide, simple, couleur, prix) et des méthodes (allumer, parler, ...)
En résumé, la programmation orientée objet consiste à représenter les objets et leur relation afin de leur permettre de communiquer pour mettre en oeuvre les actions attendues.
VIII-A. Classe et objet ▲
La classe
Une classe est un modèle de quelque chose que l'on souhaite créer.
C'est quelque chose d'abstrait qui servira de modèle à la création d'un objet particulier.
Elle a des attributs et des méthodes. Fille peut être une classe représentant un modèle d'individu de sexe féminin.
Cette classe aura des attributs (age, caractère, prénom), que l'on peut appeler " données membres " et des méthodes (parler, dormir, travailler, séduire) que l'on peut appeler des " fonctions membres ".
Les attributs représentent l'état de l'objet.
Et les méthodes représentent les opérations que l'on peut appliquer à l'objet.
Les variables d'instances
public
class
CFille {
private
int
age;
private
String caractere;
private
String prenom;
}
Cette déclaration de classe contient trois attributs de classe.
Comme elles ne sont pas déclarées à l'intérieur d'une méthode, on les appelle des variables d'instances.
- age : est un entier qui indique l'age de la fille.
- caractere : est une chaîne de caractère qui indique le caractère d'une fille.
- prenom : est une chaîne de caractère qui indique le prénom de la fille.
Les variables de classe
Une variable de classe est une variable qui est commune à toutes les instances de cette classe. Une telle variable est d'ailleurs accessible sans avoir besoin de passer par une instance de la classe.
Il faudra utiliser le mot clé static pour déclarer une variable de classe.
Dans notre exemple ci-dessous, nous avons deux variables de classe :
public
class
compteur
{
public
static
int
nombre =
0
;
public
static
int
nb =
0
;
public
compteur
(
)
{
nombre++
;
System.out.println
(
"Création Instance n° : "
+
nombre ); this
.nb=
nombre;
}
public
static
void
main (
String [] args)
{
compteur c1 =
new
compteur
(
); compteur c2 =
new
compteur
(
); compteur c3 =
new
compteur
(
);
System.out.println
(
"Il existe : "
+
compteur.nb +
" "
+
"instances"
);
}
}
Quel serait l'affichage si j'ignore le mot clé static dans la déclaration de la variable nombre ?
Le constructeur va incrémenter la variable nombre puis afficher le message.
Au prochain appel du constructeur, la variable nombre sera à nouveau initialisée à 0.
Quel serait l'affichage si j'ignore le mot clé static dans la déclaration de la variable nb ?
Le compilateur va générer une erreur de compilation. Seul une variable de classe peut être accessible sans avoir besoin de passer par une instance de la classe.
Les méthodes
Dans le langage JAVA, une méthode détient quatre points essentiels :
- Le nom de la méthode
- Les arguments
- La valeur de retour
- Le corps de la méthode
Définition d'une méthode
TypeRetour NomMethode (
type1 argument1, type2 argument2, typen argumentn)
{
// Corps de la méthode
}
Les arguments : il s'agit des arguments que l'on souhaite passer à la méthode. Elles sont obligatoirement séparées par des virgules. Dans le corps de la méthode, ces arguments deviendront des variables locales.
Le nom de la méthode :C'est le nom que l'on a attribué à la méthode. Pour appeler la méthode, il faudra obligatoirement passer par son nom.
La valeur de retour : Chaque méthode peut retourner une valeur. Il faudra le spécifier dans la déclaration de la méthode.
Si le type de retour est void, alors la méthode ne retourne rien. Par contre, si un type de retour est spécifié, il faudra obligatoirement retourner une valeur.
Dans le cas contraire, une erreur de compilation sera générée.
La méthode peut aussi faire une opération sur les arguments et peut retourner la somme de ces deux arguments.
Par exemple :
int
somme
(
int
nb1, int
nb2)
Cette méthode nommée somme peut faire la somme des deux arguments et retourner la somme.
Getter et Setter
Les accesseurs (getter ou setter) permettent de modifier ou récupérer les attributs d'une classe.
Pour des raisons de sécurité, les attributs doivent être déclarés privés.
public
class
Person {
private
int
numeroSS; private
String name ;
public
int
getNumeroSS
(
) {
return
numeroSS;}
public
void
setNumeroSS
(
int
numeroSS) {
this
.numeroSS =
numeroSS;}
public
String getName
(
) {
return
name; }
public
void
setName
(
String name) {
this
.name =
name;
}
public
static
void
main (
String [] args){
Person p1 =
new
Person
(
);
p1.setName
(
"Audrey"
);
p1.setNumeroSS
(
12334454
);
System.out.println
(
"Name : "
+
p1.getName
(
) +
"
\n
"
+
"Numéro : "
+
p1.getNumeroSS
(
));
}
}
Résultat de l'exécution :
2.
Name : Audrey
Numéro : 12334454
Exemple d'application
La classe CDistributeur a des attributs (Nom, NumeroMachine) et des méthodes comme Distribuer, ControlerCarte, LireCarte, ComposerCode, ActiverClavier).
public
class
CDistributeur {
private
String nom;
private
int
numeroMachine
privaye void
distribuer
(
){}
private
void
ControlerCarte
(
) {}
public
void
ComposerCode
(
int
code) {
}
private
void
ActiverClavier
(
) {}
}
L'objet
Un objet est l'instanciation d'une classe, c'est-à-dire la création d'un objet particulier à partir de la classe.
Pierre peut être une instance de la classe Sportif, représentant un individu particulier en tant que Sportif.
Il est important de savoir qu'une instance va détenir exactement les propriétés de sa classe parente.
Pierre peut être grand et avoir 18 ans. Il peut parler l'anglais et le français.
Il peut courir vite et peut être très agressive. Paul est une autre instance de la classe Sportif.
Il peut être très gentil et avoir 25 ans. Il peut parler l'allemand. Il peut être plus rapide que Pierre.
Chaque objet est unique.
Sportif est un modèle (classe) ;
Tandis que Pierre et Paul sont des instances (objet).
Ils ont été instanciés à partir d'un modèle (classe).
Caractéristiques d'un objet
Un objet dispose de trois caractéristiques essentielles : Le comportement de l'objet :
Que pouvons-nous faire avec cet objet?
Quelles sont les méthodes que nous pouvons lui appliquer?
Par exemple, pouvons nous appliquer la méthode courir à un avion et un humain ?
Tous les objets de la même classe vont partager le même comportement.
Par exemple, la classe Sportif détient une méthode courir. Comme Paul et Pierre sont des instances de cette classe, Ils peuvent courir.
L'A380 est une instance de la classe Avion. Comme la classe Avion ne détient pas de méthode courir. L'A380 ne peut pas courir.
L'état de l'objet :
Quelle est la réaction d'un objet lorsqu'on lui applique une méthode ?
Chaque objet dispose des attributs qui lui appartiennent.
Il s'agit de l'état de l'objet. Il est possible que l'état d'un objet change dans le fil du temps.
Dans le cas où l'état d'un objet change sans que l'on fasse appel à une méthode, il y a violation de la règle d'encapsulation. Par contre, l'état de l'objet ne suffit pas à décrire celui-ci car chaque objet dispose d'une identité spécifique. Par exemple, dans un système de traitement de commandes, deux commandes peuvent se différencier même si elles contiennent les mêmes produits. Chaque objet dispose d'une identité (Référence) et généralement un état distinct (disponible - en cours d'acheminement). Il est possible que ces caractéristiques essentielles aient une influence sur les autres.
Par exemple, un produit p peut être en cours d'acheminement et retarder l'expédition de la commande.
Si une commande est expédiée, il ne sera pas possible de la modifier.
C'est pourquoi, cette commande va refuser l'appel de la méthode ajouter, modifier, supprimer.
L'identité de l'objet :
Comment un objet peut il se différencier d'un autre qui peut avoir le même comportement et le même état.
Par exemple, plusieurs personnes peuvent avoir le même nom, le même prénom, la même date de naissance, le même lieu de naissance, la même adresse. Comment peut-on les différencier.
Par contre, chaque personne a un numéro de sécurité sociale unique qui va lui permettre de se différencier des autres personnes.
L'encapsulation
L'encapsulation est un mécanisme qui consiste à protéger les informations contenues dans un objet.
L'utilisateur pourra manipuler les données à l'aide des méthodes. En d'autres termes, on va interdire au programmeur d'accéder à certaines données ou méthodes de la classe. Comme les classes sont partagées, le concepteur peut décider de restreindre l'accès à certaines parties. Le concepteur va créer une classe pour des besoins bien spécifique et il va éviter que l'on modifie ces spécifications.
Les niveaux d'accès
Il existe trois niveaux d'accès pour les données membres et les méthodes.
Public : la méthode ou l'attribut sont accessible par tout le monde sans exception.
Private : les attributs ou méthodes déclarées ne sont accessible uniquement au sein de la classe dans laquelle elles sont déclarées.
Protected : les éléments déclarés " protected" ne sont accessibles uniquement à partir de la classe mère et les classes enfants.
Laura est une autre instance de la classe Fille. Elle a un caractère capricieux.
Elle peut avoir 29 ans. Elle peut parler l'espagnol. Elle peut dormir tôt.
Elle peut être difficile à séduire.
Et elle peut s'embrasser uniquement avec un homme dont elle est amoureuse.
Un homme ne pourra pas embrasser Laura sans son accord.
La méthode étant privée, il risque de se faire taper par Laura.
Par contre, la méthode séduire est publique. C'est-à-dire, accessible par tout le monde. Tous les hommes peuvent essayer de séduire Laura.
Laura à besoin d'être amoureuse d'un homme pour l'embrasser. Si et seulement si Laura est séduite et tombe amoureuse d'un homme, alors elle peut l'embrasser. Dans les autres cas, elle va refuser de l'embrasser.
Par contre, Laura peut aussi avoir une maison et une voiture qui sont protégées (protected).
Ses enfants pourront y accéder uniquement.
En résumé, Laura a des propriétés publiques (+) (parler, séduire) : Tous les hommes pourront parler ou séduire Laura. Accessible par tout le monde.
Laura a des propriétés privées (-) (embrasser) : Seule Laura pourra décider d'embrasser un homme. Uniquement accessible par elle-même.
Laura a des propriétés protected (#) (une maison, une voiture) : Sa maison et sa voiture lui appartiennent. Laura et ses enfants pourront les utiliser.
La notion de constructeur
Un constructeur a pour objectif d'initialiser les attributs de la classe. Par la suite, il serapossible de réaliser différentes actions.
Un constructeur a plusieurs caractéristiques.
- Il se nomme exactement de la même manière que la classe.
- Il ne détient pas de valeur de retour.
- Il peut avoir des arguments utilisables à la création de l'objet
- Il n'est pas obligatoire d'avoir un constructeur.
Dans le cas où on ne définit pas de constructeur, le compilateur Java définit un constructeur sans arguments par défaut. La création de l'objet se réalise par le biais du mot clé new.
Syntaxe Java
o Il est possible de déclarer le nom d'un objet appartenant à une classe sans définir l'objet.
nomDeLaClasse nomDeMonObjet ; ex : Fille Laura ;
o Il va falloir construire l'objet. nomDeMonObjet = new nomDeLaClasse () ex : Laura = new Fille() ;
o Il est aussi possible de créer un objet en deux étapes : nomDeLaClasse nomDeMonObjet = new nomDeLaClasse () ; ex : Fille Laura = new Fille() ;
Exemple de constructeur
class
Fille {
public
Fille
(
int
age, String prenom, String caractere,String interet)
{
_age =
age;
_prenom =
prenom;
_caractere =
caractere;
_interet =
interet;
}
}
-----------------------------------------------------------------------------
class
Fille{
public
Fille
(
int
age, String prenom, String caractere,String interet)
{
_age =
age;
_prenom =
prenom;
_caractere =
caractere;
_interet =
interet;
}
public
Fille
(
int
age, String prenom)
{
_age =
age;
_prenom =
prenom;
}
}
Il est possible de mettre en place un ou plusieurs constructeurs.
Il faudra obligatoirement faire appel à ce constructeur en lui fournissant les quatre arguments (age, prenom, caractere, interet). Où bien, il faudra fournir deux arguments si l'on souhaite utiliser le second constructeur.
Dans tous les autres cas, le compilateur VA REFUSER de créer un objet de type Fille.
Pour instancier un objet " Fille ", il faudra obligatoirement écrire le code suivant :
Fille Laura;
Laura =
new
Fille (
23
,"Laura"
,"gentille"
,"musique"
); // Où bien
Fille Marguerite =
new
Fille
(
24
,"Marguerite"
,"capricieuse"
,"livre"
);
Fille Helene =
new
Fille
(
24
,"Helene"
); // appel du constructeur avec 2 arguments.
Fille Jade =
new
Fille
(
) ; // REFUSÉ
VIII-B. L'héritage▲
L'héritage est un concept fondamental de la programmation orientée objet.
Il offre la possibilité de réutiliser les composants logiciels existants (Classes).
Une classe dérivée (=enfant) pourra utiliser les propriétés de la super classe (=parent) et pourra ajouter ses propres propriétés.
Ce qui offre la possibilité de ne pas avoir à répartir de zéro. Il s'agit de la relation : " est un ".
Très important : Il n'y a pas d'héritage multiple en java.
Une classe ne peut hériter d'une seule classe. Nous verrons dans les chapitres suivants
comment java dérive ce problème.
public
class
Personnne{}
public
class
Etudiant extends
Personne{}
public
class
Professeur extends
Personne{}
Le mot clé extends indique qu'il s'agit de l'héritage.
Il est possible de dire que la classe Etudiant hérite de la classe Personne.
Exemple d'application
Une personne a un nom, un prénom, un numéro de Sécurité Sociale.
Un étudiant a un nom, un prénom, un numéro de Sécurité Sociale, une note.
Un professeur a un nom, un prénom, un numéro de Sécurité Sociale, il enseigne une matière.
Il est possible de créer les classes sous cette forme :
Un étudiant est une personne. Un professeur est une personne.
Les caractéristiques communes entre les trois classes peuvent être centralisés dans la classe Personne.
Voilà le plus grand intérêt du concept d'héritage.
VIII-C. Le polymorphisme ▲
Le polymorphisme est une caractéristique essentielle de la programmation orientée objet.
Dans la langue grec, le polymorphisme signifie peut prendre plusieurs formes.
Le polymorphisme offre la possibilité de définir plusieurs méthodes portant le même nom mais possédant différents paramètres.
Le choix de la méthode sera faite automatiquement en fonction des paramètres.
Exemple d'application
Nous sommes en présence d'une méthode nommée " receptionner ".
Cette méthode réceptionne les arguments et affiche celui-ci.
public
void
receptionner
(
int
a , int
b)
{
System.out.println
(
"J'ai reçu deux nombres entiers "
+
a +
" et "
+
b);
}
public
void
receptionner
(
int
a )
{
System.out.println
(
"J'ai reçu un entier "
+
a );
}
public
void
receptionner
(
int
a , boolean
b)
{
System.out.println
(
"J'ai reçu un entier "
+
a +
"et un boolean :"
+
b );
}
public
static
void
main
(
String[] args)
{
Poly monprogramme =
new
Poly
(
);
monprogramme.receptionner
(
5
);
monprogramme.receptionner
(
6
, 98
);
monprogramme.receptionner
(
2
,true
);
}
Résultat de l'exécution :
2.
3.
J'ai reçu un entier : 5
J'ai reçu deux nombres entiers 6 et 98
J'ai reçu un entier : 2et un boolean :true
Le polymorphisme à l'aide de l'héritage
Nous avons deux classes (Personne, Etudiant)
La classe Personne détient la méthode seReposer(boolean b)
La classe Etudiant détient la méthode seReposer(int heure)
Je crée un étudiant puis je fait appel à la méthode seRepose avec comme argument un boolean. Que se passe t -il ?
Comme la classe seRepose(boolean) n'existe pas au niveau de la classe Etudiant, on va voir si celui-ci existe au niveau de la classe parent. En effet, celui-ci existe bien au niveau de la classe parent. Alors on va exécuter la méthode à partir de la classe parent.
Je crée un étudiant puis je fait appel à la méthode seRepose avec comme argument un entier.
Que se passe t -il ?
Comme la classe Etudiant détient la méthode seRepose(int heure), elle va exécuter la méthode.
Je crée une personne puis je fait un appel à la méthode seRepose avec comme argument un entier. Que se passe t-il ?
Une erreur sera générée car il n'existe pas de méthode seRepose(int) au niveau de la classe Personne. Une classe parent ne peut pas utiliser les méthodes d'une classe enfant.
VIII-D. Classe abstraite ▲
Une classe abstraite est une classe dont l'implémentation n'est pas complète.
Elle va servir de modèle pour les classes enfants.
La classe abstraite va définir des méthodes en fournissant leur signature (le nom, type de retour, type d'argument).
Les classes dérivées devront obligatoirement implémentées ces méthodes.
C'est une assurance pour la classe de base que les classes enfants respecteront bien la spécification définie. (= interface de programmation).
Une classe est dite abstraite si elle détient une ou plusieurs méthodes abstraites. Il n'est pas possible d'instancier une classe abstraite.
Exemple d'application
Nous avons une classe " animaldomestique " à partir de laquelle va dériver la classe
" oiseau ", " chien ", " chat ".
Il sera possible d'instancier un oiseau, chien, chat.
Mais il ne sera pas possible d'instancier un animaldomestique puisqu'il s'agit d'une classe
abstraite.
Code source en java
public
abstract
class
animaldomestique {
abstract
public
void
parler
(
);
}
public
class
Chat extends
animaldomestique {
public
void
parler
(
)
{
System.out.println
(
"miao miao miao"
);
}
}
public
class
Chien extends
animaldomestique {
public
void
parler
(
) {
System.out.println
(
"hav hav hav"
);
}
}
public
class
oiseau extends
animaldomestique {
public
void
parler
(
)
{
System.out.println
(
"cik cik cik"
);
}
}
public
static
void
main
(
String[] args) {
oiseau titi =
new
oiseau
(
);
titi.parler
(
); Chat tom =
new
Chat
(
);
tom.parler
(
); Chien toto =
new
Chien
(
);
toto.parler
(
);
}
Le résultat d'exécution est le suivant :
2.
3.
cik cik cik
miao miao miao
hav hav hav
VIII-E. Classe interface ▲
Dans le chapitre concernant la classe abstraite, nous avons vu comment une classe pouvait définir des fonctionnalités (=méthodes) pour ses descendants.
En effet, une interface va définir les méthodes. Mais celui-ci est plus riche car une classe pourra implémenter plusieurs interfaces. Contrairement à une classe qui ne pouvait hériter d'une seule classe abstraite.
La notion d'interface va venir compléter l'héritage.
C'est-à-dire, une classe pourra hériter d'une classe C1 et implémenter une ou plusieurs classe I1,I2,I3,….
Exemple d'application
Un doctorant est à la fois un étudiant et un enseignant.
Nous avions vu que l'héritage multiple n'existe pas en java. Comment résoudre ce problème ?
En effet, les interfaces vont nous permettre de résoudre ce problème.
public
interface
Etudiant {
public
void
etudier
(
);
}
public
interface
Enseignant {
public
void
enseigner
(
);
}
public
class
Doctorant implements
Enseignant,Etudiant {
public
void
enseigner
(
)
{
System.out.println
(
"J'enseigne à Paris."
);
}
public
void
etudier
(
)
{
System.out.println
(
"Je suis étudiant à Paris"
);
}
}
public
class
testProgramme {
public
static
void
main
(
String[] args) {
Doctorant monDoctorant =
new
Doctorant
(
); monDoctorant.enseigner
(
); monDoctorant.etudier
(
);
}
}
Le mot clé implements est utilisé en java pour indiquer que l'on va implémenter une classe interface.
A l'exécution, on obtient :
J'enseigne à Paris.
Je suis étudiant à Paris
IX. La classe String ▲
Le langage Java offre la possibilité de manipuler des chaînes de caractères.
La classe String offre plusieurs constructeurs et méthodes permettant de travailler
sur les chaînes de caractères.
Déclaration
Il est possible de déclarer une chaîne de caractère de la manière suivante :
String maVille =
" Paris "
;
Où bien
String maVille =
new
String
(
"Paris"
);
Comparaison de deux chaînes de caractères
boolean equals(Object anObject)
Pour comparer deux strings, il faut utiliser la méthode equals.
Cette méthode renvoie true si les deux chaînes sont égaux. Sinon false.
String ville1 =
"Paris"
;
String ville2=
"Istanbul"
;
boolean
resultat =
(
ville1.equals
(
ville2)) ;
System.out.println
(
"Resultat : "
+
resultat);
/*Résultat d'exécution
Resultat : false */
La méthode compareTo
Il existe une autre manière de comparer deux chaînes. Cette méthode compte le nombre de caractère.
- La retourne 0 si les deux chaînes contiennent le même nombre de caractère.
- Si le premier string est plus petit, la méthode retourne un nombre négative.
- Si le premier string est plus grand, la méthode retourne un nombre positif.
- La méthode compare le nombre de caractère contenu dans la chaîne de caractère.
//ville1 est inférieur à ville2
String ville1=
"Istanbul"
;
String ville2=
"Istanbullllllllllll"
;
int
resultat =
(
ville1.compareTo
(
ville2)) ;
System.out.println
(
resultat);
// Résultat d'affichage : -11
//ville1 est supérieur à ville2
String ville10=
"Istanbullllllllllllllll"
;
String ville20=
"Istanbullllllllllll"
;
int
resultat2 =
(
ville10.compareTo
(
ville20)) ;
System.out.println
(
resultat2);
// Résultat d'affichage : 4
//ville1 est égal à ville2
String ville100=
"Istanbul"
;
String ville200=
"Istanbul"
;
int
resultat3 =
(
ville100.compareTo
(
ville200)) ;
System.out.println
(
resultat3);
// Résultat d'affichage : 0
Obtenir un caractère précis
char charAt(int i) : la méthode charAt retourne un caractère qui se trouve à l'indice i.
char charAt ( int a ) : fournit le caractère qui se trouve à l'indice a
String unstring =
"bonjour java"
;
char
caractere =
unstring.charAt
(
5
);
//retourne u
Concaténation de deux String
String concat
(
String unString)
Il existe deux manières de concaténer les Strings.
String unString =
"Istanbul"
;
String unespace =
" "
;
String unautreString =
"est une belle ville"
;
System.out.println
(
unString +
unespace +
unautreString);
System.out.println
(
unString.concat
(
unespace).concat
(
unautreString));
Le résultat d'affichage est le même : Istanbul est une belle ville .
Comme nous pouvons le constater par le biais de ces deux exemples,
il est possible de concaténer deux chaînes :
o par le biais de l'opérateur +
o par le biais de la méthode concat.
Extraction de deux chaînes
Il est possible d'extraire une chaîne par le biais de la méthode substring.
String substring
(
int
beginIndex)
String unString =
"Istanbul"
;
String premierString0 =
unString.substring
(
0
);
String premierString1 =
unString.substring
(
1
);
System.out.println
(
"unString.substring(0) ==>"
+
premierString0);
System.out.println
(
"unString.substring(1) ==>"
+
premierString1);
String unSecondString0 =
unString.substring
(
0
, 3
);
String unSecondString1 =
unString.substring
(
2
, 5
);
System.out.println
(
"unString.substring(0, 3)"
+
unSecondString0);
System.out.println
(
"unString.substring(2, 5)"
+
unSecondString1);
/*
* unString.substring(0) ==>Istanbul
unString.substring(1) ==>stanbul
unString.substring(0, 3)Ist
unString.substring(2, 5)tan
*/
Obtenir la longueur d'une chaîne de caractère
public int length()
La méthode length retourne la longueur d'une chaîne de caractère.
String unString =
"Istanbul"
;
String unautreString =
"L'ECTEI est une école"
;
int
unentier =
unString.length
(
);
int
unautreentier =
unautreString.length
(
);
System.out.println
(
"La chaine de caractère : "
+
unString +
" a une longueur de "
+
unentier);
System.out.println
(
"La chaine de caractère : "
+
unautreString+
" a une longueur de "
+
unautreentier);
/*Résultat de l'exécution
* La chaine de caractère : Istanbul a une longueur de 8
La chaine de caractère : L'ECTEI est une école a une longueur de 21
*/
Remplacer un caractère par un autre
String replace(char uncaractere, char unautrecaractere)
Permet de remplacer toutes les occurences d'un caractère par un autre caractère.
String unString =
"MCTMIS est une mot."
;
System.out.println
(
"unString : "
+
unString );
String unautreString =
unString.replace
(
"M"
,"X"
);
System.out.println
(
"Chaîne modifiée : "
+
unautreString );
/*
Résultat d'exécution :
unString : MCTMIS est une mot.
Chaîne modifiée : XCTXIS est une mot.
*/
Remplacer une chaîne de caractère par une autre
String replaceAll(String ancien, String nouveau)
Permet de remplacer toutes les occurences d'une chaîne de caractère par une autre chaîne de
caractère.
String s6=
" Bonjour Théodore ! J'ai dit Bonjour ! Bonjour est le premier mot à dire! "
;
String ma =
s6.replaceAll
(
"Bonjour"
, "Hi"
);
/*
Hi Théodore ! J'ai dit Hi ! Hi est le premier mot à dire!
*/
Remplacer une chaîne de caractère par une autre
String replaceAll(String ancien, String nouveau)
Permet de remplacer toutes les occurences d'une chaîne de caractère par une autre chaîne de caractère.
String s6=
" Bonjour Théodore ! J'ai dit Bonjour ! Bonjour est le premier mot à dire! "
;
String ma =
s6.replaceAll
(
"Bonjour"
, "Hi"
);
/*
Hi Théodore ! J'ai dit Hi ! Hi est le premier mot à dire!
*/
Remplacer la première occurrence d'une chaîne de caractère
String replaceFirst(String unString, String unAutreString)
Remplace la première occurrence de l'expression unString par unAutreString, puis renvoie la chaîne de caractère.
String s6=
" Paris est une belle ville. Je travaille à Paris. Paris est la capitale de la France. "
;
String maChaine =
s6.replaceFirst
(
"Paris"
, "Istanbul"
);
/*
Résultat d'exécution :
Istanbul est une belle ville. Je travaille à Paris. Paris est la capitale de la France.
*/
Transformation majuscule et minuscule
Il est possible de transformer une chaîne de caractère en majuscule et en minuscule.
String toLowerCase() Transformer les caractères en minuscules.
String toUpperCase() Transformer les caractères en majuscules.
String unstring =
"un string en miniscule"
;
String enmajuscule =
unstring.toUpperCase
(
);
System.out.println
(
unstring +
" "
+
"Convertit en majuscle ==>"
+
enmajuscule);
String unStringEnMajuscule =
" UN STRING EN MAJUSCULE"
;
String enminiscule =
unstring.toLowerCase
(
);
System.out.println
(
unStringEnMajuscule +
" "
+
"Convertit en miniscule ==> "
+
enminiscule );
/*
* Résultat d'exécution :
* un string en miniscule Convertit en majuscle ==>UN STRING EN MINISCULE
UN STRING EN MAJUSCULE Convertit en miniscule ==> un string en miniscule
*/
Début et fin
Comment savoir si une phrase commence par une chaîne de caractère précis. Où bien s'il se termine avec une chaîne de caractère précis. La méthode startsWith et endsWith nous permettent de répondre à ce problème.
boolean
startsWith
(
String unMot)
boolean
endsWith
(
String unAutreMot)
String string =
"Java est un langage."
;
boolean
start =
string.startsWith
(
"Java"
);
boolean
fin =
string.endsWith
(
"."
);
System.out.println
(
"start ==>"
+
start );
System.out.println
(
"End ==> "
+
fin);
/*
Résultat d'exécution :
start ==>true
End ==> true
*/
Supprimer les espaces du début et de la fin
La fonction trim() permet de supprimer les espaces de début et de fin.
public String trim()
String e1 =
" une belle vie a paris en 2009. "
;
System.out.println
(
"Sans Espace : "
+
e1.trim
(
) +
"****"
);
/*
Résultat d'exécution :
Sans Espace : une belle vie a paris en 2009.****
*/
Découpage d'une chaîne de caractère
String[] split(String expression) Permet de découper une chaîne de caractère en utilisant une expression régulière. Par exemple, un espace, le signe arobase, ....
String unString=
"unEleve@mot.fr"
;
String tableau[] =
unString.split
(
"@"
);
for
(
int
indice=
0
;indice<
tableau.length;indice++
)
System.out.println
(
"["
+
tableau[indice]+
"]"
);
/* Résultat d'exécution :
[unEleve]
[mot.fr]
*/
String unString=
"PARIS est une ville. "
;
String tableau[] =
unString.split
(
" "
);
for
(
int
indice=
0
;indice<
tableau.length;indice++
)
System.out.println
(
"["
+
tableau[indice]+
"]"
);
/* Résultat d'exécution :
[PARIS]
[est]
[une]
[ville.]
*/
Retrouver la position du premier occurrence d'un caractère
int indexOf(int caractere)
Cette méthode retourne l'index de la première occurrence d'un caractère.
String s1=
"Je manipule les Strings!"
;
System.out.println
(
"Index du premier 'a' dans '"
+
s1+
"': '"
+
s1.indexOf
(
"a"
)+
"'"
);
/*
Index du premier 'a' dans 'Je manipule les Strings!': '4'
*/
X. Les arraylists ▲
La classe ArrayList est une classe de tableaux. La taille du tableau peut augmenter ou diminuer à l'exécution. Contrairement au tableau classique qui contiennent des types de données simples, une ArrayList contient des objets.
La création d'une ArrayList peut se réaliser de la manière suivante :
ArrayList unObjet = new ArrayList();
La classe ArrayList contient plusieurs méthodes :
void add( int i,Object element) : insère l'élément à la position i
void add ( Object element ) : insère l'élément à la fin de l'ArrayList
void clear() : Supprime le contenu de l'ArrayList.
boolean contains(Object element) : retourne true si l'élément existe dans la liste
Object remove(int i) : supprime l'élément qui se trouve à l'indice i
Object set(int i, Object element): remplace l'élément qui se trouve à l'indice i
int size() : retourne le nombre d'élément dans la liste.
boolean isEmpty() : retourne true si la liste est vide. Sinon false.
int lastIndexOf(Object elem): retourne la position de l'élément elem dans la liste. Si l'élément est
absent, alors retourne -1.
void removeRange(int i, int j) : supprime les éléments entre l'index i et j.
Un exemple d'application utilisant les ArrayList : Une agence modèle.
//Définition de la classe CModeles
package
MyPackage_TD_ArrayList;
public
class
CModeles {
//Attributs
private
String _nom;
private
String _prenom;
private
String _numTel;
private
int
age;
//getteur/setteur
public
String get_nom
(
) {
return
_nom;
}
public
void
set_nom
(
String _nom) {
this
._nom =
_nom;
}
public
String get_prenom
(
) {
return
_prenom;
}
public
void
set_prenom
(
String _prenom) {
this
._prenom =
_prenom;
}
public
String get_numTel
(
) {
return
_numTel;
}
public
void
set_numTel
(
String tel) {
_numTel =
tel;
}
public
int
getAge
(
) {
return
age;
}
public
void
setAge
(
int
age) {
this
.age =
age;
}
//Constructeur
public
CModeles
(
String _nom, String _prenom, String tel, int
age) {
this
._nom =
_nom;
this
._prenom =
_prenom;
_numTel =
tel;
this
.age =
age;
}
}
package
MyPackage_TD_ArrayList;
import
java.util.ArrayList;
public
class
ListeModeles {
//Création de l'ArrayList
ArrayList ListeModeles=
new
ArrayList
(
);
//Méthode permettant l'ajout d'un objet à la fin
public
void
ajouterElement
(
CModeles c )
{
ListeModeles.add
(
c);
}
//Méthode permettant l'ajout d'un objet à une position précis
public
void
ajouterElement
(
int
i, CModeles m)
{
ListeModeles.add
(
i,m);
System.out.println
(
"Ajout à la position"
+
i +
":"
+
m.get_nom
(
) );
}
//Suppression de l'élément qui se trouve à la position i
public
void
supprimerElement
(
int
i)
{
ListeModeles.remove
(
i);
}
//methode permettant d'afficher le contenu de la liste
public
void
afficher
(
)
{
for
(
int
indice=
0
; indice<
ListeModeles.size
(
);indice++
)
{
//Je vais afficher tous les objets
System.out.println
(
"Nom : "
+
((
CModeles) ListeModeles.get
(
indice)).get_nom
(
)
+
"
\n
"
+
"Prénom : "
+((
CModeles) ListeModeles.get
(
indice)).get_prenom
(
)
+
"
\n
"
+
"Age : "
+((
CModeles) ListeModeles.get
(
indice)).getAge
(
)
+
"
\n
"
+
"Téléphone : "
+((
CModeles) ListeModeles.get
(
indice)).get_numTel
(
)
+
"
\n
"
+
"__________________________"
);
}
}
}
package
MyPackage_TD_ArrayList;
import
java.util.ArrayList;
public
class
Main {
public
static
void
main
(
String[] args) {
//Création d'une liste
ListeModeles m1 =
new
ListeModeles
(
);
//Création des objets
CModeles julie =
new
CModeles
(
"Buisson"
, "Julie"
,"0140401502"
,21
);
CModeles Aline =
new
CModeles
(
"Durand"
, "Aline"
,"0140501232"
,20
);
CModeles Aurelie =
new
CModeles
(
"Nivoise"
, "Aurelie"
,"0174501502"
,25
);
CModeles Liane =
new
CModeles
(
"Lumiere"
, "Liane"
,"0144196562"
,28
);
CModeles Sylvie =
new
CModeles
(
"LaBelle"
, "Sylvie"
,"0178966562"
,24
);
//Ajout des objets dans l'ArrayList
m1.ajouterElement
(
julie);
m1.ajouterElement
(
Aline);
m1.ajouterElement
(
Aurelie);
m1.ajouterElement
(
Liane);
m1.afficher
(
); //Affiche le contenu de la liste
m1.supprimerElement
(
0
); //Supprimer l'élément à l'indice 0
System.out.println
(
"**************************************"
);
//Affiche le contenu de la liste
m1.afficher
(
);
System.out.println
(
"**************************************"
);
//Ajoute l'objet Sylvie à la position 1
m1.ajouterElement
(
1
,Sylvie);
//Affiche le contenu de la liste
m1.afficher
(
);
}
}
Le résultat d'affichage est le suivant :
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
Nom : Buisson
Prénom : Julie
Age : 21
Téléphone : 0140401502
__________________________
Nom : Durand
Prénom : Aline
Age : 20
Téléphone : 0140501232
__________________________
Nom : Nivoise
Prénom : Aurelie
Age : 25
Téléphone : 0174501502
__________________________
Nom : Lumiere
Prénom : Liane
Age : 28
Téléphone : 0144196562
__________________________
**************************************
Nom : Durand
Prénom : Aline
Age : 20
Téléphone : 0140501232
__________________________
Nom : Nivoise
Prénom : Aurelie
Age : 25
Téléphone : 0174501502
__________________________
Nom : Lumiere
Prénom : Liane
Age : 28
Téléphone : 0144196562
__________________________
**************************************
Ajout à la position1:LaBelle
Nom : Durand
Prénom : Aline
Age : 20
Téléphone : 0140501232
__________________________
Nom : LaBelle
Prénom : Sylvie
Age : 24
Téléphone : 0178966562
__________________________
Nom : Nivoise
Prénom : Aurelie
Age : 25
Téléphone : 0174501502
__________________________
Nom : Lumiere
Prénom : Liane
Age : 28
Téléphone : 0144196562
__________________________
XI. Les interfaces graphiques : SWING▲
Dans une interface graphique, il existe deux types de composants :
- Les conteneurs
- Les composants atomiques.
Un conteneur va permettre de placer des composants, par exemple une fenêtre.
Les composants atomiques sont des composants qui ne peuvent pas contenir d'autres composants, par exemple un bouton radio, un champ de texte, une image.
La classe JFrame
La création d'une application peut se faire par le biais de la classe JFrame. Cette classe appartient au paquetage javax.swing.
Création d'une fenêtre graphique simple
import
javax.swing.JFrame;
public
class
feni {
public
static
void
main
(
String[] args) {
JFrame F =
new
JFrame
(
);
F.setTitle
(
"une interface"
);
F.setSize
(
320
,150
);F.setVisible
(
true
);
}
}
JFrame F =
new
Jframe
(
); Création d'un objet F de type Jframe. F contient la référence de l'objet.
F.setTitle
(
"une interface"
): Attribution d'un titre à notre interface graphique.
F.setSize
(
320
,150
); Définition de la taille de la fenêtre.
F.setVisible
(
true
):Cette méthode va permettre de configurer la visibilité de la fenêtre. Elles peut prendre deux états :
* True : la fenêtre est alors visible.
* False : la fenêtre est alors invisible.
Autre méthode :
* void
setEnabled
(
boolean
b) : l'argument est de type boolean. Il va permettre de définir si le composant est active ou inactive. true ==>activer false==>désactiver
* boolean
isEnabled
(
) : cette méthode permet de connaître l'état du composant. Cette méthode retourne true si le composant est active. false dans le cas contraire.
* void
setBackground
(
Color c) : permet de définir une couleur du premier plan d'un composant.
* void
setForeground
(
Color c) : Modifie la couleur du premier plan d'un composant.
Ajout de composant
Pour ajouter un composant, il faut d'abord créer un panel c'est à dire un conteneur. Puis, il faudra ajouter les composants dans ce conteneur.
import
javax.swing.JButton;
import
javax.swing.JFrame;
import
javax.swing.JPanel;
public
class
feni {
public
static
void
main
(
String[] args) {
JFrame F =
new
JFrame
(
);
F.setTitle
(
"une interface avec un bouton"
);
F.setSize
(
340
,200
);
JPanel unpanel =
new
JPanel
(
);
F.add
(
unpanel);
JButton unboutton=
new
JButton
(
"JAVA"
);
unpanel.add
(
unboutton);
F.setVisible
(
true
);
}
}
Les étapes à suivre :
* Création d'une interface graphique
* Création d'un panel (Conteneur)
* Création des composants
* Ajout du panel à l'interface graphique
* Ajout des composants au conteneur
import
javax.swing.JFrame;
import
javax.swing.JPanel; Import des paquetages Jframe et Jpanel.
JPanel unpanel =
new
Jpanel
(
): // Création d'un panel,
c'est à dire un conteneur pour les composants.
F.add
(
unpanel) : Ajout du conteneur a l'interface graphique.
Button unboutton =
new
Jbutton
(
"JAVA"
) : Création d'un bouton qui affiche Bonjour.
unpanel.add
(
unboutton) : Ajout du bouton dans le conteneur.
Ajouter du texte dans le panel : JLabel
import
javax.swing.*;
public
class
feni {
public
static
void
main
(
String[] args) {
JFrame F =
new
JFrame
(
);
F.setTitle
(
" Application "
);
F.setSize
(
340
,200
);
JPanel unpanel =
new
JPanel
(
);
F.add
(
unpanel);
JButton unboutton=
new
JButton
(
" Hello "
);
unpanel.add
(
unboutton);
JLabel label =
new
JLabel
(
" Java est un langage de programmation"
);
unpanel.add
(
label);
F.setVisible
(
true
);
}
}
JLabel label =
new
JLabel
(
"Java est un langage de programmation "
);
unpanel.add
(
label); Création d'une étiquette et ajout dans le conteneur
Il est aussi possible de définir une taille pour un bouton.
2.
3.
JButton unbouton =
new
JButton
(
"Bonjour"
);
unbouton.setPreferredSize
(
new
Dimension
(
15
, 23
));
Les écouteurs
Un écouteur permet de réaliser une ou plusieurs actions lorsque l'on clique sur un bouton. Ces actions sont programmées dans la partie écouteur. Attention, il faut obligatoirement poser des écouteurs sur le bouton.
unboutton.addActionListener
(
this
); on ajoute un écouteur au bouton
Par la suite, il faut programmer le comportement de l'écouteur.
public
void
actionPerformed (
ActionEvent ev)
{
nbAppuie++
;
System.out.println (
"Appui sur le bouton Bonjour"
+
nbAppuie) ;
}
Programmer plusieurs écouteurs
Il est possible de programmer un comportement spécifique pour chaque composant.
import
javax.swing.* ;
import
java.awt.* ;
import
java.awt.event.* ;
class
FenetreBoutons extends
JFrame implements
ActionListener
{
static
int
nb =
0
;
public
FenetreBoutons (
)
{
setTitle (
"Ecouteur avec plusieurs boutons"
) ;
setSize (
600
, 100
) ;
monBouton1 =
new
JButton (
"Premier boutton"
) ; //Création des boutons
monBouton2 =
new
JButton (
"Deuxième boutton"
) ;
monBouton3 =
new
JButton (
"Troisième bouton"
) ;
JPanel contenu =
new
Jpanel
(
); //Création des conteneurs
super
.add
(
contenu);
contenu.add
(
monBouton1) ; //ajout des boutons dans le conteneur.
contenu.add
(
monBouton2) ;
contenu.add
(
monBouton3) ;
monBouton1.addActionListener
(
this
); //affectation des écouteurs
monBouton2.addActionListener
(
this
);
monBouton3.addActionListener
(
this
);
setVisible
(
true
);
}
public
void
actionPerformed (
ActionEvent ev)
{
String button =
ev.getActionCommand
(
) ;
if
(
button.equals
(
"Premier boutton"
))
{
nb++
;
System.out.println
(
"Appui sur le 1er boutton"
+
" "
+
nb);
}
if
(
button.equals
(
"Deuxième boutton"
))
{
nb=
nb+
2
;
System.out.println
(
"Appui sur le 2ème boutton"
+
" "
+
nb);
}
if
(
button.equals
(
"Troisième bouton"
))
{
nb=
nb+
3
;
System.out.println
(
"Appui sur le 3ème boutton"
+
" "
+
nb);
}
}
private
JButton monBouton1, monBouton2, monBouton3 ;
}
Résultat d'exécution :
2.
3.
4.
5.
Appui sur le 1er boutton 1
Appui sur le 2ème boutton 3
Appui sur le 3ème boutton 6
Appui sur le 2ème boutton 8
Appui sur le 1er boutton 9
Lorsque j'appuie sur chaque bouton, une action est programmée.
Le premier bouton incrémente la variable nb.
Le second bouton ajoute 2 à la variable nb. Le troisième bouton ajoute 3 à la variable nb.
monBouton1 =
new
JButton (
"Premier boutton"
); Création d'un bouton dont l'affichage
est " Premier boutton "
….
monBouton1.addActionListener
(
this
); ajout d'un écouteur à mon bouton
….
public
void
actionPerformed (
ActionEvent ev)
{
String button =
ev.getActionCommand
(
); // Cette ligne de commande récupère le nom du bouton
if
(
button.equals
(
"Premier boutton"
)) // on compare le texte récupéré pour le comparer à Premier boutton. Si c'est le cas, on va exécuter les instructions suivantes.
{
nb++
;
System.out.println
(
"Appui sur le 1er boutton"
+
" "
+
nb);
}
}
Les champs de texte
Dans une fenêtre, il faut allouer un espace pour permettre à l'utilisateur d'entrer un texte. Le JTextField est utilisé pour répondre à ce besoin.
Un JTextField se déclare de la manière suivante :
JTextField champ1 = new JTextField(20);
Pour affecter un texte par défaut au JtextField, il faut utiliser la méthode
setText(String unmot).
champ1.setText("bonjour");
Pour récupérer le texte tapé par l'utilisateur, il faut utiliser la méthode getText().
String unString = champ1.getText();
Les étiquettes
Lorsqu'on souhaite recueillir des informations, nous avons vu qu'il fallait utiliser des
JTextField. Mais pour guider l'utilisateur, il faut que les champs de texte soit
accompagnés par une étiquette. Ainsi, l'utilisateur saura la définition de chaque champ.
JLabel usernameLabel=new Jlabel("Nom");
Recueillir des informations
import
javax.swing.*;
public
class
feni extends
javax.swing.JFrame {
//Création des champs de texte
JTextField username =
new
JTextField
(
23
);
JTextField note =
new
JTextField
(
20
);
JTextArea appreciation =
new
JTextArea
(
4
,30
);
//Création des boutons
JButton ok =
new
JButton
(
"OK"
);
JButton cancel =
new
JButton
(
"Cancel"
);
public
feni
(
)
{
//Attribution du titre à la fenêtre
super
(
"Registre Etudiant"
);
//Attribution d'une taille
setSize
(
300
,220
);
//Création d'un conteneur
JPanel pane =
new
JPanel
(
);
//Création des étiquettes
JLabel usernameLabel=
new
JLabel
(
"Nom"
);
JLabel NoteLabel=
new
JLabel
(
"Note"
);
JLabel commentsLabel=
new
JLabel
(
"Appréciation"
);
//Retour à la ligne
appreciation.setLineWrap
(
true
);
appreciation.setWrapStyleWord
(
true
);
//Ajout des composants au conteneur
pane.add
(
usernameLabel);
pane.add
(
username);
pane.add
(
NoteLabel);
pane.add
(
note);
pane.add
(
commentsLabel);
pane.add
(
appreciation);
pane.add
(
ok);
pane.add
(
cancel);
add
(
pane);
//La fenêtre est visible
setVisible
(
true
);
//Verouillage de l'agrandissement de la fenêtre
setResizable
(
false
);
}
public
static
void
main
(
String [] args)
{
feni Fenetre=
new
feni
(
);
}
}
Les boites à cocher
Swing permet d'ajouter des boutons radios. Lorsque l'on souhaite interroger un utilisateur et qu'il existe deux où trois réponses, il est préférable d'utiliser des boutons radios.
Dans notre exemple, l'utilisateur doit répondre à une question. En fonction de sa réponse, le système va traduire sa réponse.
import
java.awt.* ;
import
java.awt.event.* ;
import
javax.swing.* ;
class
Fenetre extends
JFrame implements
ActionListener
{
public
Fenetre (
)
{
setTitle (
"Les cases a cocher"
) ;
setSize (
250
, 100
) ;
JPanel contenu=
new
JPanel
(
);
//Création d'une étiquette
JLabel uneetiquette =
new
JLabel
(
"Aimez vous Java?"
);
contenu.add
(
uneetiquette);
//Création des boutons radios
coche1 =
new
JCheckBox (
"Oui"
) ;
contenu.add
(
coche1) ;
coche1.addActionListener (
this
) ;
coche2 =
new
JCheckBox (
"Non"
) ;
contenu.add
(
coche2) ;
coche2.addActionListener (
this
) ;
etat =
new
JButton (
"Résultat"
) ;
contenu.add
(
etat) ;
etat.addActionListener (
this
) ;
super
.add
(
contenu);
}
public
void
actionPerformed (
ActionEvent ev)
{
Object source =
ev.getSource
(
) ;
if
(
source ==
coche1)
{
coche2.setSelected
(
false
);
}
if
(
source ==
coche2)
{
coche1.setSelected
(
false
);
}
if
(
source ==
etat)
{
if
(
coche1.isSelected
(
)==
true
){
System.out.println (
"L'utilisateur apprécie Java!"
); }
if
(
coche2.isSelected
(
)==
true
){
System.out.println (
"L'utilisateur n'apprécie pas Java!"
);
}
}
}
private
JCheckBox coche1, coche2 ; private
JButton etat ;
}
Le système affiche le résultat suivant :
Si l'utilisateur coche oui ==> L'utilisateur apprécie Java!
Si l'utilisateur coche non ==> L'utilisateur n'apprécie pas Java!
Par défaut, une case à cocher prend comme argument false. Ce qui signifie qu'il n'est pas cochée.
Il existe une méthode qui permet de modifier cet état.
MaCase.setSelected(true) ; //case cochée
Les groupes de checkbox
Une case à cocher peut prendre un seule état. C'est pourquoi, il est possible de faire des groupes de case à cocher.
Ceci empêche l'utilisateur de faire plusieurs choix pour la même question.
import
java.awt.*;
import
javax.swing.JPanel;
class
feni {
public
feni
(
)
{
Frame w =
new
Frame
(
" Groupes "
);
JPanel panel =
new
JPanel
(
);
w.setSize
(
300
,200
);
w.add
(
panel);
CheckboxGroup groupe=
new
CheckboxGroup
(
);
Checkbox box1=
new
Checkbox
(
"ING1"
,groupe,false
);
panel.add
(
box1);
Checkbox box2=
new
Checkbox
(
"ING2"
,groupe,true
);
panel.add
(
box2);
Checkbox box3=
new
Checkbox
(
"ING3"
,groupe,false
);
panel.add
(
box3); w.setVisible
(
true
);
}
}
CheckboxGroup groupe=
new
CheckboxGroup
(
);
Je vais définir un groupe de checkbox. Ici, je lui attribue le nom " groupe ".
Checkbox box1=new Checkbox("ING1",groupe,false);
Nous allons créer le premier élément.
Le premier argument est la valeur à afficher. Ici, " ING1 "
Le second est le nom de son groupe
Le troisième est sa valeur par défaut au lancement de la fenêtre.
Saisir du texte dans un champ et copier le contenu dans un autre champ
import
java.awt.* ;
import
java.awt.event.* ;
import
javax.swing.* ;
class
Fenetre extends
JFrame implements
ActionListener
{
public
Fenetre (
)
{
setTitle (
"Saisie et Copie de texte"
) ;
setSize (
300
, 120
) ;
JPanel contenu=
new
JPanel
(
);
entree =
new
JTextField (
20
) ;
contenu.add
(
entree) ; entree.addActionListener
(
this
) ;
bouton =
new
JButton (
"COPIER"
) ; contenu.add
(
bouton) ; bouton.addActionListener
(
this
) ;
sortie =
new
JTextField (
20
) ;
sortie.setEditable
(
false
);
contenu.add
(
sortie) ;
super
.add
(
contenu);
super
.setVisible
(
true
);
}
public
void
actionPerformed (
ActionEvent e)
{
if
(
e.getSource
(
) ==
bouton)
{
String texte =
entree.getText
(
) ;
sortie.setText
(
texte) ;
}
}
private
JTextField entree, sortie ;
private
JButton bouton ;
}
String texte = saisie.getText() ; : la méthode getText() permet de récupérer le texte saisi par l'utilisateur.
copie.setText(texte) ; : La méthode setText() permet d'affecter un texte à un champ.
copie.setEditable(false); La méthode setEditable(false) permet de verrouiller le champ.
Exercice d'application : PAINT
package
unpackage;
import
java.awt.* ;
import
java.awt.event.* ;
import
javax.swing.* ;
class
Fenetre extends
JFrame implements
ActionListener
{
public
Fenetre (
)
{
setTitle (
"ECE paint"
) ;
setSize (
400
, 200
) ;
Container contenu =
getContentPane
(
) ;
// creation paneau pour le dessin
pan =
new
Paneau
(
) ;
pan.setBackground (
Color.white) ;
contenu.add
(
pan) ;
// création des boutons
rectangle =
new
JButton (
"Rectangle"
) ;
contenu.add
(
rectangle, "North"
) ;
rectangle.addActionListener (
this
) ;
triangle =
new
JButton (
"triangle"
) ;
contenu.add
(
triangle, "West"
) ;
triangle.addActionListener (
this
) ;
ovale =
new
JButton (
"Ovale"
) ;
contenu.add
(
ovale, "South"
) ;
ovale.addActionListener (
this
) ;
trait =
new
JButton (
"Trait"
) ;
contenu.add
(
trait, "East"
) ;
trait.addActionListener (
this
) ;
super
.setResizable
(
false
);
}
//programmation des écouteurs
public
void
actionPerformed (
ActionEvent ev)
{
if
(
ev.getSource
(
) ==
rectangle) pan.setRectangle
(
) ;
if
(
ev.getSource
(
) ==
ovale) pan.setOvale
(
) ;
if
(
ev.getSource
(
)==
triangle) pan.setTriange
(
);
if
(
ev.getSource
(
)==
trait) pan.setTrait
(
);
pan.repaint
(
) ; // pour forcer la peinture du paneau des maintenant
}
private
Paneau pan ;
private
JButton rectangle, ovale ,triangle,trait;
}
//dessiner les dessins
class
Paneau extends
JPanel
{
public
void
paintComponent
(
Graphics g)
{
super
.paintComponent
(
g) ;
if
(
ovale) g.drawOval (
80
, 20
, 120
, 60
) ;
if
(
rectangle) g.drawRect (
80
, 20
, 120
, 60
) ;
if
(
triangle) {
g.drawLine (
80
, 20
, 175
, 60
) ;
g.drawLine
(
175
,60
,62
,100
);
g.drawLine
(
62
,100
, 80
,20
);
}
if
(
trait) g.drawLine (
80
, 20
, 178
, 60
) ;
//g.drawLine(100,100,250,300
}
public
void
setRectangle
(
) {
rectangle =
true
; ovale =
false
; triangle
=
false
;trait=
false
;}
public
void
setOvale
(
) {
rectangle =
false
; ovale =
true
; triangle
=
false
; trait=
false
; }
public
void
setTriange
(
) {
rectangle =
false
;ovale=
false
; triangle =
true
;
trait=
false
;}
public
void
setTrait
(
) {
rectangle =
false
;ovale=
false
; triangle
=
false
;trait=
true
;}
private
boolean
rectangle =
false
, ovale =
false
, triangle=
false
,
trait=
false
;
}
Les boites combinées
import
java.awt.* ;
import
java.awt.event.* ;
import
javax.swing.* ;
class
Fenetre extends
JFrame implements
ActionListener
{
private
String[] nombres =
{
"Choix"
,"un"
, "deux"
, "trois"
, "quatre"
, "cinq"
, "six"
}
;
private
JComboBox combobox ;
public
Fenetre
(
)
{
setTitle (
"Boite combinée"
) ;
setSize (
250
, 100
) ;
JPanel contenu=
new
JPanel
(
);
combobox =
new
JComboBox
(
nombres) ;
combobox.setEditable (
true
) ;
contenu.add
(
combobox) ;
combobox.addActionListener (
this
) ;
super
.add
(
contenu);
}
public
void
actionPerformed (
ActionEvent e)
{
Object valeur =
combobox.getSelectedItem
(
) ;
if
(
combobox.getSelectedItem
(
) !=
"Choix"
)
{
System.out.print (
"Choix : "
) ;
System.out.println ((
String) valeur);
}
}
}
GESTIONNAIRE DE MISE EN FORME : BORDER LAYOUT
Le gestionnaire de mise en forme, Border Layout, offre la possibilité de placer les
composants dans une zone géographique. C'est à dire, le conteneur est divisé en cinq
parties :
- Nord ( North )
- Sud ( South)
- Est (East)
- Ouest ( West)
- Centre ( Center)
Il existe plusieurs constructeursBorderLayout() : Création d'un gestionnaire BorderLayout.
BorderLayout(int hauteur; int verticale) : Création d'un gestionnaire
BorderLayout. Les arguments hauteur et verticale offre la possibilité de définir un
espacement entre les composants.
L'ajout d'un composant se réalise par le biais de la méthode add qui prend deux
arguments. Le premier argument est le composant et le second est sa position.
add(composant c , position p )
package
unpack;
import
java.awt.* ;
import
javax.swing.* ;
class
Fenetre extends
JFrame {
public
Fenetre (
) {
super
(
"Test BorderLayout"
) ; setSize
(
250
, 200
) ;
Container contenu =
getContentPane
(
) ;
contenu.setLayout
(
new
BorderLayout
(
3
,5
)) ;
contenu.add
(
new
JButton
(
"Centre"
),"Center"
) ;
contenu.add
(
new
JButton
(
" Nord"
), "North"
) ;
contenu.add
(
new
JButton
(
" Sud"
), "South"
) ;
contenu.add
(
new
JButton
(
"Ouest"
), "West"
) ;
contenu.add
(
new
JButton
(
"Est"
), "East"
) ;
}
}
GESTIONNAIRE DE MISE EN FORME : FLOW LAYOUT
Le gestionnaire de mise en forme FLOW LAYOUT, permet de placer les composants les
uns à la suite des autres, de gauche à droite.
import
java.awt.* ;
import
javax.swing.* ;
class
feni extends
JFrame {
public
feni (
) {
super
(
"Test FlowLayout"
) ;
setSize
(
400
, 100
) ;
Container contenu =
getContentPane
(
) ;
contenu.setLayout
(
new
FlowLayout
(
)) ; //Création du FlowLayout
JButton un =
new
JButton
(
"1"
); //Création des boutons
JButton deux =
new
JButton
(
"2"
);
JButton trois =
new
JButton
(
"3"
);
JButton quatre =
new
JButton
(
"4"
);
JButton cinq =
new
JButton
(
"5"
);
JButton six =
new
JButton
(
"6"
);
JButton sept =
new
JButton
(
"7"
);
JButton huit =
new
JButton
(
"8"
);
contenu.add
(
un); //ajout des boutons
contenu.add
(
deux);
contenu.add
(
trois);
contenu.add
(
quatre);contenu.add
(
cinq);
contenu.add
(
six);contenu.add
(
sept);
contenu.add
(
huit);
super
.setResizable
(
false
);
}
}
GESTIONNAIRE DE MISE EN FORME : GRIDLAYOUT
Le gestionnaire de mise en forme GRIDLAYOUT offre la possibilité de placer les composants les uns à la suite des autres sur une grille régulière. Chaque composant va alors occuper une cellule particulière de la grille.
Ils existent deux constructeurs :
public GridLayout(int verticale, int horizontal) permet de créer un gestionnaire sous forme d'une grille. Les arguments verticale et horizontal spécifient le nombre de ligne et de colonne.
public GridLayout(int rows, int cols, int hesp, int vesp) permet de créer un gestionnaire sous forme de grille. De plus, hesp et vesp définissent les espaces entre les différents composants.
package
unpack;
import
java.awt.* ;
import
javax.swing.* ;
class
Fenetre extends
JFrame {
public
Fenetre (
) {
super
(
"Un exemple GRIDLAYOUT"
) ; setSize
(
300
, 200
) ;
Container contenu =
getContentPane
(
) ;
contenu.setLayout
(
new
GridLayout
(
4
, 3
)) ;
contenu.add
(
new
JButton
(
"CAROTTE"
)) ; contenu.add
(
new
JButton
(
"TOMATE"
)) ;
contenu.add
(
new
JButton
(
"POMME"
)) ; contenu.add
(
new
JButton
(
"ORANGE"
)) ;
contenu.add
(
new
JButton
(
"CERISE"
)) ;
contenu.add
(
new
JButton
(
"ANANAS"
)) ;
contenu.add
(
new
JButton
(
"PECHE"
)) ;
contenu.add
(
new
JButton
(
"PIMENT"
)) ;
contenu.add
(
new
JButton
(
"CLEMENTINE"
)) ;
contenu.add
(
new
JButton
(
"KAKI"
)) ;
contenu.add
(
new
JButton
(
"RAISIN"
)) ;
contenu.add
(
new
JButton
(
"FRAISE"
)) ;
}
}
LES EVENEMENTS LIES A LA SOURIS
Il existe des écouteurs liés à la souris. Ces écouteurs peuvent nous informer de la position de la souris.
La souris est sur l'interface graphique
La souris n'est pas sur l'interface graphique
La souris a cliqué sur l'interface graphique
La souris presse sur l'écran graphique
La souris relâche la pression
Tous ces actions peuvent être programmées par le biais de méthode. Ces méthodes sont illustrées dans le programme suivant.
import
javax.swing.* ;
import
java.awt.event.* ;
class
MaFenetre extends
JFrame implements
MouseListener
{
static
int
nbClique =
0
;
static
int
nbEntrer =
0
;
static
int
nbPression =
0
;
static
int
nbExited =
0
;
static
int
nbRelache =
0
;
MaFenetre (
)
{
setTitle (
"Les evenements liés à la souris"
) ;
setBounds (
10
, 13
, 230
, 200
) ;
addMouseListener (
this
) ;
}
public
void
mouseClicked
(
MouseEvent ev)
{
nbClique++
;
System.out.println
(
"La souris a cliquée : "
+
nbClique +
"ème fois"
);
}
public
void
mousePressed (
MouseEvent ev) {
nbPression++
;
System.out.println
(
"La souris a presser"
+
nbPression +
"fois"
);
}
public
void
mouseReleased
(
MouseEvent ev) {
nbRelache++
;
System.out.println
(
"La souris a relachée"
+
nbRelache +
"fois"
);
}
public
void
mouseEntered (
MouseEvent ev)
{
nbEntrer++
;
System.out.println
(
"La souris est venue pour la "
+
nbEntrer +
"fois"
);
}
public
void
mouseExited (
MouseEvent ev) {
nbExited++
;
System.out.println
(
"La souris a quittée la fenetre"
+
nbExited +
"fois"
);
}
}
Résultat d'affichage :
2.
3.
4.
5.
6.
La souris est venu pour la 1ème fois
La souris a quitter la fenetre1ème fois
La souris est venu pour la 2ème fois
La souris a pressée1 ème fois
La souris a relachée1ème fois
La souris a cliquée : 1ème fois
LES MENUS ET LES BARRES D'OUTILS
Nous avons vu dans le cours qu'une fenêtre JFrame pouvait contenir des composants
atomiques tel que les boutons, les champs de texte.
Nous allons maintenant voir qu'il est
aussi possible de lui ajouter des menus et des barres d'outils.
Ils existent différents types d'objets:
les menus ( JmenuBar ) : permet de créer un menu
les items (Jmenu) : permet d'ajouter un élément au menu
la constitution des menus : permet de créer des items pour chaque élément.
package
unpack;
import
java.awt.* ;
import
javax.swing.* ;
class
Fenetre extends
JFrame {
private
JMenuBar Menusbarre ;
private
JMenu Fichier, Edition ;
private
JMenuItem ouvrir, enregistrer,copier, couper,
coller,apercu,fermer,imprimer ;
public
Fenetre (
) {
super
(
"Le Menu"
) ; setSize
(
100
, 200
) ;
Menusbarre =
new
JMenuBar
(
) ; setJMenuBar
(
Menusbarre) ;
Fichier =
new
JMenu
(
"Fichier"
) ;
Menusbarre.add
(
Fichier) ;
ouvrir =
new
JMenuItem
(
"Ouvrir"
) ;
Fichier.add
(
ouvrir) ;
enregistrer =
new
JMenuItem
(
"Enregistrer"
) ;
Fichier.add
(
enregistrer) ;
Fichier.addSeparator
(
) ;
apercu =
new
JMenuItem
(
"Aperçu"
) ;
Fichier.add
(
apercu) ;
imprimer =
new
JMenuItem
(
"Imprimer"
) ;
Fichier.add
(
imprimer) ;
Fichier.addSeparator
(
) ;
fermer =
new
JMenuItem
(
"Fermer"
) ;
Fichier.add
(
fermer) ;
Edition =
new
JMenu
(
"Edition"
) ;
Menusbarre.add
(
Edition) ;
couper =
new
JMenuItem
(
"Couper"
) ;
Edition.add
(
couper) ;
copier =
new
JMenuItem
(
"Copier"
) ; Edition.add
(
copier) ;
coller =
new
JMenuItem
(
"Coller"
) ; Edition.add
(
coller) ;
}
}
package
unpack;
import
java.awt.* ;
import
javax.swing.* ;
class
Fenetre extends
JFrame {
public
Fenetre (
) {
super
(
"les sous menus"
);
super
.setSize
(
200
,400
);
JMenuBar barreMenus =
new
JMenuBar
(
) ;
setJMenuBar
(
barreMenus) ;
JMenu export
=
new
JMenu
(
"Boisson"
) ;
barreMenus.add
(
export
) ;
JMenu format =
new
JMenu
(
"Gazeuse"
) ;
export
.add
(
format) ;
JMenuItem pdf =
new
JMenuItem
(
"light"
) ;
format.add
(
pdf) ;
JMenuItem html =
new
JMenuItem
(
"à la vanille"
) ;
format.add
(
html) ;
JMenuItem doc =
new
JMenuItem
(
"non gazeuse"
) ;
export
.add
(
doc) ;
JMenu MenuAChoix =
new
JMenu
(
"Fruit"
) ;
barreMenus.add
(
MenuAChoix) ;
JCheckBoxMenuItem choix1 =
new
JCheckBoxMenuItem
(
"pomme"
) ;
JCheckBoxMenuItem choix2 =
new
JCheckBoxMenuItem
(
"fraise"
) ;
JCheckBoxMenuItem choix3 =
new
JCheckBoxMenuItem
(
"orange"
) ;
MenuAChoix.add
(
choix1) ;
MenuAChoix.add
(
choix2) ;
MenuAChoix.add
(
choix3) ;
JMenu Exemple =
new
JMenu
(
"Legume"
) ;
barreMenus.add
(
Exemple) ;
JRadioButtonMenuItem unexemple =
new
JRadioButtonMenuItem
(
"Carotte"
) ;
JRadioButtonMenuItem unautreexemple =
new
JRadioButtonMenuItem
(
"Citron"
) ;
Exemple.add
(
unexemple) ; Exemple.add
(
unautreexemple) ;
ButtonGroup groupe =
new
ButtonGroup
(
) ;
//permet l'unicité à l'intérieur du groupe
groupe.add
(
unexemple) ; groupe.add
(
unautreexemple) ;
}
}
LES EXCEPTIONS
Lorsque nous développons un programme Java, il se peut qu'une erreur se produise à l'exécution du programme. Il faudra donc gérer tous les erreurs qui risquent de se présenter. Dans un champ, l'utilisateur saisi une lettre à la place d'un chiffre. Si le développeur n'a pas prit ses précautions, le programme java s'arrête avec un message d'erreur à la console. Les exceptions java vont permettre de traiter les cas particulier. Il va falloir indiquer l'action à réaliser si l'exception se présente.
try
{
//opération susceptible de générer une exception.
}
catch
(
exception 1
)
{
//Action à réaliser
}
Exception d'application :
Le programme doit calculer la somme d'une division. Nous savons par avance que deux erreurs peuvent être générer :
Division par zéro
Les nombres entrés par l'utilisateur peuvent être une lettre
Le programme suivant gère ces deux erreurs afin d'éviter s'arrête si ces deux exceptions se produisent.
public
class
Calcul {
public
static
void
main (
String[] args)
{
int
unnombre =
4
;
String unautrenombre1 =
"0"
;
int
total=
0
;
try
{
int
unautrenombre =
Integer.parseInt
(
unautrenombre1);
total =
unnombre /
unautrenombre;
System.out.println (
total);
}
catch
(
ArithmeticException exception)
{
System.out.println (
"La division par zéro n'est pas possible !"
);
}
catch
(
NumberFormatException nfe) {
System.out.println
(
"Ce n'est pas un entier"
);
}
}
}
Le bloc try va contenir toutes les instructions qui peuvent provoquer une erreur.
Le bloc catch va réaliser une action en fonction de l'exception générée.
XII. Base de données ▲
Installation d'une base de données sous Eclipse
Télécharger le serveur local Wamp : http://www.wampserver.com/dl.php
Il faut démarrer le serveur
Il faut sélectionner phpMyAdmin.
Sur l'interface de PhpMyAdmin :
1. Liste des bases : c'est la liste de vos bases de données.
2. Créer une base : pour créer une nouvelle base de données, tapez un nom dans le champ du formulaire à droite, cliquez sur " Créer".
INSTALLATION DE L'API JDBC
Pour installer " l'API JDBC ", il faudra faire un clic droit sur votre projet.
1. Sélectionner " Properties"
2. Sélectionner " Java Build Path "
3. Cliquer sur le bouton " Add External JARs… "
4. Sélectionner votre fichier jar " mysql-connector-java-5.1.10-bin "
Pour effectuer des opérations dans une base de données :
1. Il faudra se connecter
2. Il faudra s'identifier
3. Il faudra envoyer des commandes
Connexion et identification à la base de donnée
package
data_processing;
import
java.sql.DriverManager;
import
com.mysql.jdbc.Connection;
public
class
Connex {
static
Connection seconnecter
(
)
{
try
{
Class.forName
(
"com.mysql.jdbc.Driver"
);
String adresse =
"jdbc:mysql://localhost/tourisme"
;
String user =
"root"
;
String passwd =
""
;
Connection conn =
(
Connection) DriverManager.getConnection
(
adresse, user, passwd);
return
conn;
}
catch
(
Exception e) {
System.out.println
(
"Problème est survenue lors de la connexion à la bdd!"
);
}
return
null
;
}
}
Class.forName("com.mysql.jdbc.Driver"); : Il faut mentionner le driver
Il faut mentionner les paramètres de connexion à la base de données.
C'est-à-dire, l'adresse de la base de données, le nom de l'utilisateur, et le mot de passe.
String adresse = "jdbc:mysql://localhost/tourisme";
String user = "root";
String passwd = "";
Connection conn = (Connection) DriverManager.getConnection( adresse, user, passwd);
Envoie de commande Les méthodes doivent être placées dans la classe. Il ne faut pas oublier d'inclure la ligne de connexion dans la classe.
Cette ligne va permettre d'utiliser la connexionprivate static Connection theConnection = Connex.seconnecter();
Nous allons manipuler une table nommée " hotel " qui se trouve dans la base de données " tourisme ".
Afficher les données provenant de la base de données
public
void
AfficherHotel
(
){
String query =
"SELECT * FROM hotel WHERE 1;"
;
try
{
Statement state =
theConnection.createStatement
(
);
ResultSet res =
state.executeQuery
(
query);
while
(
res.next
(
)){
System.out.println
(
"Numéro : "
+
res.getString
(
"Id_Hotel"
)+
"
\n
"
+
"Nom : +res.getString("
Nom")+"
\n"+"
NbEtoile : "+ res.getString("
NbEtoile")+"
\n"+ "
Description : " +res.getString("
Description")+"
\n"+"
Prix par nuit : " + res.getString("
PrixparNuit") + "
€");
}
res.close
(
); state.close
(
);
}
catch
(
SQLException e) {
System.out.println
(
"Une erreur s'est produite!"
);
}
}
String query =
"SELECT * FROM hotel WHERE 1;"
; L'utilisateur va mentionner la requête.
Statement state = theConnection.createStatement(); Récupération de la connexion ResultSet res =
state.executeQuery
(
query);
Cette ligne va exécuter la requête. Puis, elle va retourner un objet de type ResultSet qui contient tous les résultats de la requête. L'objet " res " va stocker toutes les données.
Cette commande va permettre d'afficher les résultats obtenus à l'exécution de la requête.
2.
3.
while
(
res.next
(
)){
System.out.println
(
"Numéro : "
+
res.getString
(
"Id_Hotel"
)+
"
\n
"
+
"Nom : +res.getString("
Nom")+"
\n"+"
NbEtoile : "+ res.getString("
NbEtoile")+"
\n"+ "
Description : " +res.getString("
Description")+"
\n"+"
Prix par nuit : " + res.getString("
PrixparNuit") + "
€");
}
res.getString
(
"Nom"
) : dans notre cas, on demande à obtenir le contenu de la colonne " Nom "
while
(
res.next
(
)) va permettre de balayer toutes les lignes.
res.close
(
); Fermeture de la connexion
state.close
(
); Fermeture du Resultset
Supprimer toutes les données de la table
public
void
ViderTable
(
){
String query =
"TRUNCATE TABLE `hotel` ;"
;
try
{
Statement state =
theConnection.createStatement
(
);
ResultSet res =
state.executeQuery
(
query);
}
catch
(
SQLException e) {
System.out.println
(
"Une erreur est survenue lors de la suppression!"
);
}
}
String query =
"TRUNCATE TABLE `hotel` ;"
; L'utilisateur va mentionner la requête.
Etablissement de la connexion et exécution de la requête
2.
Statement state =
theConnection.createStatement
(
);
ResultSet res =
state.executeQuery
(
query);
Supprimer un hôtel par son index
public
void
supprimer_Hotel
(
int
idHotel) {
try
{
String query =
"DELETE FROM hotel"
+
" WHERE Id_Hotel = '"
+
idHotel+
"'"
;
Statement state =
theConnection.createStatement
(
);
int
nbEnregSup =
state.executeUpdate
(
query);
if
(
nbEnregSup ==
0
){
System.out.println
(
"La suppression s'est bien réalisée!"
);
}
else
{
state.close
(
);
}
}
catch
(
SQLException e){
System.out.println
(
"Une erreur est survenue lors de la suppression!"
);
}
}
}
Statement state = theConnection.createStatement(); Etablissement de la connexion
int nbEnregSup = state.executeUpdate(query); Exécution de la requête. La méthode executeUpdate retourne 0 en cas de succès.
Si l'opération s'est bien déroulée alors on affiche un message.
if (nbEnregSup == 0) {
System.out.println("La suppression s'est bien réalisée!");
}
Modifier les données d'un hotel
public
void
modifier_Hotel
(
int
id_Hotel, String name, int
nbEtoile, String description,int
prix) {
String query =
" UPDATE"
+
" `tourisme`.`hotel` SET "
+
"`Nom` = '"
+
name +
"'"
+
","
+
"`NbEtoile` = '"
+
nbEtoile +
"'"
+
","
+
"`Description` = '"
+
description +
"'"
+
","
+
"`PrixparNuit` = '"
+
prix +
"'"
+
" WHERE "
+
"`hotel`.`Id_Hotel` = "
+
id_Hotel +
" "
+
"LIMIT 1 "
+
";"
;
try
{
Statement state =
theConnection.createStatement
(
);
state.executeUpdate
(
query );
state.close
(
);
}
catch
(
SQLException e){
System.out.println
(
"Modification non effectuée"
);
}
}
Il s'agit de la requête
String query =
" UPDATE"
+
" `tourisme`.`hotel` SET "
+
"`Nom` = '"
+
name +
"'"
+
","
+
"`NbEtoile` = '"
+
nbEtoile +
"'"
+
","
+
"`Description` = '"
+
description +
"'"
+
","
+
"`PrixparNuit` = '"
+
prix +
"'"
+
" WHERE "
+
"`hotel`.`Id_Hotel` = "
+
id_Hotel +
" "
+
"LIMIT 1 "
+
";"
;
Etablissement de la connexion et Exécution de la requête. Fermeture de la connexion.
2.
3.
Statement state =
theConnection.createStatement
(
);
state.executeUpdate
(
query );
state.close
(
);
`tourisme`
.`hotel`
: tourisme est le nom de la base de données.
hotel est le nom de la table.