Cahier de TP Java

2 déc. 2002 ... Programmation avancée: TP Java. ... 2.8 Vos notes. 3 TP n°3 : Affiner la définition des classes ? Constructeurs et visibilités. 3.1 Constructeurs.


un extrait du document



DESS IGSI
Java
À : DESS IGSI
De : Laurent Perrussel (Laurent.Perrussel@univ-tlse1.fr)
Date :  DATE \@ "dd/MM/yy" \* MERGEFORMAT 02/12/02

Introduction
L’objectif de ce mémo est de présenter le langage Java. La programmation Java s’effectuera à l’aide de l’outil de développement JBuilder. Chaque chapitre fait l’objet d’une séance de travaux pratiques. Les travaux pratiques complètent le cours de programmation : les concepts de programmation (structures de données et de contrôles) sont supposés connus.
Le mémo est organisé en chapitres : chaque chapitre traite d’un thème et fait l’objet d’une mise en pratique en T.P. Les thèmes ne sont pas indépendants : ils supposent une certaine continuité dans l’apprentissage.


TABLES DES MATIERES


 TOC \o "1-4" Introduction  PAGEREF _Toc464381576 \h 1
1 TP n° 1 : Concepts de base  PAGEREF _Toc464381577 \h 6
1.1 Programmation orienté-objet  PAGEREF _Toc464381578 \h 6
1.2 Identifier et créer un objet  PAGEREF _Toc464381579 \h 6
1.3 Les données  PAGEREF _Toc464381580 \h 7
1.3.1 Données primitives  PAGEREF _Toc464381581 \h 8
1.3.2 Les tableaux  PAGEREF _Toc464381582 \h 8
1.3.3 Les chaînes de caractères  PAGEREF _Toc464381583 \h 9
1.3.4 Accès aux données  PAGEREF _Toc464381584 \h 9
1.4 Les classes  PAGEREF _Toc464381585 \h 7
1.4.1 Description type d’une classe  PAGEREF _Toc464381586 \h 7
1.5 JBuilder 3  PAGEREF _Toc464381587 \h 10
1.6 Exercice  PAGEREF _Toc464381588 \h 10
1.6.1 A faire  PAGEREF _Toc464381589 \h 14
1.7 Ce qu’il faut retenir  PAGEREF _Toc464381590 \h 14
1.8 Vos notes  PAGEREF _Toc464381591 \h 14
2 TP n° 2 : définir des méthodes  PAGEREF _Toc464381592 \h 15
2.1 Squelette d’une méthode  PAGEREF _Toc464381593 \h 15
2.2 Valeur de retour  PAGEREF _Toc464381594 \h 16
2.3 Appeler la méthode d’un objet  PAGEREF _Toc464381595 \h 16
2.4 La liste des arguments  PAGEREF _Toc464381596 \h 16
2.5 Les instructions de traitements  PAGEREF _Toc464381597 \h 17
2.5.1 Opérateurs mathématiques  PAGEREF _Toc464381598 \h 17
2.5.2 Instructions de contrôle  PAGEREF _Toc464381599 \h 17
2.5.2.1 Instruction conditionnelle  PAGEREF _Toc464381600 \h 18
2.5.2.2 Les instructions d’itérations  PAGEREF _Toc464381601 \h 18
2.6 Exercice  PAGEREF _Toc464381602 \h 19
2.6.1 A faire  PAGEREF _Toc464381603 \h 20
2.7 Ce qu’il faut retenir  PAGEREF _Toc464381604 \h 20
2.8 Vos notes  PAGEREF _Toc464381605 \h 20
3 TP n°3 : Affiner la définition des classes – Constructeurs et visibilités  PAGEREF _Toc464381606 \h 21
3.1 Constructeurs  PAGEREF _Toc464381607 \h 21
3.2 Visibilité des classes et de leur contenu  PAGEREF _Toc464381608 \h 22
3.2.1 Visibilité de la classe  PAGEREF _Toc464381609 \h 22
3.2.2 Visibilité des données et méthodes  PAGEREF _Toc464381610 \h 22
3.3 Exercice  PAGEREF _Toc464381611 \h 23
3.3.1 A faire  PAGEREF _Toc464381612 \h 24
3.4 Ce qu’il faut retenir  PAGEREF _Toc464381613 \h 24
3.5 Vos notes  PAGEREF _Toc464381614 \h 24
4 TP 4 : Création d’un dialogue  PAGEREF _Toc464381615 \h 25
4.1 La construction d’une interface  PAGEREF _Toc464381616 \h 25
4.2 Les composants  PAGEREF _Toc464381617 \h 25
4.2.1 Chargement des bibliothèques  PAGEREF _Toc464381618 \h 25
4.2.2 Type de composants  PAGEREF _Toc464381619 \h 25
4.2.2.1 Les conteneurs  PAGEREF _Toc464381620 \h 25
4.2.2.2 Les contrôles  PAGEREF _Toc464381621 \h 26
4.3 Description des contrôles  PAGEREF _Toc464381622 \h 27
4.3.1 Les boutons  PAGEREF _Toc464381623 \h 27
4.3.1.1 Constructeurs  PAGEREF _Toc464381624 \h 27
4.3.1.2 Quelques méthodes  PAGEREF _Toc464381625 \h 27
4.3.2 Les boites à cocher  PAGEREF _Toc464381626 \h 28
4.3.2.1 Constructeurs  PAGEREF _Toc464381627 \h 28
4.3.2.2 Quelques méthodes  PAGEREF _Toc464381628 \h 28
4.3.3 Les listes de choix  PAGEREF _Toc464381629 \h 28
4.3.3.1 Constructeurs  PAGEREF _Toc464381630 \h 28
4.3.3.2 Quelques méthodes  PAGEREF _Toc464381631 \h 29
4.3.4 Les listes  PAGEREF _Toc464381632 \h 29
4.3.4.1 Constructeurs  PAGEREF _Toc464381633 \h 29
4.3.4.2 Quelques méthodes  PAGEREF _Toc464381634 \h 30
4.3.5 Les zones de saisie  PAGEREF _Toc464381635 \h 30
4.3.5.1 Constructeurs  PAGEREF _Toc464381636 \h 30
4.3.5.2 Quelques méthodes  PAGEREF _Toc464381637 \h 31
4.4 Disposer les contrôles  PAGEREF _Toc464381638 \h 31
4.4.1 FlowLayout  PAGEREF _Toc464381639 \h 31
4.4.2 BorderLayout  PAGEREF _Toc464381640 \h 32
4.4.3 GridLayout  PAGEREF _Toc464381641 \h 32
4.4.4 GridBagLayout  PAGEREF _Toc464381642 \h 32
4.5 Exercice  PAGEREF _Toc464381643 \h 32
4.6 A faire  PAGEREF _Toc464381644 \h 35
4.7 Ce qu’il faut retenir  PAGEREF _Toc464381645 \h 35
4.8 Vos notes  PAGEREF _Toc464381646 \h 35
5 TP n°5 : Gérer des événements  PAGEREF _Toc464381647 \h 36
5.1 La gestion des événements  PAGEREF _Toc464381648 \h 36
5.1.1 Le contrôleur de la fenêtre  PAGEREF _Toc464381649 \h 36
5.1.2 Le contrôleur des contrôles  PAGEREF _Toc464381650 \h 36
5.2 question de méthode  PAGEREF _Toc464381651 \h 37
5.3 Exercice  PAGEREF _Toc464381652 \h 37
5.4 A faire  PAGEREF _Toc464381653 \h 38
5.5 Ce qu’il faut retenir  PAGEREF _Toc464381654 \h 38
5.6 Vos notes  PAGEREF _Toc464381655 \h 39
6 TP n°6 : Héritage et interface  PAGEREF _Toc464381656 \h 40
6.1 Héritage  PAGEREF _Toc464381657 \h 40
6.1.1 Une seconde visite du parking  PAGEREF _Toc464381658 \h 40
6.2 Classes abstraites  PAGEREF _Toc464381659 \h 42
6.3 Interface  PAGEREF _Toc464381660 \h 42
6.4 Exercice  PAGEREF _Toc464381661 \h 43
6.5 Ce qu’il faut retenir  PAGEREF _Toc464381662 \h 43
Vos notes  PAGEREF _Toc464381663 \h 43
7 TP n° 7 : Vecteurs et listes  PAGEREF _Toc464381664 \h 44
7.1 Description d’un vecteur  PAGEREF _Toc464381665 \h 44
7.1.1 Création d’un vecteur  PAGEREF _Toc464381666 \h 44
7.1.2 Quelques méthodes  PAGEREF _Toc464381667 \h 44
7.2 Concordance de types et transtypage  PAGEREF _Toc464381668 \h 45
7.3 Exercice  PAGEREF _Toc464381669 \h 45
7.4 Ce qu’il faut retenir  PAGEREF _Toc464381670 \h 46
Vos notes  PAGEREF _Toc464381671 \h 46
8 TP n°8 : L’architecture modèle – Vue – Contrôleur  PAGEREF _Toc464381672 \h 47
8.1 Fonctionnement  PAGEREF _Toc464381673 \h 47
8.2 Présenter des données dans des tables  PAGEREF _Toc464381674 \h 48
8.3 Description des composants Listes et Tables  PAGEREF _Toc464381675 \h 50
8.3.1 Les Listes  PAGEREF _Toc464381676 \h 50
8.3.1.1 Constructeurs  PAGEREF _Toc464381677 \h 50
8.3.1.2 Quelques méthodes  PAGEREF _Toc464381678 \h 50
8.3.2 Les modèles de données « Liste »  PAGEREF _Toc464381679 \h 50
8.3.2.1 L’interface ListModel  PAGEREF _Toc464381680 \h 50
8.3.2.2 La classe abstraite AbstractListModel et la classe DefaultListModel  PAGEREF _Toc464381681 \h 50
8.3.3 Les Tables  PAGEREF _Toc464381682 \h 51
8.3.3.1 Constructeurs  PAGEREF _Toc464381683 \h 51
8.3.3.2 Quelques méthodes  PAGEREF _Toc464381684 \h 52
8.3.4 Les modèles de données « Table »  PAGEREF _Toc464381685 \h 52
8.3.4.1 L’interface TableModel  PAGEREF _Toc464381686 \h 52
8.3.4.2 La classe abstraite AbstractTableModel et la classe DefaultTableModel  PAGEREF _Toc464381687 \h 53
8.4 Exercice  PAGEREF _Toc464381688 \h 54
8.4.1 A faire  PAGEREF _Toc464381689 \h 54
8.5 Ce qu’il faut retenir  PAGEREF _Toc464381690 \h 55
8.6 Vos Notes  PAGEREF _Toc464381691 \h 55
9 TP n°9 : Hashtables  PAGEREF _Toc464381692 \h 56
9.1 Description de la classe HashTable  PAGEREF _Toc464381693 \h 56
9.1.1 Constructeurs  PAGEREF _Toc464381694 \h 56
9.1.2 Quelques méthodes  PAGEREF _Toc464381695 \h 56
9.2 Description de l’interface Enumeration  PAGEREF _Toc464381696 \h 57
9.2.1 Les méthodes  PAGEREF _Toc464381697 \h 58
9.3 Exercice  PAGEREF _Toc464381698 \h 58
9.4 A faire  PAGEREF _Toc464381699 \h 58
9.5 Ce qu’il faut retenir  PAGEREF _Toc464381700 \h 58
9.6 Vos Notes  PAGEREF _Toc464381701 \h 59
10 TP n° 10 : Arbres, récursivité  PAGEREF _Toc464381702 \h 60
10.1 Spécification d’un arbre  PAGEREF _Toc464381703 \h 61
10.2 Exercice  PAGEREF _Toc464381704 \h 62
10.2.1 A faire  PAGEREF _Toc464381705 \h 63
10.3 Ce qu’il faut retenir  PAGEREF _Toc464381706 \h 63
Vos Notes  PAGEREF _Toc464381707 \h 63
A. Quelques Références  PAGEREF _Toc464381708 \h 64


