Programmation orientée objet

Licence 2 d'informatique --- Feuille n° 1

Premiers pas
On rappelle qu'il est préférable en Java que chaque classe soit définie dans un
fichier qui lui est propre. Le nom du fichier doit être le nom de la classe qu'il
contient, auquel on ajoute le suffixe .java. Les noms de classes doivent être
constitués de mots acollés avec la première lettre en majuscule.

Exercice n° 1 (Hello Groland!)

Écrire un programme Java qui affiche Hello Groland!. Compiler et exécuter ce

programme

Exercice n° 2

En Java, les chaînes de caractères sont représentées par des objets de la

classe String, dont les instances sont non mutables. On souhaite pouvoir convertir
des chaînes de caractères contenant des nombres en valeur entières. Le faire en
utilisant la méthode statique static int parseInt(String) de la classe Integer.
Définir une chaîne de caractères contenant un entier et obtenir sa valeur sous forme
d'entier (int). Faire attention au fait que la méthode parseInt peut lever
l'exception NumberFormatException. Déclarer une chaîne de caractères contenant un
nombre réel et obtenir sa valeur sous la forme d'un flottant (double).

Exercice n° 3 (Tableaux)

• Déclarer deux tableaux t1 et t2 d'entiers.

• Créer pour t1 et t2 des tableaux de 5 entiers.
• Initialiser t2 avec les valeurs 1, 567, -23, 78 et 4.
• Comment faire la déclaration, la création et l'initialisation d'un
tableau t3 en une seule instruction ?
• Écrire une méthode statique pour trouver le plus petit élément d'un
tableau.
• Écrire une méthode statique pour trier les éléments d'un tableau.

Exercice n° 4

Écrire une programme prenant sur la ligne de commande une expression

mathématique en notation préfixée, de la forme opérateur nombre nombre et qui
l'évalue.
Exercice n° 5

Écrire une programme qui prend une liste d'entiers sur la ligne de commande, les
recopie dans un tableau d'entiers, trie le tableau puis finalement affiche le contenu
du tableau.

Exercice n° 6 (Références et égalités)

• Créer un tableau t de 4 références sur des chaînes de caractères. Créer une

chaîne de caractères dont le contenu est "Bon". Affecter les 2 premiers
éléments du tableau avec cette chaîne et le troisième avec la
chaîne "Bonjour". Créer une nouvelle chaîne de caractères dont le contenu
est à nouveau "Bon" et affecter cette chaîne au dernier élément du
tableau t. Comparer 2 à 2 les éléments du tableaux en utilisant les
méthodes String.equals(), String.compareTo(), et l'opérateur ==. Que
constate-t-on ?
• Concaténer t[0] avec la chaîne "jour" en utilisant la
méthode String.concat() ou l'opérateur +. Comparer 2 à 2 les éléments du
tableaux en utilisant les méthodes String.equals(), String.compareTo(), et
l'opérateur ==. Que constate-t-on ?

Exercice n° 7

• Écrire une classe Point représentant un point dans le plan et possédant un

constructeur Point(int, int), une méthode réalisant une translation, et
une méthode de comparaison de signature boolean sameAs(Point).
• Créer un point et le désigner par deux références p1 et p2.
Comparer p1 et p2 avec l'opérateur == et avec la méthode sameAs. Effectuer
une translation de p1 et refaire les comparaisons. Que constate-t-on ?
• Soit le code suivant
• p1 = new Point(1,1);
• p2 = new Point(1,1);

Comparer à nouveau p1 et p2. Que constate-t-on ? Exécuter l'affectation p1

= p2. Que devient l'objet qui était référencé par p2.

Exercice n° 8

Déclarer un tableau t1 contenant les valeurs 2, 7, 5, 21 et -7. Recopier t1 dans un

tableau t2. Comparer les tableaux t1 et t2 en utilisant l'opérateur == et la
méthode equals.
 Programmation orientée objet
Licence 2 d'informatique --- Feuille n° 2

Classes et objets
On considère des rectangles dans le plan. Dans un premier temps, on suppose pour
simplifier que les côtés des rectangles sont parallèles aux axes. Un rectangle est
donc complètement déterminé par le point en bas et à gauche et par ses dimensions
horizontale et verticale.

Exercice n° 1 (Rectangle)

Définir une classe Rectangle permettant de manipuler de tels objets. Définir trois
constructeurs prenant respectivement en paramètre 2 points, 1 points et 2 longueurs
ou 4 longueurs.

