\documentclass[twoside,a4paper,10pt]{report}
\usepackage[french]{babel} %% Use your own babel language
\usepackage[top=3cm,bottom=3cm,left=2.5cm,right=2.5cm]{geometry}
\usepackage[utf8]{inputenc}
\usepackage{pslatex}
\usepackage{hyperref}
\usepackage{graphicx}
\usepackage{tabularx}
\usepackage{supertabular}
\usepackage{pdflscape} %% Used for very big table
\usepackage{moreverb}
\usepackage{color}
\usepackage{listings}
\usepackage{lastpage}
\usepackage{fancyhdr}
\usepackage{ulem}
\usepackage{textcomp}
\usepackage{wasysym}
\usepackage{wrapfig} %%Usefull for image 
%%\usepackage{fguill} %%Use this package for guillemot[left|right] useless with babel set to french
\usepackage{eso-pic} %% Background
\pagestyle{fancy}%
\renewcommand{\headrulewidth}{0.1pt}
\renewcommand{\footrulewidth}{0pt}
\renewcommand{\chaptermark}[1]{%
	\markboth{\chaptername\ \thechapter.\ #1}{}}

\renewcommand{\sectionmark}[1]{%
	\markright{#1}{}}

\fancypagestyle{plain}{%
\fancyhf{}
\fancyfoot[R]{\thepage/\pageref{LastPage}}
\renewcommand{\headrulewidth}{0pt}
\renewcommand{\footrulewidth}{0pt}}
\fancyhf{}
\fancyhead[L]{\rightmark}
\fancyhead[R]{\leftmark}
\fancyfoot[R]{\thepage/\pageref{LastPage}}
\renewcommand{\headrulewidth}{0.1pt}
\renewcommand{\footrulewidth}{0pt}

\definecolor{codegray}{gray}{.95}
\lstset{language=C,
	numbers=left,
	tabsize=2,
	basicstyle=\scriptsize,
	stringstyle=\textrm,
	showstringspaces=false,
	frame=none,
	xleftmargin=3pt,
	backgroundcolor=\color{codegray}}

\newcommand{\settexitref}[2]{(\ref{#1}p\pageref{#1})}
\newcommand{\dokutitlelevelone}[1]{\chapter{#1}}
\newcommand{\dokutitleleveltwo}[1]{\section{#1}}
\newcommand{\dokutitleleveltree}[1]{\subsection{#1}}
\newcommand{\dokutitlelevelfour}[1]{\subsubsection{#1}}
\newcommand{\dokutitlelevelfive}[1]{\paragraph{#1}}
\newcommand{\dokufootnote}[1]{\footnote{#1}}
\newcommand{\dokufootmark}[1]{\footnotemark[#1]}
\newcommand{\dokubold}[1]{\textbf{#1}}
\newcommand{\dokuitalic}[1]{\textsl{#1}}
\newcommand{\dokumonospace}[1]{\texttt{#1}}
\newcommand{\dokuunderline}[1]{\underline{#1}}
\newcommand{\dokuoverline}[1]{\sout{#1}}
\newcommand{\dokusupscript}[1]{\textsuperscript{#1}}
\newcommand{\dokusubscript}[1]{$_{#1}$}
\newcommand{\dokuhline}{\line(1,0){400}}
\newcommand{\dokulabel}[1]{\label{#1}}
\newcommand{\dokuitem}{\item}
\newcommand{\dokuquoting}{\textbar}
\newcommand{\dokutabularwidth}{\textwidth}
\newcommand{\dokusupertabularheadbreak}{\small\sl continued from previous page}
\newcommand{\dokusupertabulartailbreak}{\small\sl continued on next page}
\newcommand{\dokuheadingstyle}[1]{\textbf{#1}}
\definecolor{dokuheadingcolor}{rgb}{0,0,0.60}
\newcommand{\dokubackground}[1]{%
\AddToShipoutPicture{%
  \AtTextCenter{%
    \makebox(0,0)[c]{\resizebox{\textwidth}{!}{%
      \rotatebox{25}{\textsf{\textbf{\textcolor[gray]{0.90}{#1}}}}}}%
  }%
 }%
}

\hypersetup{
pdftitle = {INF2 JAVA -- Travaux Pratiques},
pdfauthor = {E. Bruno},
pdfcreator = {DokuTeXit},
pdfproducer = {dokuwiki + TeXit + latex + dvipdf}
}
\title{INF2 JAVA -- Travaux Pratiques}
\author{E. Bruno}
\begin{document}
\thispagestyle{empty}
\maketitle
\thispagestyle{empty}
\cleardoublepage
\tableofcontents
\newpage
\thispagestyle{plain}
\cleardoublepage
\newpage



\dokutitlelevelone{TP}
\label{3817848ef191468810fc4b1cfc855ba1}%% tp
\label{3817848ef191468810fc4b1cfc855ba1}%%Start: tp => /home/bruno/public_html/data/pages/tp.txt
La correction des TP se trouve sur le svn suivant : \href{https://lsis.univ-tln.fr/svn/bruno/enseignement/INF2TP/trunk/INF2TP/}{https://lsis.univ-tln.fr/svn/bruno/enseignement/INF2TP/trunk/INF2TP/}

La première fois que vous voulez récupérer la correction utiliser la commande suivante (\dokubold{ ATTENTION cela va créer un répertoire INF2TP dans votre répertoire courant }).


\small
\begin{verbatimtab}
svn checkout https://lsis.univ-tln.fr/svn/bruno/enseignement/INF2TP/trunk/INF2TP/
\end{verbatimtab}
\normalsize
Pour vérifier si les corrections ont été mises à jour et mettre à jour votre copie locale lancer la commande suivante dans le répertoire \dokumonospace{INF2TP}:


\small
\begin{verbatimtab}
svn update

\end{verbatimtab}
\normalsize
Un exemple d'application se trouve sur le svn suivant :


\small
\begin{verbatimtab}
  http://lsis.univ-tln.fr/svn/bruno/enseignement/MonEntreprise/branches/experimental/
\end{verbatimtab}
\normalsize
faire un \dokumonospace{svn checkout} puis éventuellement des \dokumonospace{svn update}


\dokutitleleveltwo{TP1 - Premiers pas en Java}
\label{13d6d501473b756b79e18c21da9270c8}%% tp1_-_premiers_pas_en_java

\dokutitleleveltree{Objectif}
\label{ba81ee9ceeb9c96227f3607460f09179}%% objectif
Les objectifs de ce premier TP sont la mise en place de l’environnement de
travail en java et l’étude des fondements du langage. C’est-à-dire d’une part la
compréhension de la compilation et de l’exécution de code java, l’arborescence
classique d’une application et la génération de la documentation et d’autre part
la maîtrise de la création de classes et d’objets.


\dokutitleleveltree{Une première exécution}
\label{b97da50baa65ba86fe1ff292c2294c58}%% une_premiere_execution

\dokutitlelevelfour{Mettre en place l’environnement}
La première chose à faire est de fixer quelle distribution du jdk va être utilisée,
pour cela fixer la valeur de la variable d’environnement \dokumonospace{JAVA{\textunderscore}HOME} pour
indiquer son emplacement (\dokumonospace{/usr/lib/jvm/java-6-sun}). Ensuite, on ajoute le répertoire \dokumonospace{{\textdollar}JAVA HOME/bin} à la valeur de la variable \dokumonospace{PATH} pour que les commandes de bases soient accessibles. Vérifier que cela fonctionne en exécutant les commandes \dokumonospace{java -version} et
\dokumonospace{javac -help} (il doit s'agit de la JVM de Sun).

Il est impératif que toutes les documentations suivantes soient ouvertes dans
votre navigateur web :


\begin{itemize}
\dokuitem  la documentation sur les API\dokufootnote{Application Programming Interface} : \href{http://java.sun.com/javase/6/docs/api/}{http://java.sun.com/javase/6/docs/api/}
\dokuitem  la documentation sur les outils Java fournis par Sun : \href{http://java.sun.com/javase/6/docs/}{http://java.sun.com/javase/6/docs/}
\end{itemize}

\dokutitlelevelfour{Compiler et exécuter une application}
A la racine de votre compte ajouter un répertoire \dokumonospace{INF2} (ce répertoire sera
appelé répertoire de travail). A l’intérieur de votre répertoire de travail ajouter
le répertoire \dokumonospace{TP} (appelé répertoire de projet). A l’intérieur de votre répertoire
de projet ajouter les répertoires standards \dokumonospace{src}, \dokumonospace{build}, \dokumonospace{doc}, \dokumonospace{dist} et \dokumonospace{lib}.

Dans le répertoire \dokumonospace{src}, créer l’arborescence correspondant au paquetage :
\dokumonospace{fr.univtln.login.tp.tp1}. A l’intérieur de ce paquetage ajouter le programme
Java \hyperref[ed8520fc8f1f43293e871eb39170cc10]{PremierProgramme.java}.

Ouvrir et modifier ce programme pour que l’instruction \dokumonospace{package} soit correcte.

A partir de votre répertoire de projet, compiler le programme avec
la commande suivante :


\small
\begin{verbatimtab}
   javac -sourcepath src -d build src/fr/univtln/login/tp/tp1/PremierProgramme.java
\end{verbatimtab}
\normalsize
Regarder dans le répertoire \dokumonospace{build}. Pour exécuter le programme, depuis votre
répertoire de projet :


\small
\begin{verbatimtab}
   java -classpath build fr.univtln.login.tp.tp1.PremierProgramme Pierre
\end{verbatimtab}
\normalsize

\dokutitleleveltree{Générer la documentation}
\label{48a778ee2b0c631bd6262c866a2f1989}%% generer_la_documentation

\dokutitlelevelfour{Précision sur la forme}
La commande javadoc produit de la documentation en partant de commentaires
particuliers insérés dans le code source des classes (/** \ldots{} */). On peut ainsi
documenter les paquetages, classes ou interfaces, variables d’instance, méthodes,\ldots{}

Les commentaires peuvent contenir du texte simple et des balises HTML\dokufootnote{HyperText Markup Language} de
mise en forme de texte ($<$I$>$ italique, $<$B$>$ caractère gras, \ldots{} ). On peut utiliser la
balise $<$code$>$ pour inclure du code dans les commentaires. Des balises spéciaux appelées annotations qui commencent par le caractère @ (@author, @version, @param,. . . ) sont définies pour fixer des valeurs standards. Les commentaires doivent être placées juste avant ce qu’ils commentent. Lire cette page : \href{http://java.sun.com/javase/6/docs/technotes/tools/solaris/javadoc.html}{http://java.sun.com/javase/6/docs/technotes/tools/solaris/javadoc.html}

De plus, il est rappelé que le langage Java est entouré d’un ensemble de
bonnes pratiques. Cette page présente les habitudes dans le cadre du langage
java. Lire cette page : \href{http://www.oracle.com/technetwork/java/javase/documentation/index-137868.html}{http://www.oracle.com/technetwork/java/javase/documentation/index-137868.html}

Ajouter les commentaires pour les packages (cf. \dokumonospace{package-info.java})


\dokutitlelevelfour{Génération}
A partir de maintenant, tous vos programmes seront commentés.
Générer la documentation depuis votre répertoire de projet avec la commande:


\small
\begin{verbatimtab}
   javadoc fr.univtln.tp.tp1 src/fr/univtln/bruno/tp/tp1/PremierProgramme.java -d doc
\end{verbatimtab}
\normalsize

\dokutitleleveltree{Générer et exécuter l’archive jar}
\label{c02260cdb8b1e57c1059fe6b23a9b3ab}%% generer_et_executer_l_archive_jar
Génerer l’archive de votre projet depuis votre répertoire de projet avec la commande :


\small
\begin{verbatimtab}
   cd build; jar cvf ../dist/tp.jar fr; cd ..
\end{verbatimtab}
\normalsize
Exécuter le programme en ajoutant le jar au classpath et en indiquant la classe exécutable avec la commande suivante :


\small
\begin{verbatimtab}
  java -classpath dist/tp.jar fr.univtln.login.tp.tp1.PremierProgramme Pierre
\end{verbatimtab}
\normalsize
Il est possible de rendre le jar "exécutable" en créant un fichier \dokumonospace{manifest}
qui indique en particulier quelle est la classe exécutable.

Copier le fichier \dokumonospace{monManifest} (\hyperref[f5a5742e52db426ff3ee9a53fa855142]{monmanifest.zip}) dans le répertoire de projet et regarder son
contenu. Recréer le fichier \dokumonospace{.jar} en précisant le manifeste à ajouter :


\small
\begin{verbatimtab}
 cd build; jar cvfm ../dist/tp.jar ../monManifest fr; cd ..
\end{verbatimtab}
\normalsize
Puis exécuter directement l’archive :


\small
\begin{verbatimtab}
 java -jar dist/tp.jar Pierre
\end{verbatimtab}
\normalsize

\dokutitleleveltree{Automatiser le processus avec Apache Ant}
\label{88e8220184f8abd9da0dd62f8e30743a}%% automatiser_le_processus_avec_apache_ant
Comme vous l’avez vu, la compilation d’un projet complet en Java est une tâche
fastidieuse. C’est pourquoi, il est conseillé d’utiliser un outil qui automatise ce
travail : Ant (\href{http://ant.apache.org/}{http://ant.apache.org/}). Ant utilise un fichier de configuration
qui indique les tâches à accomplir, vous trouverez un exemple de ce fichier sur
le wiki \hyperref[cda483d3e14be43cf5a7c26fbfacfe7c]{build.xml.zip}.

Copier ce fichier dans votre répertoire de projet et regarder son contenu.
Adapter son contenu pour qu’il indique des chemins corrects.

Créer une variable d’environnement \dokumonospace{ANT{\textunderscore}HOME} qui indique le répertoire d’installation
de ant (\dokumonospace{/usr/share/ant}). Ajouter \dokumonospace{ANT{\textunderscore}HOME/bin} dans le \dokumonospace{PATH}.

Pour obtenir l’ensemble des tâches possibles avec un fichier de construction: 


\small
\begin{verbatimtab}
ant -projecthelp build.xml
\end{verbatimtab}
\normalsize
Pour lancer l’exécution et si nécessaire compiler et générer l’archive :


\small
\begin{verbatimtab}
ant run
\end{verbatimtab}
\normalsize

\dokutitleleveltree{Utilisation de l’environnement Eclipse}
\label{62b8a7455f9d912d6d01ea8a960006af}%% utilisation_de_l_environnement_eclipse
Nous allons maintenant utiliser l’environnement de développement eclipse :
\dokumonospace{\href{http://www.eclipse.org}{http://www.eclipse.org}}. Comme "workspace" vous pouvez choisir votre
espace de travail (c’est là que eclipse stocke ses informations de configuration).

Créer un nouveau projet à partir d’un fichier ant (cf. menu file).
Modifier les propriétés du nouveau projet (clic droit sur le projet). Dans
"Java compiler" indiquer la compatibilité avec Java 5 (ou 6). Dans les propriétés des
chemins vérifier que les répertoires des sources et des binaires sont corrects.

Dans les propriétés du paquetage \dokumonospace{JRE{\textunderscore}LIB} indiquer où se trouve l’archive de
la Javadoc.

Pour lancer une tâche ant, utiliser le menu de droite.
Vous pouvez maintenant  éditer vos programmes Java.


\dokutitleleveltree{Les concepts de base de Java}
\label{6dc2485b1cdab315914f2e006d399886}%% les_concepts_de_base_de_java

\dokutitlelevelfour{Création et instanciation d’une classe}
Créer une classe Java exécutable nommée \dokumonospace{Test} qui appartient au paquetage
'tp1'. La classe 'Test' devra afficher \dokumonospace{"Hello"}.

Créer une classe \dokumonospace{Personne} sans constructeur explicite qui décrit une
personne ayant un nom, un prénom, un âge et un salaire. Créer les accesseurs
correspondants à ces attributs (eclipse peut le faire automatiquement). 
Vous vérifierez qu’un salaire ne peut pas être
négatif. Instancier une personne \dokumonospace{p1} dans le \dokumonospace{main} de la classe \dokumonospace{Test}, mettre à jour ses informations et les afficher (\dokumonospace{Pierre Truc est agé de 30 ans et gagne 2000€}).

Ajouter des constructeurs dans la classe Personne qui initialisent le nom et le
prénom et éventuellement l’âge et la profession. Modifier cette classe pour que
le nom et le prénom ne puissent plus être modifiés après l’instanciation.

Ajouter un attribut qui indique l’année de naissance et les accesseurs associés. Modifier la méthode que retourne l’âge. L’année courante s’obtient avec
\dokumonospace{java.util.Calendar.getInstance().get(Calendar.YEAR)}.

Ajouter une méthode \dokumonospace{comparerSalaire()} qui prend en paramêtre une personne et retourne -1, 0 ou 1 selon que celle à un salaire supérieur, égal ou
inférieur à l’instance courante. Créer une deuxième personne \dokumonospace{p2} née la même
année que \dokumonospace{p1} mais qui gagne plus. Afficher le résultat de la comparaison des
salaires de \dokumonospace{p1} et \dokumonospace{p2}.

Ajouter une méthode \dokumonospace{comparerSalaire()} qui prend en paramètre deux personnes et qui retourne -1, 0 ou 1 selon de le salaire de la première est inférieur, égal ou supérieur à celui de la seconde.

Attention \dokumonospace{comparerSalaire(Personne)} et \dokumonospace{comparerSalaire(Personne,
Personne)} sont-elle des méthode de classe ou d’instance ?

Ajouter un attribut de classe \dokumonospace{totalDesSalaires} qui indique le total des salaires des
personnes et un accesseur. Modifier les méthodes nécessaires pour le salaire
total soit maintenu à jour automatiquement.

Afficher le salaire total après la création de chaque personne.


\dokutitlelevelfour{Les méthodes de base}

\dokutitlelevelfive{toString()}
Afficher directement l’objet \dokumonospace{p1} dans la classe \dokumonospace{Test}. Ajouter une méthode :
\dokumonospace{String toString()} à la classe personne qui retourne une chaîne de caractère
qui décrit la personne. Exécuter \dokumonospace{Test}.


\dokutitlelevelfive{equals()}
On souhaite considérer que deux personnes sont "égales" dans notre application, si elles sont nées la même année. Pour définir une relation d’égalite d’objets en Java on redéfinit la méthode \dokumonospace{Boolean equals(Object)}. Vérifier
que \dokumonospace{p1} et \dokumonospace{p2} sont égales.


\dokutitlelevelfour{Définition de classes locales}
Pour représenter le fait qu’une Personne à un cerveau ajouter une définition de
la Classe \dokumonospace{Cerveau} à l’intérieur de la définition de la classe \dokumonospace{Personne}. Ajouter
un attribut \dokumonospace{cerveau} à \dokumonospace{Personne} et instancier un cerveau à chaque personne lors
de sa création. Compiler et exécuter \dokumonospace{Test}. Regarder dans le répertoire \dokumonospace{build}
les classes qui ont été compilées. Essayer de créer une instance de \dokumonospace{Cerveau}
directement dans la classe \dokumonospace{Test}.


\dokutitleleveltree{Pour finir\ldots{}}
\label{19d1064f37343bcf091522e4f14a4bde}%% pour_finir
Vous allez maintenant créer une classe \dokumonospace{Entreprise} qui permet de représenter
des entreprises qui comportent au maximun  \dokumonospace{MAX{\textunderscore}EMPLOYES} \dokumonospace{Personnes}.

Vous ajouterez les méthodes pour créer une entreprise, ajouter des employés
et afficher le nombre d’employés, un employé précis et tous les employés (en
utilisant le \dokumonospace{foreach} de Java5).

Les entreprises doivent appartenir à l’une des trois catégories suivantes:
\dokumonospace{{PUBLIQUE, PME, GRAND GROUPE}}. Modifier la classe \dokumonospace{Entreprise} pour
représenter cela en utilisant un type \dokumonospace{enum} et ajouter trois méthodes \dokumonospace{isPUBLIQUE()},
\dokumonospace{isPME()}, \dokumonospace{isGRAND{\textunderscore}GROUPE()} qui retournent un booléen.

Ajouter une méthode \dokumonospace{miseEnForme()} qui passe le nom de toute les personnes
d’une entreprise en majuscule.

Modifier votre classe \dokumonospace{Test}, pour l’on puisse lui passer en paramètre le nom
et le type d’une entreprise, puis la liste des personnes qui la compose.


\small
\begin{verbatimtab}
  java Test maBoite PME Pierre Durand 1950 2000 Paul Dupond 1960 3000 Marie Martin 1975 2500
  
\end{verbatimtab}
\normalsize

\dokutitleleveltwo{TP2 -  Héritage, polymorphisme et interfaces en Java}
\label{38fd5686c7a9588a43e1d01f2747f330}%% tp2_-_heritage_polymorphisme_et_interfaces_en_java

\dokutitleleveltree{Objectif}
\label{ba81ee9ceeb9c96227f3607460f09179}%% objectif
L'objectif ce TP est de présenter l'héritage, le polymorphisme et l'utilisation des interfaces en Java. Vous devez écrire la javadoc \href{http://java.sun.com/j2se/javadoc/writingdoccomments/}{http://java.sun.com/j2se/javadoc/writingdoccomments/} au fur et à mesure de l'avancement et il est \dokubold{fortement} conseillé d'avoir le documentation de java sous les yeux : \href{http://java.sun.com/j2se/1.5.0/docs/api/index.html}{http://java.sun.com/j2se/1.5.0/docs/api/index.html}


\dokutitleleveltree{Appel d'une méthode la classe mère}
\label{a8c413cea71c6288c7d30ab2e020f1c2}%% appel_d_une_methode_la_classe_mere
Dans cet exercice nous allons modéliser des \dokumonospace{plantes}, des \dokumonospace{animaux}, des \dokumonospace{mammifères} et des \dokumonospace{oiseaux} mais aussi des \dokumonospace{chiens}, des \dokumonospace{aigles}, des \dokumonospace{lapins} et des \dokumonospace{hommes}. 


\dokutitlelevelfour{Modélisation par héritage et Instanciation}

\begin{itemize}
\dokuitem  Modélisez cette hiérarchie (directement en Java) avec des classes. Ajoutez à chaque classe fille au moins une variable et une méthode nouvelle selon votre imagination (âge, nom, sexe, \ldots{}).
\dokuitem  Ajoutez une classe exécutable \dokumonospace{Test} et créez des instances de chacune des classes. Affichez avec la méthode \dokumonospace{System.out.prinln()} chacun des objets. 
\dokuitem  Redéfinissez la méthode \dokumonospace{toString()} (héritée de \dokumonospace{Object}, voir dans la documentation) de la super classe pour qu'elle affiche "\dokumonospace{Je suis un animal}" (ou "\dokumonospace{Je suis une plante}"). Exécutez la classe \dokumonospace{Test}. Expliquer le résultat en étudiant la classe \dokumonospace{java.lang.System}.
\dokuitem  Modifiez la méthode précédente pour qu'elle affiche "\dokumonospace{Je suis un animal et mon identifiant est X}".
\end{itemize}

\dokutitlelevelfour{Polymorphisme simple}

\begin{itemize}
\dokuitem  Avec quels types de références pouvez-vous manipuler les classes précédentes ?
\dokuitem  Dans la méthode \dokumonospace{main} la classe \dokumonospace{Test}, créez des tableaux qui permettent de voir certains des animaux crées \dokubold{dans la section précédente} comme des collections (de taille fixe) d'animaux ou de mammifères.
\dokuitem  Ajouter à chaque classe une méthode \dokumonospace{String getInfo()} (qui appellera celle de la superclasse) pour que l'affichage du tableau suivant :
\end{itemize}

\lstset{language=java}
\begin{lstlisting}
{new Animal(12), new Animal(), new Chien(5,"Medor"), new Homme(), new Homme(25,"Robert")}

\end{lstlisting}
soit de la forme :


\small
\begin{verbatimtab}

Je suis un animal âgé de 12 an(s).
Je suis un animal.
Je suis un animal âgé de 5 an(s). Je suis un mammifère. Je suis un chien de nom Médor.
Je suis un animal. Je suis un mammifère. Je suis un homme.
Je suis un animal âgé de 25 an(s). Je suis un mammifère. Je suis un homme de nom Robert.

\end{verbatimtab}
\normalsize

\dokutitlelevelfour{Classes abstraites}

\begin{itemize}
\dokuitem  Modifiez les classes pour s'assurer que tous les Animaux possèdent la méthode \dokumonospace{String moyenExpression} qui retourne une phrase du type "\dokumonospace{Je parle}", "\dokumonospace{J'aboie}", ou "\dokumonospace{Je fais des bulles}" (l'aigle trompette, glapit ou glatit ; le lapin clapit).
\dokuitem  Est-ce que le moyen d'expression peut être définit pour toutes les classes ? Peut-on alors créer une instance de la classe Animal, quelle est votre conclusion pour s'assurer de cela ? Faites de même pour toutes les classes pour les lesquelles cela vous semble nécessaire.
\dokuitem  Écrivez une méthode \dokumonospace{afficherAnimaux()} dans la classe \dokumonospace{Animal} qui prend en paramètre un tableau d'animaux et qui affiche leur référence et leur cri. Testez la sur le tableau de la question précédente.
\end{itemize}

\dokutitlelevelfour{Administration de classe et polymorphisme}

\begin{itemize}
\dokuitem  Modifiez vos classes pour que l'on garde automatiquement des références (dans un tableau) vers tous les animaux créés (Vous vérifierez aussi que l'on ne crée pas plus de \dokumonospace{NB{\textunderscore}MAX{\textunderscore}ANIMAUX}).
\dokuitem  Créez une méthode (de classe ou d'instance ?) qui affiche la description complète de tous les animaux crées.
\end{itemize}

\dokutitlelevelfour{Héritage multiple et Interface}

\begin{itemize}
\dokuitem  On souhaite maintenant considérer que certains animaux (pas forcément tous) sont des carnivores (ils comportent la méthode \dokumonospace{void manger} avec comme paramètre un autre animal) ou des herbivores (ils comportent la méthode \dokumonospace{void manger} avec comme paramètre une plante) ou les deux. Créez deux interfaces pour décrire ces comportements
\dokuitem  Modifiez vos classes pour qu'elles implantent ces interfaces :
\begin{itemize}
\dokuitem  Les carnivores : quand ils mangent,  les chiens affichent "\dokumonospace{Je mord X}", et les aigles affichent "\dokumonospace{Je déchire X}".
\dokuitem  Les herbivores : les vaches affichent "\dokumonospace{Je broute X}", et les lapins "\dokumonospace{Je grignotte X}".
\end{itemize}

\dokuitem  Les hommes sont à les fois carnivores et herbivores, proposez deux solutions pour le représenter :
\begin{itemize}
\dokuitem  Dans un premier temps, sans créer de nouvelle interface.
\dokuitem  Dans un second temps en créant une nouvelle interface \dokumonospace{IOmnivore}.
\end{itemize}

\dokuitem  Le polymorphisme est aussi utilisable avec les interfaces :
\begin{itemize}
\dokuitem  Appliquez la méthode \dokumonospace{manger(unePlante} sur la \dokumonospace{Vache} que avez déjà créée en la voyant à travers une référence de type \dokumonospace{IHerbivore}. Peut-on appliquer la méthode \dokumonospace{moyenExpression()} sur cette référence ?
\end{itemize}

\dokuitem  Créez deux tableaux \dokumonospace{lesCarnivores' et }lesHerbivores'' pour manipuler les animaux existants. Créez un lapin, et faites le manger par tous les carnivores, créez une plante et faites la manger par les herbivores.
\end{itemize}

\dokutitleleveltree{Si vous avez déjà fini\ldots{}}
\label{c07df7284d8ef80d45e0450363c656af}%% si_vous_avez_deja_fini

\begin{itemize}
\dokuitem  Vous pouvez construire depuis eclipse le diagramme UML correspondant à ce TP en utilisant topcased.
\end{itemize}

\dokutitleleveltwo{TP3 - Les collections en Java}
\label{464c13010f52e5db08e22009493a5bd0}%% tp3_-_les_collections_en_java

\dokutitleleveltree{Objectif}
\label{ba81ee9ceeb9c96227f3607460f09179}%% objectif
L'objectif ce TP est de présenter d'une part l'utilisation des collections et d'autre part l'utilisation d'un outils d'édition de diagrammes UML permettant la génération de code Java (\href{http://www.topcased.org/}{Topcased}).


\dokutitleleveltree{Utilisation "Simple" des collections}
\label{fdb64fb6786fbfd7dff616c2a207aafa}%% utilisation_simple_des_collections
Vous utiliserez les classes du TP précédent.


\begin{itemize}
\dokuitem  Créez un \dokubold{ ensemble } d'animaux (sans utiliser de génériques) et peuplez le en utilisant concrètement un \dokumonospace{HashSet}.
\dokuitem  On suppose que tous les animaux ont un nom, indiquez que deux animaux sont égaux s'ils ont le même nom.
\dokuitem  Vérifier que l'on ne puisse pas ajouter deux animaux ayant le même nom (par définition d'un ensemble)
\dokuitem  Affichez cet ensemble en utilisant un itérateur puis avec le foreach de Java 5
\dokuitem  Transformez le support physique de cet ensemble en un \dokumonospace{TreeSet}, que faut-il modifier d'autre ?
\dokuitem  Créer une liste d'animaux à partir des animaux de l'ensemble. 
\dokuitem  Afficher la liste des animaux triée par l'ordre alphabétique de leur nom.
\dokuitem  Convertissez cet ensemble en un tableau d'animaux (Faites attention au type)
\dokuitem  Modifier cet ensemble en ajoutant la généricité et définissez un ensemble d'animaux (supprimez les transtypages devenus inutiles).
\dokuitem  On suppose que l'on associe à chaque animal un tatouage unique composé de son espèce (une Chaîne de caractères) et d'un entier. Le couple des deux est unique.  Ecrire la classe tatouage, surcharger et redéfinir les méthodes nécessaires. Créer une \dokumonospace{Map} (avec la généricité) contenant des animaux (\dokuitalic{(Aigle,1), (Aigle,2), (Chien,1), (Chien,2)}) et affichez les informations concernant l'animal dont l'identifiant est \dokuitalic{(Chien,1)}.
\end{itemize}

\dokutitleleveltree{Ecriture manuelle d'un programme à partir d'un diagramme de classe}
\label{89b90a5d612cddc92c60e8333fc9ea70}%% ecriture_manuelle_d_un_programme_a_partir_d_un_diagramme_de_classe
L'objectif est d'écrire un programme de gestion d'une bibliothèque qui prête des livres et des ordinateurs à des enseignants et des étudiants.

\begin{figure*}[h]
\includegraphics{/home/bruno/public_html/lib/plugins/tmp/texitimages/texitxEjPlA.ps}
\caption{fr.univtln.bruno.tp.tp3.Bilbio.eps}
\end{figure*}



\dokutitlelevelfour{Architecture de base}
Ecrire (sans utiliser d'éditeur UML) les classes Java correspondant au diagramme UML donné décrivant une bibliothèque simple. Vous veillerez en particulier à


\begin{itemize}
\dokuitem  redéfinir la méthode \dokumonospace{toString()} des différentes classes pour que celles-ci puissent être affichées
\dokuitem  représenter correctement les associations multiples en utilisant des collections (il est conseillé d'utiliser les génériques).
\dokuitem  créer une classe exécutable \dokumonospace{Test} dans laquelle vous pourrez :
\begin{itemize}
\dokuitem  créer une bibliothèque
\dokuitem  ajouter des adhérents qui doivent avoir un nom, un prénom et un statut
\dokuitem  ajouter au moins deux livres, deux revues, deux dictionnaires et deux BD
\dokuitem  ajouter deux ordinateurs portables (un sous linux, un sous windows)
\end{itemize}

\end{itemize}

\dokutitlelevelfour{Gestion des emprunts}
Ecrire le code permettant de gérer les emprunts en ajoutant aux adhérents les méthodes \dokumonospace{boolean emprunter(Empruntable e)} et \dokumonospace{boolean rendre(Empruntable e)}. Pensez à bien vérifier qu'un objet n'est pas emprunté deux fois (vérifier que cela marche en faisant un test dans la classe \dokumonospace{Test}) et qu'un adhérent n'emprunte pas plus de cinq objets.


\begin{itemize}
\dokuitem  Ajouter une méthode \dokumonospace{void afficherEmprunts()} à la classe \dokumonospace{Adherent}
\dokuitem  Ajouter une méthode \dokumonospace{void afficherFonds()} à la classe \dokumonospace{Bibliothèque} qui affiche les documents et le matériel (chacun affichant par qui il a été emprunté). \dokubold{ Ajoutez les méthodes qui vous semblent utiles pour cela}
\dokuitem  Surcharger les méthodes \dokumonospace{emprunter} et \dokumonospace{rendre} pour les Livres et les Portables, pour vérifier que l'on emprunte au plus cinq livres mais un seul portable.
\end{itemize}

\dokutitlelevelfour{Recherche dans une collection}
Ajouter une méthode \dokumonospace{Collection rechercherTitre(String mot)}, qui retourne une collection contenant des références vers les documents qui comportent la chaîne \dokumonospace{mot} dans leur titre.


\dokutitleleveltree{Ecriture assistée d'un programme à partir d'un diagramme de classe}
\label{175580f7630040e8632f8a98004c6248}%% ecriture_assistee_d_un_programme_a_partir_d_un_diagramme_de_classe
En utilisant un outils d'édition de diagramme UML, construisez le diagramme précédent et générer automatiquement le squelette des classes. 


\dokutitleleveltree{Si vous avez fini\ldots{}}
\label{72f7165a20a5cab1257f0c41bfcc70d4}%% si_vous_avez_fini
Vous pouvez affinez vos connaissances en suivant le tutorial de Sun : \href{http://java.sun.com/docs/books/tutorial/collections/index.html}{http://java.sun.com/docs/books/tutorial/collections/index.html} et la documentation \href{http://download-llnw.oracle.com/javase/6/docs/technotes/guides/collections/overview.html}{http://download-llnw.oracle.com/javase/6/docs/technotes/guides/collections/overview.html}.


\dokutitleleveltwo{TP4 - Entrées/Sorties et IHM}
\label{d84531fbaf194b29fc289117af377439}%% sorties_et_ihm

\dokutitleleveltree{Objectif}
\label{ba81ee9ceeb9c96227f3607460f09179}%% objectif
L'objectif ce TP est de d'illuster l'utilisation simple des entrées/sorties en Java et de
mettre en place des IHM de base.


\dokutitleleveltree{Les entrées/sorties}
\label{6e0e5d0b7f0fa8bc0095369c74b842f9}%% sorties
\href{http://download.oracle.com/javase/tutorial/essential/io/index.html}{http://download.oracle.com/javase/tutorial/essential/io/index.html}

En vous servant tu TP sur les animaux :


\begin{itemize}
\dokuitem  Ajouter une méthode \dokumonospace{void sauverChien(Collection c, String fichier)} et une méthode \dokumonospace{sauverChien(OutputStream os)} à la classe Chien qui sauvegarde l'état interne d'un chien dans un fichier en écrivant les types primitifs directement en binaire dans un fichier.
\dokuitem  Ajouter une méthode \dokumonospace{Collection restaurerChien(String fichier)} à la classe Chien qui crée une collection d’instances de Chien à partir des informations stockées dans un fichier.
\dokuitem  Modifier les méthodes précédentes pour qu'un tampon soit utilisé.
\dokuitem  Modifier les méthodes précédentes pour que le fichier soit compressé.
\dokuitem  Créer les méthodes \dokumonospace{void sauverChien2(Collection c, String fichier)} et
\end{itemize}
\dokumonospace{Collection restaurerChien2(String fichier)} qui font la même chose en utilisant la sérialisation.


\dokutitleleveltree{Les IHM}
\label{bc79619828144b846f02246ab5d0e2df}%% les_ihm
\href{http://download.oracle.com/javase/tutorial/uiswing/}{http://download.oracle.com/javase/tutorial/uiswing/}


\dokutitlelevelfour{Construction}
Mettez en place une IHM simple qui permet d'afficher et de modifier une instance de la classe \dokumonospace{Chien}. Essayer d’utiliser un maximum de composants de Swing (cf. tutoriel). Cette classe sera appelée une vue de Chien.

Compléter l'interface pour qu'elle affiche une "liste de Chiens" représentés par leur nom ou leur tatouage (i.e. leur identifiant). 


\dokutitlelevelfour{Activation}
Compléter votre interface pour qu'elle puisse :


\begin{itemize}
\dokuitem  d'afficher les informations qui viennent d'une instance Chien en utilisant en utilisant un contrôleur de Chien.
\dokuitem  permettre de sélectionner une chien dans le liste et d'afficher des informations (bouton afficher).
\dokuitem  permettre de créer des instances de \dokumonospace{Chien} à partir des informations et d’afficher les collections produites (bouton créer).
\end{itemize}

\dokutitlelevelfour{Editeur d'IHM}
Pour aller plus loin, vous pouvez utiliser un générateur d'IHM \href{http://code.google.com/intl/fr/javadevtools/wbpro/quick_start.html}{http://code.google.com/intl/fr/javadevtools/wbpro/quick{{\textbackslash}textunderscore}start.html} (Il faut installer un plugin sous eclipse).


\dokutitleleveltwo{TP5 - Apprendre par vous même l'introspection}
\label{c37e90642c4932ca2343602f0d7387a3}%% tp5_-_apprendre_par_vous_meme_l_introspection

\begin{itemize}
\dokuitem  Etape 1 : Suivez et expérimentez le tutorial sur l'\href{http://download.oracle.com/javase/tutorial/reflect/index.html}{introspection} (trails Classes et Member).
\dokuitem  Etape 2 : Qu'est-ce qu'un Java bean ?
\dokuitem  Etape 3 : Compilation depuis un programme. Etudiez \href{http://docs.codehaus.org/display/JANINO/Home}{Janino} (Y-a-t-il une alternative ?).
\dokuitem  Des exemples : \hyperref[60bf9958a8828e385649906ec5c5f0f8]{introspection.java.tgz} (NB ces exemples seront bientôt disponible sur le SVN).
\end{itemize}

\dokutitleleveltwo{TP6 - JDBC}
\label{f9ba4f240ea2463a02f6413c4251b142}%% tp6_-_jdbc

\dokutitleleveltree{Utilisation simple de JDBC}
\label{a9bca45b9cea190a3f0ead24d80041fc}%% utilisation_simple_de_jdbc

\begin{enumerate}\dokuitem  En utilisant pgadmin3 ou la ligne de commande et le script \hyperref[f0daf23ecae86b1edecce96d54380bdb]{journal.zip} créer les tables qui représentent des journaux.
\dokuitem  Créer une classe que se connecte à votre base de donnée postgresql. Pensez à mettre en place correctement les librairies nécessaires. Pour le moment, la connection sera représentée par une variable d'instance.
\dokuitem  Ajouter une méthode qui affiche la liste des journaux en utilisant un Statment
\dokuitem  Créer une fonction ajouterJournal(\ldots{}) qui permet d'insérer un journal dans la base de données
\dokuitem  En utilisant un PreparedStamement, lire un code de Journal au clavier et afficher les informations correspondantes tant que l'on ne rentre pas 0.
\end{enumerate}

\dokutitleleveltree{Utilisation des métadonnées}
\label{c704404daf56191e17ce4d3bd9a1cc7a}%% utilisation_des_metadonnees

\begin{enumerate}\dokuitem  Ajouter une méthode qui affiche les métadonnées correspondant à la base de données
\dokuitem  Ajouter une méthode qui afficher les métadonnées correspondant à la requête \dokumonospace{select * from journal}
\end{enumerate}

\dokutitleleveltree{Batch Update}
\label{c73ed7d23fffa149c79610e279433b8f}%% batch_update

\begin{enumerate}\dokuitem  Utiliser les batch update pour ajouter des journaux en lisant un fichier texte formaté (\dokumonospace{code{\textunderscore}j:titre:prix:type:periode::adr{\textunderscore}j}).
\end{enumerate}

\dokutitleleveltree{Utilisation d'un pool de connexion}
\label{f35dfc1e84c1497c63988ac9264ff06b}%% utilisation_d_un_pool_de_connexion
En utilisant la classe suivante, utiliser maintenant un pool de connexion au lieu d'une variable globale.


\lstset{language=java}
\begin{lstlisting}
package fr.univ_tln.bruno.mycompany.jdbc.pool;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.LinkedList;
import java.util.Queue;

/**
 * The Class DatabaseManager.
 */
public class DatabaseManager {

	/** The Constant freeConnections. */
	private static final Queue<Connection> freeConnections = new LinkedList<Connection>();

	/** The Constant numberOfInitialConnections. */
	private static final int numberOfInitialConnections = 5;

	/** The Constant password. */
	private static final String password = System
			.getProperty("MyCompany.database.password");

	/** The Constant url. */
	private static final String url = System
			.getProperty("MyCompany.database.url");

	/** The Constant user. */
	private static final String user = System
			.getProperty("MyCompany.database.user");

	static {
		for (int i = 0; i < numberOfInitialConnections; i++) {
			try {
				freeConnections.add(DriverManager.getConnection(url, user,
						password));
			} catch (SQLException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}

	/**
	 * Gets the connection.
	 * 
	 * @return the connection
	 * 
	 * @throws SQLException
	 *             the SQL exception
	 */
	public static synchronized Connection getConnection() throws SQLException {
		Connection connection = null;
		if (freeConnections.isEmpty()) {
			connection = DriverManager.getConnection(url, user, password);
		} else {
			connection = freeConnections.remove();
		}
		return connection;
	}

	/**
	 * Release connection.
	 * 
	 * @param connection
	 *            the connection
	 */
	public static synchronized void releaseConnection(Connection connection) {
		if (freeConnections.size() < numberOfInitialConnections) {
			freeConnections.add(connection);
		} else {
			try {
				connection.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
	}
}

\end{lstlisting}
Attention, les login et password doivent être définit pas des "properties" (cf \dokumonospace{System.setProperty()}). Ensuite, ils pourront être lus dans un fichier de configuration.


\dokutitleleveltree{Pour finir}
\label{19d1064f37343bcf091522e4f14a4bde}%% pour_finir

\begin{enumerate}\dokuitem  Créer une interface \dokumonospace{Entity} qui impose les méthodes \dokumonospace{create}, \dokumonospace{remove}, et \dokumonospace{merge}
\dokuitem  Créer une classe qui spécialise la classe Chien en implante l'interface précédente et qui permet de 
\begin{enumerate}\dokuitem  Créer une instance de Chien
\dokuitem  D'invoquer \dokumonospace{create} pour ajouter ce Chien dans la base de données
\dokuitem  De modifier l'instance de Chien en mémoire (éventuellement plusieurs fois)
\dokuitem  De faire une mise à jour dans la base de données avec \dokumonospace{merge} 
\dokuitem  Et finalement de supprimer le Chien avec remove.
\end{enumerate}

\dokuitem  Implanter des méthodes qui permettent de retrouver et d'instancier un ou des Chiens :
\begin{enumerate}\dokuitem  Chien findById(\ldots{})
\dokuitem  List$<$Chien$>$ findByName(\ldots{}), \ldots{}
\end{enumerate}

\dokuitem  En vous inspirant de cet exemple \href{http://onjava.com/pub/a/onjava/excerpt/swinghks_hack24/index.html}{http://onjava.com/pub/a/onjava/excerpt/swinghks{{\textbackslash}textunderscore}hack24/index.html}, créer une JTable qui permet d'afficher les Chiens contenus dans la base de données.
\end{enumerate}
\end{document}