TP n° 1 : Concepts de base
Programmation orienté-objet
Java est un langage orienté objet. Un objet est, de manière intuitive, un ensemble de données et un ensemble de fonctions/procédures s’appliquant sur ces données.
Exemple : une calculatrice élémentaire. Les deux nombres représentent les données et les opérations de base comme la multiplication ou la soustraction sont les fonctions.

Les fonctions/procédures sont appelées des méthodes. Les méthodes décrivent le comportement de l’objet.
Un programme en Java est un ensemble d’objets exécutant des méthodes ou demandant l’exécution de méthodes par les autres objets en leur envoyant des messages.
L’ensemble des objets de même type forme une classe d’objets.
Identifier et créer un objet
Tous les objets manipulés en Java doivent être identifiés. Cette identification permet de désigner et donc de manipuler l’objet : modifier ses données ou demander l’exécution de méthodes. Une identification s’effectue en mentionnant deux caractéristiques : quel est l’identifiant de l’objet et sa classe :
ClasseObjet NomObjet ;
Exemple : Pour pouvoir manipuler la calculatrice, nous déclarons un identifiant d’objet : c. Cet identifiant permettra de désigner des objets de la classe des calculatrices.
Calculatrice c ;
La ligne précédente est une déclaration. Cette définition ne permet pas d’avoir l’objet identifié par c à notre disposition, c’est-à-dire qu’on ne peut pas, par exemple, demander à la calculatrice ayant l’identifiant c d’effectuer une opération arithmétique. Il faut pour cela créer l’objet. La création s’effectue à l’aide de l’opérateur new. Cette instruction fait partie du jeu d’instructions de base du langage. Une création d’objet suit la syntaxe suivante :
NomObjet = new ClasseObjet(…) ;
Exemple : Pour pouvoir manipuler la calculatrice, nous créons un objet de la classe Calculatrice. L’objet est désigné à l’aide de l’identifiant c. Autrement dit, c référence un objet de la classe des calculatrices
c = new Calculatrice() ;
Les données
Les données manipulées dans un objet décrivent l’état d’un objet. Ainsi dans un objet de la classe des thermostats, la température qui est une valeur numérique représente la température désirée. Le comportement est lui limiter à deux fonctionnalités : monter la température et descendre la température.
Maintenant considérons un client et ses commandes :

 SHAPE \* MERGEFORMAT 