Exercice n° 2

Écrire une méthode surface qui calcule la surface du rectangle. Écrire une
méthode translate qui déplace un rectangle en déplaçant le point en bas et à
gauche. Que se passe-t-il si plusieurs rectangles partagent le même point.

Exercice n° 3

Écrire une méthode contains qui teste si un point donné (en paramètre) est à
l'intérieur du rectangle. Écrire une autre méthode contains qui teste si un rectangle
donné est à l'intérieur du rectangle.

Exercice n° 4

Écrire une méthode sameAs qui teste l'égalité de deux rectangles.

Exercice n° 5

Ajouter à la classe Rectangle un attribut nbr qui comptabilise le nombre d'objets de

la classe Rectangle.

Exercice n° 6

Écrire une méthode hull qui calcule le rectangle englobant d'un ensemble de
rectangles. Cette méthode prend en paramètre un tableau de rectangles et retourne
le plus petit rectangle qui contient tous les rectangles du tableau.
On considère qu'un dessin est constitué d'un ensemble de rectangles.

Exercice n° 7 (Dessins)

Définir une classe Dessin. Chaque objet de cette classe contient un tableau de
rectangles dont la taille est fixée à la construction de l'objet. Au départ, un dessin ne
contient aucun rectangle. Écrire une méthode add qui permet d'ajouter un rectangle
à un dessin.

Exercice n° 8

Écrire des méthodes surface et translate pour la classe Dessin. La surface d'un
dessin est la somme des surfaces de ses rectangles même si ceux-ci se superposent.
Translater un dessin consiste à translater chacun de ses rectangle.

Exercice n° 9

Ajouter à la classe Dessin une méthode hull qui calcule le rectangle englobant des
rectangles du dessin. Afin de pouvoir calculer de manière incrémentale ce rectangle
englobant, ajouter un attribut hullRect à la classe Dessin et modifier les méthodes
pour qu'elles prennent en compte cet attribut.

Programmation orientée objet

Licence 2 d'informatique ---

Héritage, masquage de méthode et liaison

tardive
On considère des rectangles donc les côtés ne sont plus nécessairement parallèles
aux axes. Un tel rectangle est vu comme un rectangle aux côtés parallèles qui aurait
été incliné d'un certain angle par rapport à l'horizontale.

Exercice n° 1

En utilisant l'héritage, définir une classe SlantedRectangle permettant de manipuler

de tels objets. Définir des constructeurs appropriés.

Exercice n° 2
Définir une méthode rotate dans l'esprit de la méthode translate.

Exercice n° 3

De quelles méthodes hérite la classe SlantedRectangle ? Redéfinir celles qui le

nécessitent.

Exercice n° 4

Pour chacun des appels de méthode ci-dessous, dire s'il va être compilé
correctement et auquel cas, quelle méthode est appelée effectivement à l'exécution
?
Point p = new Point(1,2);
Rectangle r = new Rectangle(p, 2, 3);
Rectangle t = new SlantedRectangle(p, 2, 3);
SlantedRectangle s = new SlantedRectangle(p, 2, 3);

System.out.println(r.surface());
r.rotate(2);
System.out.println(r.contains(p));

System.out.println(t.surface());
t.rotate(2);
System.out.println(t.contains(p));

System.out.println(s.surface());
s.rotate(2);
System.out.println(s.contains(p));

Exercice n° 5

Est-ce que la classe Dessin définie précédemment peut contenir des rectangle
inclinés ? Est-ce que les méthodes surface, contains et hull de la
classe Dessin fonctionnent encore correctement ?

Exercice n° 6

Définir une méthode String toString() dans la classe Rectangle ? Est-ce en fait
une définition ou une redéfinition ? Est-il nécessaire de la redéfinir dans la
classe SlantedRectangle ?

Exercice n° 7

Redéfinir la méthode equals dans les classes Rectangle et SlantedRectangle.

On considère les définitions de classes suivantes

class A {
void f(A o) {
System.out.println("void f(A o) dans A");
 }
}
class B extends A {
void f(A o) {
System.out.println("void f(A o) dans B");
}
}

Exercice n° 8

Qu'affiche le fragment de programme suivant ?

A a = new A();
A ab = new B();
B b = new B();

a.f(a);
a.f(ab);
a.f(b);
ab.f(a);
ab.f(ab);
ab.f(b);
b.f(a);
b.f(ab);
b.f(b);

Exercice n° 9

On ajoute maintenant à la classe B la méthode suivante

