1.Programmation en Java : notions de base, orienté objet et héritage

Travaux pratique de Méthodologie et Langage de Programmation, UMONS/Polytech, TP1 1
1.Programmation en Java : notions de base, orienté objet et héritage
Cette séance de TP a pour objectif d'introduire à la programmation en Java et de présenter les
notions suivantes : compilation avec Java, notion de package, types et structures de données, utilisation
des objets en Java et héritage.
1.1.Notions
a) Les objets
La programmation en Java se base sur la notion d'objet. Par exemple, une application gérant un
terminal pourrait être décrite par une classe et déclarée de la manière suivante :
public class Terminal
{
public static void main( String args[] )
{
}
}
Retenons déjà que la définition d'une classe publique doit impérativement être enregistrée dans
un fichier du même nom que la classe suivi de l'extension .java (ici, Terminal.java ; attention au
respect de la casse : terminal.java n'est pas valable!).
Comme en C/C++, on retrouve la méthode main qui sera appelée en premier lieu lors de
l'exécution du code ; ici, cette méthode ne renvoie rien, ce qui est spécifié par le mot-clé void.
Les variables et méthodes peuvent être de type public (toutes les classes y ont accès) ou
private (seule la classe propriétaire y a accès).
Le mot-clé static peut être utilisé pour déclarer des variables de classe (qui seront alors
partagées par toutes les instances de la classe) ou des méthodes de classe. De telles méthodes spécifient
que l'action réalisée n'est pas liée à une instance particulière de cette classe.
b)Les packages
En Java, l'objectif de réutilisabilité du code conduit à une organisation des classes en packages.
Chaque package regroupe de manière cohérente un certain nombre de classes. En vue de réutiliser une
classe prédéfinie, on peut importer des packages en début de code. Par défaut, un package de base
(java.lang) est importé lors de chaque compilation même si le programmeur ne le spécifie pas. Les
classes sont regroupées en deux ensembles : les packages de noyau (commençant par java.*) et les
packages d'extensions (commençant par javax.*).
Par exemple, pour importer les sous-packages du package swing, nous ajouterons en début de
code la ligne suivante :
import javax.swing.*;
Remarque: le compilateur n'importe que les packages utiles à l'exécution du code et non pas
l'intégralité des packages mentionnés.
La grande quantité d'objets et de méthodes déjà définis dans l'API Java oblige le programmeur a
faire usage de la documentation. Cette documentation peut être consultée sur Internet à l'adresse :
http://java.sun.com/javase/6/docs/api/.
Pour ces séances de TP, nous utiliserons l'IDE Open Source et gratuit Netbeans disponible au
téléchargement à l'adresse http://www.netbeans.org.
UMONS/Polytech
Pierre Manneback, Sébastien Frémal 2014-2015