Si nous considérons maintenant des objets de ces classes :







Un client à des caractéristiques de base (nom, ville,…) qui sont du texte et des caractéristiques plus complexes : la liste des commandes. Cette liste est en fait un objet composé d’un ensemble de commandes. De fait, nous voyons que chaque commande est-elle même un objet et, que chaque ligne de commande contient deux informations : l’article et la quantité commandé. L’article est un objet et la quantité est une valeur numérique.
Les classes
Une classe est décrite dans un document portant l’extension .java. Ce document ne doit contenir qu’une seule classe et le nom du document est le même nom que celui de la classe.
Exemple : Nom du fichier associé à la classe LignesDeCdes : LignesDeCdes.java
Description type d’une classe
Une classe est décrite à l’aide du mot-clef class :
class maClasse {
…
description de la classe (données + méthodes)
…
}
La description proprement dite, appelée corps de la classe, est spécifiée entre accolades.
Exemple : description de la classe lignes de commandes. Une ligne de commande contient un article et une quantité commandée. L’article s’appelle article_commande et est un objet de la classe Article. La quantité est une valeur entière.
class LignesDeCdes  {
Article article_commande ; int qte_cdee ;
}
Dans un objet il ne peut y avoir que deux types d’attributs :
des objets,
des valeurs primitives (qui ne sont pas des objets).