void f(B o) {
System.out.println("void f(B o) dans B");
}
Est-ce une redéfinition ou une surcharge ? Qu'affiche alors le fragment de
programme de l'exercice 8 ?

Exercice n° 10

On ajoute finalement à la classe A la méthode suivante

void f(B o) {
System.out.println("void f(B o) dans A");
}
Est-ce une redéfinition ou une surcharge ? Qu'affiche alors le fragment de
programme de l'exercice 8 ?

Exercice n° 11

Qu'affiche le fragment de programme suivant ?

System.out.println(a instanceof A);
System.out.println(ab instanceof A);
System.out.println(b instanceof A);
 System.out.println(a instanceof B);
System.out.println(ab instanceof B);
System.out.println(b instanceof B);

Exercice n° 12

Dans la classe Rectangle a été définie une méthode boolean contains(Rectangle).

Cette méthode doit-elle être redéfinie dans la classe SlantedRectangle ? Quels cas
ne sont pas couverts par cette redéfinition ? On ajoute alors une méthode boolean
contains(SlantedRectangle) dans les classes Rectangle et SlantedRectangle. Quels
cas ne sont toujours pas couverts par ces ajouts ?

Exercice n° 13

On considère les définitions de classes suivantes

class C {
char ch = 'C';
char getCh() { return ch; }
}
class D extends C {
char ch = 'D';
char getCh() { return ch; }
}
Qu'affiche le fragment de programme suivant ?
C c = new C();
C cd = new D();
D d = new D();

System.out.println(c.ch);
System.out.println(c.getCh());
System.out.println(cd.ch);
System.out.println(cd.getCh());
System.out.println(d.ch);
System.out.println(d.getCh());
 Programmation orientée objet
Licence 2 d'informatique --- Feuille n° 4

Interfaces et classes abstraites

En plus des points et des rectangles vus au séances précédentes, on s'intéresse
maintenant aux disques. On considère qu'un disque est déterminé par son centre et
son rayon.

Exercice n° 1

Définir une classe Disque avec des constructeurs appropriés ainsi que des
méthodes translate, surface et contains.

Aux séances précédentes avait été définie une classe Dessin qui permettait de
regrouper des rectangles.

Exercice n° 2

Quelle est la bonne méthode pour avoir des dessins capables de regrouper à la fois
des rectangles et des disques. On pourra utiliser une interface Figure.

Exercice n° 3

La classe Dessin possède des méthodes translate, surface et contains. Peut-elle

implémenter l'interface Figure ? Quel est l'intérêt de faire cela ?

2 Expressions arithmétiques
On considère maintenant des expressions arithmétiques formées à partir de
constantes réelles (nombres flottants) et utilisant les quatre opérations arithmétiques
usuelles (addition, soustraction, multiplication et division). Un telle expression est
par exemple 3 + (4.7 + 2.3) * 5 .

Ces expressions arithmétiques sont représentés par des arbres binaires. Les nœuds
internes de l'arbre contiennent les opérateurs alors que Les feuilles de l'arbre
contiennent les constantes. Les fils gauche et droit d'un nœud interne représentent
les deux sous-expressions gauche et droite. L'expression 3 + (4.7 + 2.3) * 5 par
l'arbre de la figure ci-dessous.
 FIG 1. L'arbre de l'expression 3 + (4.7 + 2.3) * 5

L'organisation en interfaces et classes

Exercice n° 4

Définir une interface ArithExpr qui déclare les fonctionnalités d'une expression
arithmétique. La seule fonctionnalité requise est de pouvoir être évaluée. Déclarer
en conséquence une méthode eval du bon type.

Pour représenter l'expression, on va créer des objets pour chacun des nœuds. Ces
objets vont bien sûr être des instances de classes différentes suivant qu'il s'agisse de
nœuds internes ou de feuilles.

Exercice n° 5

Définir une classe Constant pour représenter les constantes des expressions.

Exercice n° 6

Définir quatre classes Addition, Soustraction, Multiplication et Division pour les

opérations arithmétique. On remarque que ces quatre classes partagent beaucoup de
propriétés. Comment faut-il faire pour partager le code ?

Exercice n° 7

Redéfinir la méthode toString afin d'afficher les expressions en notation infixe.

Écrire des méthodes prefix et suffix permettant d'afficher les expressions en
notation préfixe et suffixe.

Exercice n° 8