Travaux pratique de Méthodologie et Langage de Programmation, UMONS/Polytech, TP1 2
c) Constructeurs
Lors de la création d'un objet, une méthode particulière nommée « constructeur » est appelée. Ce
constructeur doit porter le même nom que l'objet et ne renvoyer aucun type de donnée. Cette méthode
permet d'initialiser l'objet et de réaliser un certain nombre d'opérations qui lui sont nécessaires. Par
exemple pour la classe Terminal:
public class Terminal
{public Terminal()
{// CONSTRUCTEUR
}
}
d)L'interaction avec l'utilisateur
Le package java.lang comprend une classe nommée System permettant, entre autre chose, la
sortie d'informations vers la console. Cette classe peut s'utiliser de la manière suivante :
System.out.println("Impression d'une ligne dans la console");
La possibilité d'utiliser des boîtes de dialogue en vue d'interagir avec l'utilisateur est fournie par
la classe JOptionPane du package javax.swing. Par exemple, voici deux cas d'utilisation de cette
classe :
String nom = JOptionPane.showInputDialog("Veuillez entrer votre nom");
JOptionPane.showMessageDialog(null,"Bonjour "+nom);
Pour plus d'informations concernant cette classe, consultez la documentation en ligne.
Lorsque le programme demande l'affichage d'un objet (par exemple, dans une boîte de dialogue
ou dans le terminal), la machine virtuelle fait automatiquement appel à la fonction toString() de
l'objet. Cette méthode ne prend aucun paramètre et retourne un String indiquant comment l'objet doit
être représenté sous forme de texte.
e) Héritage
La notion d'héritage permet la création de nouvelles classes à partir d'anciennes (qui seront alors
appelées superclasses), en vue d'y ajouter de nouvelles fonctionnalités ou de redéfinir des
fonctionnalités existantes. Un héritage peut être spécifié par le mot-clé extends de la manière suivante :
public class SousClasse extends SuperClasse
Remarque : Java n'autorise pas l'héritage multiple, contrairement à C++. L'utilisation des
interfaces (qui seront vues ultérieurement) permet de ne pas être limité par cette contrainte.
Les membres privés de la superclasse ne sont pas accessibles par les sous-classes. Dès lors, en
plus de private et de public, on retrouvera un nouveau mot-clé (protected) qui permettra d'indiquer
qu'un membre est effectivement accessible par les sous-classes de celle à laquelle il appartient.
Lorsqu'une méthode est redéfinie dans une sous-classe, il est malgré tout possible de faire appel à la
méthode originale de la superclasse à l'aide du mot-clé super. Par exemple, super.toString()
permettra de faire appel à la méthode toString de la superclasse.
UMONS/Polytech
Pierre Manneback, Sébastien Frémal 2014-2015

Travaux pratique de Méthodologie et Langage de Programmation, UMONS/Polytech, TP1 3
1.2.Exercices
a) Exercice 1
Définir une classe Personne à partir de laquelle nous pourrons instancier des objets regroupant
les informations suivantes :
●le nom ;
●l'âge.
Le constructeur par défaut ainsi qu'un constructeur permettant l'initialisation des 2 attributs
seront définis. De plus, il serait utile de prévoir des méthodes pour accéder et modifier la valeur des
attributs de Personne. La classe servira à la création de 3 personnes (par exemple p1, p2 et p3) pour
lesquelles les attributs sont mentionnés directement dans le code ; ceux-ci seront ensuite affichés dans la
console.
Conseils :
●séparer le code en deux parties : d'une part la définition de la classe Personne et d'autre
part le test de cette classe (par exemple dans une classe publique TestPersonne) ;
●redéfinir la fonction toString() (existante dans toute classe) et permettant de renvoyer
l'information utile d'un objet de type Personne (c'est-à-dire le nom et l'âge).
b)Exercice 2
Modifier l'exercice 1 pour que l'entrée des données se fasse à l'exécution en utilisant des boîtes
de dialogue. De même, l'affichage des attributs ne se fera plus dans la console mais plutôt dans des boîtes
de dialogue. Cette nouvelle manière d'entrer et d'afficher les attributs de l'objet se fera au sein de deux
nouvelles méthodes. De plus, les personnes créées seront regroupées dans un tableau de taille définie
(voir annexes) ce qui permet d'afficher ces personnes à l'aide d'une boucle.
Remarque : pour convertir un String en entier, utiliser la fonction Integer.parseInt :
int entier = Integer.parseInt(entierStr);
c) Exercice 3
Une variable de classe ainsi qu'une méthode de classe seront ajoutées à l'exercice 2 au sein de la
classe Personne :
●une variable mémorisant le nombre de personnes créées ;
●une méthode calculant l'âge moyen des personnes créées.
d)Exercice 4
À partir de l'exercice 3, établir une sous-classe nommée Etudiant qui permettra de gérer en
plus du nom et de l'âge, deux entrées spécifiant l'année et la spécialité de l'étudiant. Deux constructeurs
seront adjoints à cette nouvelle classe : l'un ne prenant aucun paramètre et l'autre prenant le nom, l'âge,
l'année et la spécialité comme paramètres. Une redéfinition de la méthode toString est également
nécessaire et tirera profit de la méthode originale définie dans la classe Personne. Une classe publique de
type TestEtudiant sera ensuite créée en vue de définir un tableau de trois personnes dont deux
étudiants.
UMONS/Polytech
Pierre Manneback, Sébastien Frémal 2014-2015