Données primitives
Les principaux types de données primitives sont représentés dans le tableau ci-après.
NomDescriptionbooleanValeur logique (true, false)charCaractèreintEntierlongEntier longfloatRéeldoubleRéel long
La déclaration de variables primitives nécessite uniquement une déclaration.
Exemple : Pour pouvoir manipuler une quantité
int qte ;
Les tableaux
Les tableaux permettent de manipuler des listes d’objets ou de données primitives. Un tableau qu’il soit un tableau d’objets ou un tableau de valeurs primitives est lui-même un objet.
La déclaration et la manipulation des tableaux s’effectuent à l’aide des crochets []. Le premier indice du tableau est toujours 0. Le nom du tableau indicé permet d’accéder à un item du tableau.
Exemple : déclaration d’un tableau tableauValeurs de valeurs entières. Ce tableau contient dix cases.
int[] tableauValeurs ;
Les tableaux étant des objets, il convient donc de créer le tableau proprement dit après l’avoir identifié. Cette opération est effectuée à l’aide du mot clef new.
tableauValeurs = new int[10] ;
Accès au cinquième élément du tableau et initialisation de sa valeur (à 9) :
tableauValeurs[4] = 9 ;
Plus généralement, il est tout à fait possible d’avoir un tableau d’objets. Dans ce cas, nous avons la même procédure en deux temps : déclaration puis création du tableau :
LignesDeCdes[] les_lignes ; … les_lignes = new LignesDeCdes[10] ;
Le résultat produit par cette dernière instruction a été la déclaration d’un tableau de 10 identifiants d’objets LignesDeCdes. Il faut donc ensuite créer chaque élément du tableau individuellement. Ainsi, si nous considérons la création de la troisième ligne de commande :
les_lignes[2] = new LignesDeCdes() ;
Les chaînes de caractères
Pour manipuler les chaînes de caractères, Java propose une classe prédéfinie : String. Pour créer une chaîne, plusieurs commandes sont possibles : création d’un objet ou affectation directe.
String chaine1, chaine2; … chaine1 = new String("toto") ; chaine2 = "titi" ;
Accès aux données
Les fonctions et procédures vont manipuler les données. L’accès aux données d’un objet doit mentionner deux éléments : quel est l’objet accédé et quelle information de cet objet souhaitons nous consulter et/ou modifier. En Java, nous « connectons » ces deux informations à l’aide d’un point : NomObjet.NomDonnee
Exemple : modifier la valeur du premier nombre, nommé Nombre1 de notre calculatrice c, en initialisant la valeur à 10
c.Nombre1 = 10 ;
Traduction Java de l’exemple
Nous nous limitons ici à la définition des attributs. Lorsque les attributs sont des objets, nous n’avons donc que la spécification de l’identifiant.
Notons que chaque classe est contenue dans un fichier différent :
Client.java, Commande.java, LigneCommande.java, Article.java.
class Client  {
String nom, ville, telephone ; Commande[] commandes ;
}
class Commande  {
String noCde  ; LigneDeCde[] lesLignes;
}class LigneCommande  {
Article articleCommande  ; int qte;
}
class Article  {
…;
}JBuilder 3
JBuilder est un outil d’aide au développement : aide à la définition d’interfaces, documentation, déboguage… La réalisation d’un programme s’effectue dans un projet : un projet regroupe un ensemble de classes et de fichiers de documentation.
Les classes sont des fichiers textes portant l’extension .java et les documents sont des pages Web portant l’extension .html.
Exercice
L’objectif est de créer une première classe élémentaire pour découvrir l’environnement JBuilder 3.
Cette classe a pour objet de décrire des bureaux. Un bureau est défini par un numéro de bureau et un occupant.
La première étape est de créer un projet : l’appel de l’expert se fait avec la commande Fichier/Nouveau Projet. L’expert projet permet de donner une première description du projet.

