\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 = {JAVA TP1},
pdfauthor = {E. Bruno},
pdfcreator = {DokuTeXit},
pdfproducer = {dokuwiki + TeXit + latex + dvipdf}
}
\title{JAVA TP1}
\author{E. Bruno}
\dokubackground{http://lsis.univ-tln.fr/\~{ }bruno/}
\begin{document}
\thispagestyle{empty}
\maketitle
\thispagestyle{empty}
\cleardoublepage
\tableofcontents
\newpage
\thispagestyle{plain}
\cleardoublepage
\newpage



\dokutitlelevelone{TP1 - Premiers pas en Java}
\label{13d6d501473b756b79e18c21da9270c8}%% tp1_-_premiers_pas_en_java
\label{35a448b5c9018c4b93cd8dbe8502d060}%%Start: tp1 => /home/bruno/public_html/data/pages/tp1.txt

\dokutitleleveltwo{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.


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

\dokutitleleveltree{Mettre en place l’environnement}
\label{50013d917c9a0c27e4794a3691569ab0}%% 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}

\dokutitleleveltree{Compiler et exécuter une application}
\label{9354dc4099f3205e207e58fa22a9c127}%% compiler_et_executer_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

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

\dokutitleleveltree{Précision sur la forme}
\label{a209ad7f06426d3acea2171d1c93386a}%% precision_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})


\dokutitleleveltree{Génération}
\label{9cb9ce5bd9e807867d42a740c9633fc7}%% generation
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

\dokutitleleveltwo{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} 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

\dokutitleleveltwo{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

\dokutitleleveltwo{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.


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

\dokutitleleveltree{Création et instanciation d’une classe}
\label{2ff45643270d0c1760e73a8e7aa4dde1}%% creation_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.


\dokutitleleveltree{Les méthodes de base}
\label{4bb1145b310b42d6a273df136f1f3e80}%% les_methodes_de_base

\dokutitlelevelfour{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}.


\dokutitlelevelfour{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.


\dokutitleleveltree{Définition de classes locales}
\label{816b8883aa25e2d707f64b4609cdafcd}%% definition_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}.


\dokutitleleveltwo{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
\end{document}