Que faut-il ajouter pour que les expressions arithmétiques puissent contenir des
variables comme dans l'expression 3 * x + 7 ? Comment définir la
méthode eval pour une variable ?
Parseurs

La lecture d'une expression arithmétique se fait par l'intermédiaire d'un parseur. Un

parseur est un objet capable de créer une expression arithmétique à partir d'une
chaîne de caractères.

Exercice n° 9

Définir une classe abstraite ArithExprParser ayant deux méthodes parse. La

première méthode prend en paramètre une chaîne de caractères alors que la seconde
prend un Reader.

Exercice n° 10

Écrire une classe PrefixParser permettant de lire une expression arithmétique en

notation préfixe.

Exercice n° 11 (difficile)

Écrire une classe InfixParser permettant de lire une expression arithmétique en

notation infixe.
 Programmation orientée objet
Licence 2 d'informatique --- Feuille n° 5

Exceptions
Exercice n° 1

Écrire une fonction qui recherche un objet dans un tableau. Si l'objet est trouvé, la
fonction retourne la première position où se trouve l'objet. Sinon la fonction lève
une exception NoSuchElementException.

Exercice n° 2

Écrire une fonction qui recherche un objet dans une liste. Si l'objet est trouvé, la
fonction retourne la première cellule où se trouve l'objet. Sinon la fonction lève une
exception NoSuchElementException. On pourra utiliser une exception lorsque l'objet
est trouvé.

Exercice n° 3

Écrire une fonction qui prend un tableau de chaînes en paramètre et qui retourne la
valeur entière de la première chaîne qui peut-être lue comme un entier par la
méthode parseInt. Si aucune chaîne ne peut être lue comme un entier, la fonction
lève une exception NumberFormatException.

Exercice n° 4

Quel est l'affichage du bout de code ci-dessous ?

class Essai1Exception extends Exception {
Essai1Exception(String s) { super(s); }
}
class Essai2Exception extends Exception {
Essai2Exception(String s) { super(s); }
}
class Essai3Exception extends Essai1Exception {
Essai3Exception(String s) { super(s); }
}
class Sample {
static void throwEssais(int i) throws Exception {
try {
switch (i) {
case 1: throw new Essai1Exception("Essai1Exception de throwEssais");
case 2: throw new Essai2Exception("Essai2Exception de throwEssais");
case 3: throw new Essai3Exception("Essai3Exception de throwEssais");
default: throw new Exception("Exception de throwEssais");
}
}
finally {
System.out.println("Finally de throwEssais");
 }
}
public static void main(String [] args)
{
for (int i = 1; i < 4; i++) {
try { throwEssais(i); }
catch (Essai3Exception e) { System.out.println("Catch Essais3"); }
catch (Essai1Exception e) { System.out.println("Catch Essais1"); }
catch (Exception e) { System.out.println("Catch Exception"); }
finally { System.out.println("Finally de main"); }
}
}
}
 Programmation orientée objet
Licence 2 d'informatique --- Feuille n° 6

Flots
Exercice n° 1

Écrire un programme Java qui effectue la copie d'un fichier. Ce programme prend
sur la ligne de commande le nom du fichier source et le nom du fichier destination.

Exercice n° 2

Écrire un programme Java qui affiche le contenu d'un fichier en mettant en

majuscule tous les caractères qui peuvent l'être.

Exercice n° 3

Écrire un programme Java qui écrit dans un fichier un tableau et une liste puis relit
ces objets.

Exercice n° 4

Écrire un programme qui supprime dans un fichier les blancs en fin de ligne.

Exercice n° 5

Écrire des classes BitInputStream et BitOutputStream permettant de faire des

entrées/sorties bit à bit.
 Programmation orientée objet
Licence 2 d'informatique --- Feuille n° 7

Collections

FIG 1 - La hiérarchie des collections

FIG 2 - La hiérarchie des maps

Exercice n° 1

Écrire un programme Java qui indexe les lignes d'un fichier. Pour chaque ligne
différente, le programme mémorise le nombre d'occurrences de cette ligne dans le
fichier.

Exercice n° 2

Reprendre l'exercice précédent en indexant les mots au lieu d'indexer les lignes.

Exercice n° 3

Écrire un programme Java qui trie les lignes d'un fichier par ordre lexicographique.
Exercice n° 4

Reprendre l'exercice précédent en utilisant l'ordre inverse.

Exercice n° 5

Implémenter l'interface List des collections Java sur les listes programmées à une
séance précédente. On implémentera en particulier l'itérateur à l'aide d'une classe
interne.