Cette description est utilisée par JBuilder pour créer le premier document décrivant votre projet. Ce document est présenté dans l’outil de navigation du projet. Le navigateur présente dans la partie gauche deux zones : la zone supérieure répertorie l’ensemble des composants du projet. La partie inférieure gauche indique les caractéristiques du composant sélectionné. La partie droite affiche le document.



La seconde étape consiste à créer notre première classe. La création d’une classe s’effectue à l’aide de la commande Fichier/Nouveau…, commande présentant l’invite suivant :

Après avoir choisi le composant Classe, spécifier la description de votre classe : indiquer Bureau comme nom de classe et cochez la case public.


La description de votre classe est la suivante :
class Bureau {
}
Compléter votre classe en précisant les données manipulées :
String nom_bureau; String occupant;
L’étape suivante consiste à créer deux bureaux : bureau1 et bureau2 et à garnir les informations de ces bureaux.
Pour que le programme puisse fonctionner, nous devons indiquer un point de démarrage. Au démarrage, le programme créera les deux bureaux. Dans une classe le point de démarrage est spécifier à l’aide d’une fonction particulière appelée main. La déclaration complète de cette fonction est :
public static void main(String[] args)
La description de notre classe est donc maintenant
class Bureau {
…
public static void main(String[] args) {
Bureau bureau1 ;
bureau1 = new Bureau() ; bureau1.nom_bureau = "ME403" ; …
}
}
Le programme écrit il faut compiler et exécuter le programme :
La compilation du programme s’effectue à l’aide de la commande Projet/Make pour le projet.
L’exécution du programme s’effectue à l’aide de la commande Exécuter/Exécuter "bureau". L’exécution ouvre une fenêtre console et le programme s’exécute dans cette fenêtre. Si la fenêtre console se referme automatiquement, bloquez son affichage en modifiant les paramètres d’exécution avec le menu Exécuter/Paramètres… et inhiber la fermeture de la fenêtre :



La compilation et l’exécution ne produisent aucun résultat. Il faut demander à ce que le programme affiche des données. L’instruction d’affichage est la suivante :
System.out.println(valeurAAfficher) ;
Si vous demander l’affichage d’un des numéros de bureau, vous obtenez :
AppAccelerator(tm) 1.2.010 for Java (JDK 1.2), x86 version.
Copyright (c) 1997-1999 Inprise Corporation. All Rights Reserved.
ME403