Travaux pratique de Méthodologie et Langage de Programmation, UMONS/Polytech, TP1 4
e) Exercice 5
Dans cet exercice, différentes classes doivent être définies en vue de gérer un ensemble de
formes géométriques. Cette gestion ne se fera pas de manière graphique mais devra uniquement traiter les
données "brutes" des formes géométriques suivantes :
●polygone convexe :
○défini par un tableau de points ;
●rectangle (héritant du polygone convexe) :
○défini par les deux sommets d'une des deux diagonales ;
○dont les côtés sont parallèles aux axes de référence ;
●carré (héritant du rectangle) :
○défini par un sommet ainsi que la longueur d'un côté ;
○dont les côtés sont parallèles aux axes de référence ;
●ellipse :
○défini par son centre, la longueur du grand axe (b) et celle du petit axe (a) ;
○dont les axes sont parallèles aux axes de référence ;
●cercle (héritant de l'ellipse) :
○défini par son centre et son rayon.
Pour chacune de ces formes, on souhaite pouvoir :
●en afficher un aperçu (sous la forme d'un String renvoyé par la fonction toString())
●en modifier les caractéristiques ;
●en calculer le périmètre et l'aire (voir annexes).
D'autres classes pourront éventuellement être définies en vue d'améliorer la conception de cette
gestion graphique.
A nouveau, une classe de test sera définie en vue de valider le bon fonctionnement des classes
géométriques obtenues.
Les informations suivantes sont des rappels pour le calcul du périmètre et de l'aire :
Ellipse
Périmètre de l'ellipse (a = demi grand axe ; b = demi petit axe)
2
1
2a2b2
Aire de l'ellipse (a = demi grand axe ; b = demi petit axe)
∗a∗b
Triangle
Aire du triangle (dont les 3 sommets sont (x1,y1), (x2,y2) et
(x3,y3) )
∣0.5 x1−x3 y2−y3− y1−y3 x2−x3∣
UMONS/Polytech
Pierre Manneback, Sébastien Frémal 2014-2015

Travaux pratique de Méthodologie et Langage de Programmation, UMONS/Polytech, TP1 5
1.3.Annexes
Ces annexes reprennent un certain nombre de notions de programmation générale et sont donc
généralement équivalentes à ce qui a déjà été vu en C/C++.
a) Structures de contrôles
Deux instructions supplémentaires peuvent, dans
le corps d'une boucle, "dévier" l'exécution normale :
●break : permet de rompre la boucle et passer à la suite du code ;
●continue : permet de passer immédiatement à l'itération suivante.
b)Types de données
On retrouve les types de données suivants (la taille en nombre de bits en mentionnée entre
parenthèses) :
boolean(8), char(16), byte(8), short(16),
int(32), long(64), float(32), double(64)
En Java, l'utilisation des tableaux doit être précédée d'une déclaration à l'aide du mot clé new.
Cela est valable pour tous les objets de Java. A titre d'exemple, un tableau de 10 entiers est déclaré
comme suit :
int tab[] = new int[10];
Les tableaux sont initialisés à 0 et les "cases" sont numérotées de 0 à n-1 comme en C/C++.
Les chaînes de caractères sont gérées par la classe String. Des opérations standards (telles que
compareTo, length, ...) sont déjà programmées dans la classe. Reportez-vous à la documentation pour
plus d'information.
UMONS/Polytech
Pierre Manneback, Sébastien Frémal 2014-2015
if (condition) {
instructions1;
}
else {
instructions2;
}
while(condition) {
instructions;
}
do {
instructions;
}
while(condition);
switch(variable) {
case 1:
instruction1;
break;
case 2:
...
}
for(initialisation;condition;incrément) {
instructions;
}