Tapez Ctrl+C pour terminer l'application…


A faire
Créer une seconde classe dans votre projet décrivant les occupants des bureaux. Les occupants ont un numéro de badge (valeur entière), un nom et un prénom.
Modifiez la classe Bureau afin que l’occupant soit un objet de la classe créée précédemment. Demandez la création de deux bureaux et affichez leurs contenus.
Modifiez la classe Bureau afin de pouvoir représenter le fait qu’il y ait deux personnes occupant un bureau. Prenez cette modification en compte en utilisant un tableau à deux positions. Demandez la création d’un bureau, initialisez les valeurs et affichez les valeurs.
Ce qu’il faut retenir
Comment définir une classe ;
Comment identifier et créer des objets ;
Les types de données primitives ;
La méthode main ;
Ecrire, compiler et exécuter un programme avec JBuilder.

Vos notes


TP n° 2 : définir des méthodes
Dans le TP précédent, nous nous sommes focalisés sur la description des données. Nous abordons dans ce TP la description du comportement des données. Le comportement des données est décrit à l’aide de méthodes. Les méthodes sont des fonctions ou procédures. Les méthodes décrivent des traitements.
Squelette d’une méthode
La description d’une méthode contient les éléments suivants : son nom, les arguments, la valeur de retour et la description du traitement. Autrement dit :
TypeDonneeRetour NomMethode(ListeDesArguments) {
Description de la méthode
}
De fait, la description d’une classe devient : description des données et description des méthodes.
class NomClasse {
/* Description des données */
typeDonnee1 nomDonnee1 ; typeDonnee2 nomDonnee2 ; …
/* Description des méthodes */
typeRetour1 methode1(…) { … }
typeRetour2 methode2(…) { … }
…
}

Exemple : reprenons l’exemple du TP précédent : une calculatrice élémentaire. Nous ajoutons une méthode additionner à la classe. La classe contient deux nombres entiers nb1 et nb2 :
class Calculatrice {
/* Description des données */
int nb1, nb2 ;
/* Description des méthodes */
…
}
Décrivons tout d’abord l’entête : la valeur retournée est un nombre entier, le nom de la méthode est additionner et la liste des arguments est vide car les deux nombres à additionner sont déjà dans la calculatrice (nb1 et nb2). Le corps de la méthode doit additionner ces deux valeurs et indiquer que le total doit être la valeur à retourner. Autrement dit :
int additionner() {
int total ; // déclaration d’une variable
total = nb1 + nb2 ; // traitement
return total ; // retour de la méthode
}
Nous voyons sur l’exemple que nous pouvons déclarer des variables ou plus généralement des données dans le corps d’une méthode. Le corps d’une méthode contient trois éléments principaux :
Instructions de déclarations de données + instructions de traitements + instructions de retour
Notons aussi dans l’exemple que la valeur retournée est bien une valeur entière (cf. déclaration de total).
Valeur de retour
L’instruction de retour, qui « normalement » conclut le corps de la méthode est return suivi de l’objet retourné. Le type de l’objet doit être le même que celui mentionné dans l’entête de la méthode. Notons qu’une méthode peut aussi bien retourner un objet, qu’une valeur primitive.
Lorsqu’une méthode ne retourne aucune valeur celle-ci est de type void. L’instruction return qui apparaît dans la liste des instructions ne mentionne pas dans ce cas d’objet.
Appeler la méthode d’un objet
Les méthodes sont dans des objets. L’appel d’une méthode doit donc mentionner l’objet associé. Autrement dit, il faut mentionner : le nom de l’objet + le nom de la méthode. L’association entre ces deux éléments se fait avec un point :
variableRecuperation = nomObjet.nomMethode(listeDesArguments) ;
Il est clair que la variable récupérant la valeur renvoyée par la méthode doit être compatible avec la valeur retournée par la méthode.
Lorsque la méthode est de type void, il ne faut pas mentionner de variable de récupération :
nomObjet.nomMethode(listeDesArguments) ;
La liste des arguments
La liste des arguments spécifie les informations additionnelles nécessaires au traitement effectué par la méthode. Additionnelles car elles ne sont pas présentes dans les données internes à la classe. La liste des arguments est une liste d’objets et/ou de données de base. Chaque argument de la liste est séparé par une virgule, et la description de l’argument se fait en deux temps : type de la variable et nom de la variable. Autrement dit :
TypeRetour nomMethode(typeVar1 nomVar1, typeVar2 nomVar2,…) {…} 
Exemple : supposons que nous ajoutions une méthode pour initialiser les deux nombres de notre calculatrice. Cette méthode reçoit en paramètre deux valeurs entières et ne retourne aucune valeur.
void initNombres(int valeur1, int valeur2) {
nb1 = valeur1 ; // traitement nb2 = valeur2 ;
return ; // retour de la méthode
}
L’appel se fera comme suit, si nous supposons disposer d’un objet calculatrice nommé c :
c.initNombres(3,7) ;
i = 10 ; c.initNombres(i,8) ;
Les instructions de traitements
Le dernier point concerne le jeu d’instructions proprement dit. Nous donnons ici quelques instructions types. Pour une liste exhaustive, se référer au manuel Java en ligne.
Opérateurs mathématiques
Les opérateurs mathématiques se subdivisent en trois catégories : les opérateurs arithmétiques, les opérateurs de comparaison, les opérateurs logiques.
Tableau  SEQ Tableau \* ARABIC 1 : opérateurs arithmétiques
SymboleDescription+Addition-Soustraction*Multiplication/Division%Modulo =Assignation++Opérateur unaire d’incrémentation.--Opérateur unaire de décrémentation.
Tableau  SEQ Tableau \* ARABIC 2 : opérateurs de comparaison
SymboleDescription>Supérieur valeur2) rst =  1; else rst = -1 ;
return rst;
Les instructions d’itérations
Les instructions d’itérations sont au nombre de trois : le TANTQUE – FIN TANTQUE, le REPETER – JUSQUA et la boucle POUR. Les deux premières boucles sont représentées ci-après. Notons que le REPETER – JUSQUA (boucle de droite) n’a pas de représentation directe. En effet la condition est une condition d’arrêt alors que la traduction en Java par un do… while exige une condition de poursuite.
while(condition) instruction do instruction while(condition) ;
La boucle POUR est représentée par l’instruction for. L’instruction exige trois arguments : une instruction d’initialisation, une expression logique de poursuite et une instruction à exécuter à chaque boucle.
for(initialisation ; condition de poursuite ; pas) instruction 
Exemple : initialiser un tableau à 0. Supposons une classe Tableau contenant comme attribut un tableau de valeurs entières :
class Tableau {
static int DIMENSIONTABLEAU = 10;
int[] tableau;
}
La méthode initialise crée le tableau et initialise toutes les valeurs à zéro.
class Tableau {
static int DIMENSIONTABLEAU = 10;
int[] tableau;
void initialiser() {
int i ;
tableau = new int[DIMENSIONTABLEAU]; for(i = 0 ; i < DIMENSIONTABLEAU ; i++) tableau[i]=0 ;
}
}
Exercice
L’objectif de ce programme est de pouvoir calculer des résultats électoraux. Il s’agit de pouvoir construire des méthodes simples et de les appeler.
IL s’agit de décrire des élections locales. Dans une élection, il y a plusieurs candidats. Chaque candidat a un nom et un prénom. Nous supposons qu’à chaque élection il y a trois candidats. Dans une élection, chaque candidat obtient des suffrages (nombres de voix). Autrement dit, les données vont être structurées comme suit :

Implémenter les classes en Java.
Ajouter une méthode main à votre classe Election et créer des objets des différentes classes.
Implémenter les fonctionnalités ci-après. Pour chaque service, définissez tout d’abord à quelle classe celui-ci doit être attaché. Ensuite, déterminez la spécification de vos méthodes : valeur retournée et paramètres attendus :
Un service calculant la proportion de voix obtenues par un candidat.
Un service déterminant si un candidat est éliminé (nb. voix < 25%), maintenu au second tour (25% < nb. voix < 50%) ou élu (> 50%).

Prenez soin de créer un nouveau projet pour votre travail. Vous supposerez que les données sont chargées dans la fonction main. La fonction main appellera aussi les méthodes et affichera les résultats.
A faire
Modifier le programme pour qu’il puisse prendre en compte plusieurs bureaux de vote. La définition de classe(s) supplémentaire(s) est nécessaire.
Définir une méthode retournant un tableau contenant le(s) nom(s) des candidats admis au second tour ou du candidat élu.
Ce qu’il faut retenir
Description d’une méthode (Type de donnée en retour, arguments,…) ;
Appel de méthodes ;
Instructions de traitement : les instructions, bloc d’instructions, les boucles les conditionnels.

Vos notes

TP n°3 : Affiner la définition des classes – Constructeurs et visibilités
L’objectif du TP est de détailler le processus de création des classes : travail d’initialisation lors de la création d’objets et contrôle des accès aux données internes d’une classe.
Constructeurs
Il est fréquent lors de la création d’objets qu’une étape d’initialisation soit nécessaire. Il s’agit par exemple d’initialiser un tableau à zéro, ou bien effectuer des créations préalables. Ces instructions sont à effectuer à la création de l’objet. Il faut donc préciser dans le programme qu’à l’exécution de l’instruction new Classe(), il faut exécuter un bloc d’instructions additionnel. Ce mécanisme peut être garanti par l’utilisation de constructeurs. Un constructeur est une méthode spéciale où sont spécifiées les instructions d’initialisation. Un constructeur est facilement identifiable car il porte le même nom que la classe.
La présence d’un constructeur n’est pas obligatoire. Il y a toujours une procédure de création implicite par défaut définie dans Java.
Exemple : constructeur initialisant directement les valeurs d’un occupant de bureau. Un occupant est décrit par un nom et un prénom ainsi qu’un numéro de badge.
class Occupant {
String nom, prenom ; int num_badge ;
Occupant(String nom, String prenom, int badge) {
this.nom = nom ; // description du constructeur this.prenom = prenom ; this.num_badge = badge ; }
}
Notons qu’un constructeur ne retourne jamais de valeur. Autrement dit un constructeur n’est pas une méthode. Les instructions sont exécutées lors de la création de l’objet. A l’utilisation de l’instruction, il doit y avoir correspondance entre les types de données spécifiés dans le constructeur et les arguments envoyés :
o = new Occupant("Sartre","Raymond",12) ;
Le constructeur permet d’unifier la création et l’initialisation. Si l’objet doit être initialisé différemment en fonction des paramètres reçus, il faut alors définir plusieurs constructeurs.
Exemple : dans la classe Occupant, nous ajoutons un second constructeur. Ce constructeur permet de créer un occupant sans initialiser les valeurs.
class Occupant {
String nom, prenom ; int num_badge ;
Occupant() {
nom = "" ; // description du premier constructeur prenom = ""; num_badge = 0 ;
}
Occupant(String nom, String prenom, int badge) {
this.nom = nom ; // description du second constructeur this.prenom = prenom ; num_badge = badge ;
}
}
Visibilité des classes et de leur contenu 
Les informations contenues dans une classe sont accessibles, par défaut, depuis les autres classes. Cette visibilité n’est que partiellement nécessaire, certaines données sont des informations temporaires ou de travail et n’exigent pas d’être visibles depuis l’extérieur, c’est-à-dire des autres classes.
Visibilité de la classe 
Afin que les classes soient accessibles elles doivent être déclarées publiques (public). Les classes qui ne sont pas publiques sont accessibles uniquement par les classes contenues dans le paquetage d’origine de cette classe.
Visibilité des données et méthodes
Les droits d’accès aux données et méthodes d’un objet sont de trois niveaux : public, privé et protégé.
public : les méthodes et données mentionnées comme publiques sont visibles depuis n’importe quel autre objet (i.e. les données étant accessibles, elles sont donc modifiables).
private : les méthodes et données privées sont inaccessibles depuis les autres classes. Le seul moyen d’accès est depuis la classe elle-même.
protected : les données sont visibles et modifiables par les sous-classes de la classe. Elles sont aussi accessibles depuis les classes du même paquetage.
Une règle, qui n’est pas systématique, veut que les données soient privées. Ceci permet de les protéger d’accès malencontreux mais garantit une indépendance des services : les classes sont utilisées conformément aux services annoncés et les services utilisent les données qu’ils souhaitent (autrement dit peu importe la manière dont le service est rendue).
L’accès aux données sera défini plus finement en spécifiant des méthodes permettant de connaître une valeur (get) et des méthodes permettant de modifier une valeur (set).
Exemple : La classe Occupant est spécifiée publique et les données privées. Nous donnons une méthode d’accès aux noms et de modification du prénom qui sont publiques. Les constructeurs sont spécifiés en tant que publics.
public class Occupant {
private String nom, prenom ; private int num_badge ;
public Occupant() {
nom = "" ; // description du premier