EISTI-ING1-GI
/
Java-2017-2018


			
				
					
						
						
							123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724
							<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml" lang="" xml:lang="">
<head>
  <meta charset="utf-8" />
  <meta name="generator" content="pandoc" />
  <meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes" />
  <title>Decouvrir Java</title>
  <style type="text/css">
      code{white-space: pre-wrap;}
      span.smallcaps{font-variant: small-caps;}
      span.underline{text-decoration: underline;}
      div.column{display: inline-block; vertical-align: top; width: 50%;}
  </style>
  <style type="text/css">
a.sourceLine { display: inline-block; line-height: 1.25; }
a.sourceLine { pointer-events: none; color: inherit; text-decoration: inherit; }
a.sourceLine:empty { height: 1.2em; position: absolute; }
.sourceCode { overflow: visible; }
code.sourceCode { white-space: pre; position: relative; }
div.sourceCode { margin: 1em 0; }
pre.sourceCode { margin: 0; }
@media screen {
div.sourceCode { overflow: auto; }
}
@media print {
code.sourceCode { white-space: pre-wrap; }
a.sourceLine { text-indent: -1em; padding-left: 1em; }
}
pre.numberSource a.sourceLine
  { position: relative; }
pre.numberSource a.sourceLine:empty
  { position: absolute; }
pre.numberSource a.sourceLine::before
  { content: attr(data-line-number);
    position: absolute; left: -5em; text-align: right; vertical-align: baseline;
    border: none; pointer-events: all;
    -webkit-touch-callout: none; -webkit-user-select: none;
    -khtml-user-select: none; -moz-user-select: none;
    -ms-user-select: none; user-select: none;
    padding: 0 4px; width: 4em;
    color: #aaaaaa;
  }
pre.numberSource { margin-left: 3em; border-left: 1px solid #aaaaaa;  padding-left: 4px; }
div.sourceCode
  {  }
@media screen {
a.sourceLine::before { text-decoration: underline; }
}
code span.al { color: #ff0000; font-weight: bold; } /* Alert */
code span.an { color: #60a0b0; font-weight: bold; font-style: italic; } /* Annotation */
code span.at { color: #7d9029; } /* Attribute */
code span.bn { color: #40a070; } /* BaseN */
code span.bu { } /* BuiltIn */
code span.cf { color: #007020; font-weight: bold; } /* ControlFlow */
code span.ch { color: #4070a0; } /* Char */
code span.cn { color: #880000; } /* Constant */
code span.co { color: #60a0b0; font-style: italic; } /* Comment */
code span.cv { color: #60a0b0; font-weight: bold; font-style: italic; } /* CommentVar */
code span.do { color: #ba2121; font-style: italic; } /* Documentation */
code span.dt { color: #902000; } /* DataType */
code span.dv { color: #40a070; } /* DecVal */
code span.er { color: #ff0000; font-weight: bold; } /* Error */
code span.ex { } /* Extension */
code span.fl { color: #40a070; } /* Float */
code span.fu { color: #06287e; } /* Function */
code span.im { } /* Import */
code span.in { color: #60a0b0; font-weight: bold; font-style: italic; } /* Information */
code span.kw { color: #007020; font-weight: bold; } /* Keyword */
code span.op { color: #666666; } /* Operator */
code span.ot { color: #007020; } /* Other */
code span.pp { color: #bc7a00; } /* Preprocessor */
code span.sc { color: #4070a0; } /* SpecialChar */
code span.ss { color: #bb6688; } /* SpecialString */
code span.st { color: #4070a0; } /* String */
code span.va { color: #19177c; } /* Variable */
code span.vs { color: #4070a0; } /* VerbatimString */
code span.wa { color: #60a0b0; font-weight: bold; font-style: italic; } /* Warning */
  </style>
  <link rel="stylesheet" href="buttondown.css">
  <!--[if lt IE 9]>
    <script src="//cdnjs.cloudflare.com/ajax/libs/html5shiv/3.7.3/html5shiv-printshiv.min.js"></script>
  <![endif]-->
</head>
<body>
<h1 id="découvrir-java">Découvrir Java</h1>
<h2 id="introduction">Introduction</h2>
<p>Dans cette première partie, nous allons découvrir Java sous la forme de petits programmes. Nous n’allons pas tout de suite chercher à faire de programmes complexes, mais nous allons utiliser des mécanismes de la Programmation Orienté Objet et observer leurs effets.</p>
<p>L’idée va être de se familiariser avec différents concepts: classes, instances, interfaces, héritage et même modèles de conception.</p>
<p>Nous allons faire collaborer des objets entre eux afin d’observer des comportements selon la manière dont ils sont assemblés.</p>
<h2 id="premiers-pas">Premiers pas</h2>
<h3 id="bases-du-langage">Bases du langage</h3>
<p>Dans cette partie, des exemples sont donnés pour chaque élément de base du langage.</p>
<p>La documentation Java fournie par Oracle est disponible <a href="https://docs.oracle.com/javase/tutorial/java/nutsandbolts/index.html">ici</a>. Elle reprend l’ensemble des concepts abordés;</p>
<h4 id="types-primitifs">Types primitifs</h4>
<p>Dupliquer la classe <code>HelloWorld</code> en une classe <code>TypesPrimitifs</code> (essayez un copier-coller).</p>
<p>Y insérer le code suivant:</p>
<div class="sourceCode" id="cb1"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb1-1" data-line-number="1"><span class="dt">int</span> entier = <span class="dv">3</span>;</a>
<a class="sourceLine" id="cb1-2" data-line-number="2"><span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">print</span>(<span class="st">&quot;entier: &quot;</span>);</a>
<a class="sourceLine" id="cb1-3" data-line-number="3"><span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(entier);</a>
<a class="sourceLine" id="cb1-4" data-line-number="4"></a>
<a class="sourceLine" id="cb1-5" data-line-number="5"><span class="dt">boolean</span> test = <span class="kw">false</span>;</a>
<a class="sourceLine" id="cb1-6" data-line-number="6"><span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">print</span>(<span class="st">&quot;booléen: &quot;</span>);</a>
<a class="sourceLine" id="cb1-7" data-line-number="7"><span class="co">// Afficher cette valeur avec un System.out.println()</span></a>
<a class="sourceLine" id="cb1-8" data-line-number="8"></a>
<a class="sourceLine" id="cb1-9" data-line-number="9"><span class="dt">float</span> flottant = <span class="fl">2.8f</span>;</a>
<a class="sourceLine" id="cb1-10" data-line-number="10"><span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">print</span>(<span class="st">&quot;flottant: &quot;</span>);</a>
<a class="sourceLine" id="cb1-11" data-line-number="11"><span class="co">// Afficher cette valeur avec un System.out.println()</span></a>
<a class="sourceLine" id="cb1-12" data-line-number="12"></a>
<a class="sourceLine" id="cb1-13" data-line-number="13"><span class="co">//Voir le tableau ci-dessous</span></a></code></pre></div>
<p>Déterminez pourquoi des erreurs de compilation apparaissent avec les types et certaines valeurs ci-dessous :</p>
<table>
<thead>
<tr class="header">
<th>Type</th>
<th>Valeurs à tester</th>
</tr>
</thead>
<tbody>
<tr class="odd">
<td>byte</td>
<td>8 puis 127 puis 128 puis -128 puis -129</td>
</tr>
<tr class="even">
<td>short</td>
<td>-32768 puis -32769</td>
</tr>
<tr class="odd">
<td>int</td>
<td>déterminez les valeurs possibles à utiliser</td>
</tr>
<tr class="even">
<td>long</td>
<td>2L puis déterminez les valeurs possibles à utiliser</td>
</tr>
<tr class="odd">
<td>float</td>
<td>1.5f puis 1.5 puis déterminez les valeurs possibles à utiliser</td>
</tr>
<tr class="even">
<td>double</td>
<td>3.8 puis 9.7d</td>
</tr>
</tbody>
</table>
<div class="line-block">char | ’<br />
String | “” puis “cd” |<br />
boolean | false puis true|</div>
<p>Pour chacun des types, trouvez quelle est la valeur par défaut.</p>
<p>Si besoin, vous pouvez trouver plus d’information sur les types primitifs <a href="https://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html">ici</a></p>
<h4 id="tableaux">Tableaux</h4>
<p>En Java, les types tableaux (<code>array</code>) sont indexés à partir de 0.</p>
<p>Ils sont déclarés grâce à des crochets: <code>[]</code></p>
<div class="sourceCode" id="cb2"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb2-1" data-line-number="1"><span class="dt">int</span>[] tableauEntiers;</a></code></pre></div>
<p>Il est possible de créer des tableaux pour tous les types primitifs, mais aussi pour des objets (par exemple le type <code>String</code>).</p>
<p>Pour créer un nouveau tableau, plusieurs possibilités.</p>
<p><em>Créez une classe </em><code>Tableaux</code>* dans laquelle vous testerez les codes donnés ci-dessous.*</p>
<p>La première, en initialisant le tableau puis chacun de ses éléments:</p>
<div class="sourceCode" id="cb3"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb3-1" data-line-number="1">tableauEntiers = <span class="kw">new</span> <span class="dt">int</span>[<span class="dv">3</span>];</a>
<a class="sourceLine" id="cb3-2" data-line-number="2">tableauEntiers[<span class="dv">0</span>] = <span class="dv">1</span> ; <span class="co">//premier élément</span></a>
<a class="sourceLine" id="cb3-3" data-line-number="3">tableauEntiers[<span class="dv">1</span>] = <span class="dv">2</span> ; <span class="co">//second élément</span></a>
<a class="sourceLine" id="cb3-4" data-line-number="4">tableauEntiers[<span class="dv">2</span>] = <span class="dv">3</span> ; <span class="co">//troisième élément</span></a>
<a class="sourceLine" id="cb3-5" data-line-number="5"></a>
<a class="sourceLine" id="cb3-6" data-line-number="6"><span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">print</span>(<span class="st">&quot;premier élément:&quot;</span>);</a>
<a class="sourceLine" id="cb3-7" data-line-number="7"><span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(tableauEntiers[<span class="dv">0</span>]);</a>
<a class="sourceLine" id="cb3-8" data-line-number="8"><span class="co">//...</span></a></code></pre></div>
<p>La seconde, en initialisant le tableau puis en lui attribuant un ensemble de valeur:</p>
<div class="sourceCode" id="cb4"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb4-1" data-line-number="1"><span class="dt">int</span>[] tableauEntiers = {<span class="dv">1</span>_<span class="dv">000</span>, <span class="dv">2</span>_<span class="dv">345</span>_<span class="dv">678</span>, <span class="dv">3</span>, <span class="dv">4</span>, <span class="dv">500000</span>,</a>
<a class="sourceLine" id="cb4-2" data-line-number="2">    <span class="dv">600</span>_<span class="dv">000</span>_<span class="dv">000</span>, <span class="dv">7</span>_<span class="dv">000</span>_<span class="dv">000</span>};</a>
<a class="sourceLine" id="cb4-3" data-line-number="3"><span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">print</span>(<span class="st">&quot;premier élément:&quot;</span>);</a>
<a class="sourceLine" id="cb4-4" data-line-number="4"><span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(tableauEntiers[<span class="dv">0</span>]);</a>
<a class="sourceLine" id="cb4-5" data-line-number="5"><span class="co">//...</span></a></code></pre></div>
<p>Plus d’informations sur les tableaux sont <a href="https://docs.oracle.com/javase/tutorial/java/nutsandbolts/arrays.html">disponibles ici</a></p>
<h5 id="exercice">Exercice</h5>
<p>Définir un tableau à deux dimensions contenant quatre <code>String</code>.</p>
<ul>
<li>En première ligne: <code>&quot;Nom&quot;</code> et <code>&quot;Prénom&quot;</code></li>
<li>En seconde ligne : <code>&quot;Myriam&quot;</code> et <code>&quot;Makeba&quot;</code></li>
</ul>
<p>Afficher chacune de ces valeurs séparéments.</p>
<h4 id="opérateurs">Opérateurs</h4>
<p>Nous allons expérimentez quelques éléments sur les opérateurs dans une nouvelle classe <code>Operateurs</code> (toujours dans le paquet <code>com.example.hello</code>).</p>
<p>Pour une référence plus complète, vous pouvez trouver des informations <a href="https://docs.oracle.com/javase/tutorial/java/nutsandbolts/operators.html">ici</a></p>
<h5 id="assignation">Assignation</h5>
<p>L’assignation de valeur se fait grâce au signe <code>=</code> :</p>
<ul>
<li>int entier = 4;</li>
<li>String chaine = “characters”;</li>
</ul>
<h5 id="opérations-arithmétiques">Opérations arithmétiques</h5>
<p>Les opérations arithmétiques simples sont résumées ici:</p>
<table>
<thead>
<tr class="header">
<th>Opérateur</th>
<th>Description</th>
</tr>
</thead>
<tbody>
<tr class="odd">
<td>+</td>
<td>Addition (ou pour le type <code>String</code> : concaténation)</td>
</tr>
<tr class="even">
<td>-</td>
<td>Soustraction</td>
</tr>
<tr class="odd">
<td>*</td>
<td>Multiplication</td>
</tr>
<tr class="even">
<td>/</td>
<td>Division</td>
</tr>
<tr class="odd">
<td>%</td>
<td>Modulo (reste de la division euclidienne)</td>
</tr>
</tbody>
</table>
<p><strong>Exercice</strong></p>
<p>Testez les codes suivants et vérifiez leur validité (<em>est-ce que le résultat produit est bien le résultat attendu ?</em>)</p>
<div class="sourceCode" id="cb5"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb5-1" data-line-number="1"><span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(<span class="st">&quot;Hello&quot;</span> + <span class="st">&quot; &quot;</span> + <span class="st">&quot;World&quot;</span>);</a>
<a class="sourceLine" id="cb5-2" data-line-number="2"><span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(  <span class="dv">1</span> + <span class="dv">3</span>);</a>
<a class="sourceLine" id="cb5-3" data-line-number="3"><span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(<span class="st">&quot;1&quot;</span> + <span class="dv">3</span>);</a>
<a class="sourceLine" id="cb5-4" data-line-number="4"><span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(<span class="fl">1.0</span> + <span class="dv">3</span>);</a>
<a class="sourceLine" id="cb5-5" data-line-number="5"></a>
<a class="sourceLine" id="cb5-6" data-line-number="6"><span class="dt">int</span> dividende = <span class="dv">24</span>;</a>
<a class="sourceLine" id="cb5-7" data-line-number="7"><span class="dt">int</span> diviseur = <span class="dv">5</span>;</a>
<a class="sourceLine" id="cb5-8" data-line-number="8"><span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(<span class="st">&quot;Le résultat de &quot;</span> +</a>
<a class="sourceLine" id="cb5-9" data-line-number="9">    dividende +<span class="st">&quot; % &quot;</span> + diviseur + <span class="st">&quot; est &quot;</span> + dividende % diviseur);</a>
<a class="sourceLine" id="cb5-10" data-line-number="10"><span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(<span class="st">&quot;Le résultat de &quot;</span> +</a>
<a class="sourceLine" id="cb5-11" data-line-number="11">    dividende +<span class="st">&quot; / &quot;</span> + diviseur + <span class="st">&quot; est &quot;</span> + dividende / diviseur);</a>
<a class="sourceLine" id="cb5-12" data-line-number="12"></a>
<a class="sourceLine" id="cb5-13" data-line-number="13"><span class="dt">double</span> dividendeFlottant = <span class="fl">24.0</span>;</a>
<a class="sourceLine" id="cb5-14" data-line-number="14"><span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(<span class="st">&quot;Le résultat de &quot;</span> +</a>
<a class="sourceLine" id="cb5-15" data-line-number="15">    dividendeFlottant +<span class="st">&quot; % &quot;</span> + diviseur + <span class="st">&quot; est &quot;</span> + dividendeFlottant % diviseur);</a>
<a class="sourceLine" id="cb5-16" data-line-number="16"><span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(<span class="st">&quot;Le résultat de &quot;</span> +</a>
<a class="sourceLine" id="cb5-17" data-line-number="17">    dividendeFlottant +<span class="st">&quot; / &quot;</span> + diviseur + <span class="st">&quot; est &quot;</span> + dividendeFlottant / diviseur);</a></code></pre></div>
<h5 id="comparaisons-et-opérations-booléennes">Comparaisons et opérations booléennes</h5>
<p>Les opérateurs de comparaisons sont les suivants:</p>
<table>
<thead>
<tr class="header">
<th>Opérateur</th>
<th>Description</th>
</tr>
</thead>
<tbody>
<tr class="odd">
<td>==</td>
<td>égal</td>
</tr>
<tr class="even">
<td>!=</td>
<td>non égal (différent de)</td>
</tr>
<tr class="odd">
<td>&gt;</td>
<td>supérieur</td>
</tr>
<tr class="even">
<td>&gt;=</td>
<td>supérieur ou égal</td>
</tr>
<tr class="odd">
<td>&lt;</td>
<td>inférieur</td>
</tr>
<tr class="even">
<td>&lt;=</td>
<td>inférieur ou égal</td>
</tr>
</tbody>
</table>
<p>Ils renvoient <strong>toujours</strong> une valeur booléenne (<code>boolean</code>).</p>
<h6 id="exercice-1">Exercice</h6>
<p>Testez les codes suivants et vérifiez leur validité (<em>est-ce que le résultat produit est bien le résultat attendu ?</em>)</p>
<div class="sourceCode" id="cb6"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb6-1" data-line-number="1"><span class="dt">int</span> un = <span class="dv">1</span>;</a>
<a class="sourceLine" id="cb6-2" data-line-number="2"><span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(<span class="st">&quot;1 == 2 : &quot;</span>     + (<span class="dv">1</span> == <span class="dv">2</span>));</a>
<a class="sourceLine" id="cb6-3" data-line-number="3"><span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(<span class="st">&quot;2 == 1 + 1 : &quot;</span> + (<span class="dv">2</span> == <span class="dv">1</span> + un));</a>
<a class="sourceLine" id="cb6-4" data-line-number="4"><span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(<span class="st">&quot;1 != 2 : &quot;</span>     + (<span class="dv">1</span> != <span class="dv">2</span>));</a>
<a class="sourceLine" id="cb6-5" data-line-number="5"><span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(<span class="st">&quot;3 &gt; 3 : &quot;</span>     + (<span class="dv">3</span> &gt; <span class="dv">3</span>));</a>
<a class="sourceLine" id="cb6-6" data-line-number="6"><span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(<span class="st">&quot;3 &gt;= 3 : &quot;</span>     + (<span class="dv">3</span> &gt;= <span class="dv">3</span>));</a>
<a class="sourceLine" id="cb6-7" data-line-number="7"><span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(<span class="st">&quot;4 &lt; 4 : &quot;</span>     + (<span class="dv">4</span> &lt; <span class="dv">4</span>));</a>
<a class="sourceLine" id="cb6-8" data-line-number="8"><span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(<span class="st">&quot;4 &lt;= 4 : &quot;</span>     + (<span class="dv">4</span> &lt;= <span class="dv">4</span>));</a></code></pre></div>
<h5 id="opérations-booléennes">Opérations booléennes</h5>
<p>Les opérations <code>ET</code>, <code>OU</code> et <code>NON</code> se font sur des valeurs booléennes:</p>
<table>
<thead>
<tr class="header">
<th>Opérateur</th>
<th>Description</th>
</tr>
</thead>
<tbody>
<tr class="odd">
<td><code>||</code></td>
<td>OU</td>
</tr>
<tr class="even">
<td><code>&amp;&amp;</code></td>
<td>ET</td>
</tr>
<tr class="odd">
<td><code>!</code></td>
<td>NON</td>
</tr>
</tbody>
</table>
<h6 id="exercice-2">Exercice</h6>
<p>Testez les codes suivants et vérifiez leur validité (<em>est-ce que le résultat produit est bien le résultat attendu ?</em>)</p>
<div class="sourceCode" id="cb7"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb7-1" data-line-number="1"><span class="dt">int</span> un = <span class="dv">1</span>;</a>
<a class="sourceLine" id="cb7-2" data-line-number="2"><span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(<span class="st">&quot;false || false : &quot;</span>     + (<span class="kw">false</span> || <span class="kw">false</span>));</a>
<a class="sourceLine" id="cb7-3" data-line-number="3"><span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(<span class="st">&quot;false || true : &quot;</span>      + (<span class="kw">false</span> || <span class="kw">true</span>));</a>
<a class="sourceLine" id="cb7-4" data-line-number="4"><span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(<span class="st">&quot;true  || true : &quot;</span>      + (<span class="kw">true</span> || <span class="kw">true</span>));</a>
<a class="sourceLine" id="cb7-5" data-line-number="5"><span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(<span class="st">&quot;false &amp;&amp; true : &quot;</span>      + (<span class="kw">false</span> &amp;&amp; <span class="kw">true</span>));</a>
<a class="sourceLine" id="cb7-6" data-line-number="6"><span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(<span class="st">&quot;true  &amp;&amp; true : &quot;</span>      + (<span class="kw">true</span>  &amp;&amp; <span class="kw">true</span>));</a>
<a class="sourceLine" id="cb7-7" data-line-number="7"><span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(<span class="st">&quot;2 == 1 + un &amp;&amp; true : &quot;</span>+ (<span class="dv">2</span> == <span class="dv">1</span> + un  || <span class="kw">true</span>));</a>
<a class="sourceLine" id="cb7-8" data-line-number="8"><span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(<span class="st">&quot;NON (2 == 1 + un &amp;&amp; true) : &quot;</span>+ !(<span class="dv">2</span> == <span class="dv">1</span> + un  || <span class="kw">true</span>));</a></code></pre></div>
<h4 id="découverte-du-débogueur-eclipse">Découverte du débogueur Eclipse</h4>
<p>Reprenez chacun des codes précédents et lancez-le en utilisant le déboggueur Eclipse (Menu <code>Run &gt; Debug</code> ou le bouton de la barre d’outils ayant l’icône correspondante)</p>
<p>Acceptez le passage dans la <code>Perspective</code> correspondante au mode <code>Debug</code></p>
<p>Ajoutez un point d’arrêt sur la première ligne de votre méthode <code>main</code> et relancez le débogueur.</p>
<p>Visualisez les boutons <code>Step into</code>, <code>Step over</code>.</p>
<ul>
<li>Observez leurs effets</li>
<li>À quoi servent-ils ?</li>
</ul>
<h3 id="objets-et-classes">Objets et classes</h3>
<h4 id="programmation-orientée-objet">Programmation Orientée Objet</h4>
<p>Java est un langage <em>Orienté Objet</em> (OO). Cela signifie que programmer consiste à définir des entités qui vont contenir des données et des comportements. Le programme indique comment ces entités vont interagir entre elles.</p>
<p>Ces entités sont des <strong>objets</strong>.</p>
<p><em>Note: On parle de Programmation Orientée Objet (POO). En anglais: OOP (Object Oriented Programing)</em></p>
<h4 id="un-peu-de-vocabulaire">Un peu de vocabulaire</h4>
<p>Pour créer un <strong>objet</strong>, il faut un modèle (un patron, un moule).</p>
<p>Le modèle d’un <strong>objet</strong> est une <strong>classe</strong>.</p>
<p>À partir de ce modèle, on en créera un exemplaire : un <strong>objet</strong> est une <strong>instance</strong> d’une <strong>classe</strong>.</p>
<p>Parfois, on utilise le mot <strong>type</strong> pour désigner une <strong>classe</strong>. Par exemple, un objet de type <code>Integer</code> désigne une instance de la classe <code>Integer</code>.</p>
<p>Chaque objet possède des <strong>membres</strong> :</p>
<ul>
<li>des informations : ses <strong>attributs</strong></li>
<li>des comportements : ses <strong>méthodes</strong></li>
</ul>
<p>Une <strong>classe</strong> permet de définir ces <strong>membres</strong> (attributs et méthodes) pour tous les <strong>objets</strong> qui seront <strong>instanciés</strong> sur son modèle.</p>
<p>Une méthode est l’équivalent d’une <strong>fonction</strong> en programmation procédurale; sauf que cette <em>fonction</em> permet de manipuler les attributs de l’objet, indépendamment de ceux d’un autre objet.</p>
<h4 id="premières-classes">Premières classes</h4>
<p>Dans un premier temps, il vous est proposé de créer une fonction mathématique permettant de multiplier deux nombres entiers.</p>
<p>Le résultat de cette fonction sera stocké dans l’attribut <code>resultat</code> de l’objet</p>
<h5 id="classe-multiplication">Classe Multiplication</h5>
<p>Implémenter une méthode (que l’on nommera <code>calculer</code>) dans une classe nommée <code>Multiplication</code></p>
<p>Voici un exemple à compléter:</p>
<div class="sourceCode" id="cb8"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb8-1" data-line-number="1"><span class="kw">package</span><span class="im"> com.example.java;</span></a>
<a class="sourceLine" id="cb8-2" data-line-number="2"></a>
<a class="sourceLine" id="cb8-3" data-line-number="3"><span class="kw">public</span> <span class="kw">class</span> Multiplication {</a>
<a class="sourceLine" id="cb8-4" data-line-number="4">  <span class="dt">int</span> resultat ;</a>
<a class="sourceLine" id="cb8-5" data-line-number="5">  <span class="kw">public</span> <span class="dt">void</span> <span class="fu">calculer</span>(<span class="dt">int</span> a, <span class="dt">int</span> b){</a>
<a class="sourceLine" id="cb8-6" data-line-number="6">    resultat = a * b;</a>
<a class="sourceLine" id="cb8-7" data-line-number="7">  }</a>
<a class="sourceLine" id="cb8-8" data-line-number="8">}</a></code></pre></div>
<p><strong>Un peu d’UML :</strong> ci-dessous la représentation UML de cette classe</p>
<figure>
<img src="images/Multiplication.png" alt="Multiplication" /><figcaption>Multiplication</figcaption>
</figure>
<hr />
<h5 id="classe-principale">Classe principale</h5>
<p>Pour tester cette classe, nous allons créer une nouvelle classe <em>principale</em> (qui contient une méthode <code>main</code>) dans laquelle on fera appel à la classe <code>Multiplication</code>.</p>
<p>Cette nouvelle classe se nommera <code>Calculer</code>:</p>
<div class="sourceCode" id="cb9"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb9-1" data-line-number="1"><span class="kw">package</span><span class="im"> com.example.java ;</span></a>
<a class="sourceLine" id="cb9-2" data-line-number="2"></a>
<a class="sourceLine" id="cb9-3" data-line-number="3"><span class="kw">public</span> <span class="kw">class</span> Calculer {</a>
<a class="sourceLine" id="cb9-4" data-line-number="4">    <span class="kw">public</span> <span class="dt">static</span> <span class="dt">void</span> <span class="fu">main</span>(<span class="bu">String</span>[] args) {</a>
<a class="sourceLine" id="cb9-5" data-line-number="5">        <span class="co">//Créer une instance de la nouvelle classe avec le mot clé `new`</span></a>
<a class="sourceLine" id="cb9-6" data-line-number="6">        Multiplication premierCalcul = <span class="kw">new</span> <span class="fu">Multiplication</span>();</a>
<a class="sourceLine" id="cb9-7" data-line-number="7"></a>
<a class="sourceLine" id="cb9-8" data-line-number="8">        <span class="co">// Créer une variable nommée resultat</span></a>
<a class="sourceLine" id="cb9-9" data-line-number="9">        premierCalcul.<span class="fu">calculer</span>(<span class="dv">3</span>, <span class="dv">5</span>); <span class="co">// appel de méthode</span></a>
<a class="sourceLine" id="cb9-10" data-line-number="10"></a>
<a class="sourceLine" id="cb9-11" data-line-number="11">        <span class="co">// Ecrire le résultat du calcul dans la sortie standard</span></a>
<a class="sourceLine" id="cb9-12" data-line-number="12">        <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(<span class="st">&quot;Le résultat de 3 multiplié par 5:&quot;</span>);</a>
<a class="sourceLine" id="cb9-13" data-line-number="13">        <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(premierCalcul.<span class="fu">resultat</span>);</a>
<a class="sourceLine" id="cb9-14" data-line-number="14">    }</a>
<a class="sourceLine" id="cb9-15" data-line-number="15">}</a></code></pre></div>
<h5 id="instantiation">Instantiation</h5>
<p>Dans ce programme, nous avons utilisé le mot clef <code>new</code> qui permet d’<strong>instancier</strong> un objet à partir d’une classe:</p>
<div class="sourceCode" id="cb10"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb10-1" data-line-number="1">Multiplication premierCalcul = <span class="kw">new</span> <span class="fu">Multiplication</span>();</a></code></pre></div>
<p>Ce mot clef permet de faire appel au <strong>constructeur</strong> de la classe. Si aucun <strong>constructeur</strong> n’est explicitement déclaré dans une classe, le compilateur Java crée un constructeur par défaut, c’est-à-dire sans aucun paramètre.</p>
<p>La ligne ci-dessus stocke un <strong>pointeur</strong> vers l’instance créée dans la variable <code>premierCalcul</code>.</p>
<p>Cette variable est déclaré avec un type (la classe) <code>Multiplication</code>.</p>
<h5 id="appel-de-méthode">Appel de méthode</h5>
<p>L’appel d’une méthode est similaire à l’appel d’une fonction dans un autre langage, à la différence près que la méthode est rattachée à un objet.</p>
<p>La ligne suivante permet donc d’appeler la méthode <code>calculer</code> qui est rattachée à l’instance <strong>pointée</strong> par la variable <code>premierCalcul</code>.</p>
<div class="sourceCode" id="cb11"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb11-1" data-line-number="1">premierCalcul.<span class="fu">calculer</span>(<span class="dv">3</span>, <span class="dv">5</span>);</a></code></pre></div>
<h5 id="test-du-programme">Test du programme</h5>
<p>Exécuter votre programme depuis Eclipse</p>
<p>Que constatez-vous ?</p>
<h5 id="classe-addition">Classe Addition</h5>
<p>Implémentez l’opération mathématique <em>Addition</em>. Elle permet d’additionner deux nombres entiers dans une classe nommée <code>Addition</code>, sur le même modèle que la classe <code>Multiplication</code>.</p>
<p>Testez-les avec un code qui devrait ressembler à ceci (toujours dans la classe principale <code>Calculer</code>:</p>
<div class="sourceCode" id="cb12"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb12-1" data-line-number="1">Addition secondCalcul = <span class="kw">new</span> <span class="fu">Addition</span>(); <span class="co">//Instanciation</span></a>
<a class="sourceLine" id="cb12-2" data-line-number="2">secondCalcul.<span class="fu">calculer</span>(<span class="dv">3</span>, <span class="dv">5</span>); <span class="co">//appel de la</span></a>
<a class="sourceLine" id="cb12-3" data-line-number="3"><span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(<span class="st">&quot;Le résultat de 3 ajouté à 5:&quot;</span>);</a>
<a class="sourceLine" id="cb12-4" data-line-number="4"><span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(secondCalcul.<span class="fu">resultat</span>);</a></code></pre></div>
<p>Essayez d’appeler plusieurs fois la méthode additionner sur une même instance et observer l’effet sur l’attribut <code>resultat</code>.</p>
<p>Faites de même sur plusieurs instances différentes (stockées dans des variables <code>troisiemeCalcul</code>, <code>quatriemeCalcul</code>, ou <code>calcul3</code>, <code>calcul4</code>, <code>calcul5</code>, etc).</p>
<p>Que constatez-vous ? Qu’en déduisez-vous ?</p>
<p>Une piste: est-ce que les attributs <code>resultat</code> des différentes instances ont la même valeur ? Quel est l’intérêt de ceci ?</p>
<h4 id="utilisation-du-débogueur-eclipse">Utilisation du débogueur Eclipse</h4>
<p>Reprenez chacun des codes précédents et lancez-le en utilisant le déboggueur Eclipse</p>
<p>Ajoutez un point d’arrêt sur la première ligne de votre méthode <code>calculer</code> et relancez le débogueur.</p>
<p>Visualisez les boutons <code>Step into</code>, <code>Step over</code> et <code>Step return</code>.</p>
<ul>
<li>À quoi peuvent-ils servir ?</li>
<li>Expérimentez et observez</li>
</ul>
<p>Visualisez la zone <code>Variables</code> (en haut à droite)</p>
<ul>
<li>Observez ce qui y est affiché</li>
<li>Dépliez l’arborescence qui y est affichée</li>
</ul>
<h3 id="lhéritage">L’héritage</h3>
<p>Une des particularité de la POO est qu’une classe peut hériter d’une autre classe. Cela a plusieurs avantages, notamment celui de permettre la réutilisation de code déjà écrit.</p>
<p>Ainsi, une classe peut hériter des comportements (méthodes) et données (attributs) d’une classe parente.</p>
<h4 id="création-dune-classe-parente">Création d’une classe parente</h4>
<p>Nous allons observer cela en modifiant le programme réalisé précédemment. Pour cela, nous allons créer une classe <code>Calcul</code> qui contiendra un attribut <code>resultat</code>. Cet attribut ne sera pas déclaré une seconde fois dans les classes qui en héritent.</p>
<p>Fichier <code>Calcul.java</code> :</p>
<div class="sourceCode" id="cb13"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb13-1" data-line-number="1"><span class="kw">package</span><span class="im"> com.example.java;</span></a>
<a class="sourceLine" id="cb13-2" data-line-number="2"></a>
<a class="sourceLine" id="cb13-3" data-line-number="3"><span class="kw">public</span> <span class="kw">class</span> Calcul {</a>
<a class="sourceLine" id="cb13-4" data-line-number="4">    <span class="dt">int</span> resultat ;</a>
<a class="sourceLine" id="cb13-5" data-line-number="5">}</a></code></pre></div>
<h4 id="création-dune-classe-fille">Création d’une classe fille</h4>
<p>Fichier <code>Multiplication.java</code> :</p>
<div class="sourceCode" id="cb14"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb14-1" data-line-number="1"><span class="kw">package</span><span class="im"> com.example.java;</span></a>
<a class="sourceLine" id="cb14-2" data-line-number="2"></a>
<a class="sourceLine" id="cb14-3" data-line-number="3"><span class="kw">public</span> <span class="kw">class</span> Multiplication <span class="kw">extends</span> Calcul {</a>
<a class="sourceLine" id="cb14-4" data-line-number="4">    <span class="kw">public</span> <span class="dt">void</span> <span class="fu">calculer</span>(<span class="dt">int</span> a, <span class="dt">int</span> b){</a>
<a class="sourceLine" id="cb14-5" data-line-number="5">        resultat = a * b;</a>
<a class="sourceLine" id="cb14-6" data-line-number="6">    }</a>
<a class="sourceLine" id="cb14-7" data-line-number="7">}</a></code></pre></div>
<p>En relançant le programme précédent, cela devrait continuer à fonctionner.</p>
<h4 id="le-mot-clé-extends">Le mot clé extends</h4>
<p>Nous observons l’utilisation du mot clé <code>extends</code> qui signifie que la classe <code>Multiplication</code> hérite de la classe <code>Calcul</code>.</p>
<p>On peut dire ceci:</p>
<ul>
<li><code>Calcul</code> est la classe parente de la classe <code>Multiplication</code></li>
<li><code>Multiplication</code> est une classe fille de la classe <code>Calcul</code></li>
</ul>
<p><strong>Un peu d’UML :</strong> voici un diagramme de classe qui représente cet héritage</p>
<figure>
<img src="images/Heritage-Calcul.png" alt="Héritage Calcul" /><figcaption>Héritage Calcul</figcaption>
</figure>
<p>On remarque ici que la classe <code>Calcul</code> hérite de la classe <code>Object</code>. La raison est simple: toute classe en Java hérite <strong>toujours</strong> de la classe <code>Object</code>. C’est logique, puisque tout est <em>objet</em> en Java.</p>
<hr />
<h4 id="addition-est-un-calcul">Addition est un Calcul</h4>
<p>Adapter la classe <code>Addition</code> pour correspondre au diagramme suivant:</p>
<figure>
<img src="images/Heritage-Calcul-Addition.png" alt="Héritage Calcul Addition" /><figcaption>Héritage Calcul Addition</figcaption>
</figure>
<h4 id="appel-dune-méthode-de-la-classe-parente">Appel d’une méthode de la classe parente</h4>
<p>Nous allons maintenant écrire une classe <code>Soustraction</code> qui va hériter de la classe <code>Addition</code> contenant la méthode suivante :</p>
<ul>
<li><code>calculer</code> permettant de soustraire deux nombres entiers .</li>
</ul>
<p>Il serait logique ici de dire que cette classe hérite d’<code>Addition</code> puisqu’une soustraction consiste à additionner au premier opérande l’opposé du second opérande : <code>resultat = a + (-b)</code></p>
<p>Il est possible d’appeler une méthode de la classe parente (la classe de niveau <strong>supér</strong>ieur) grâce au mot clé <code>super</code>:</p>
<div class="sourceCode" id="cb15"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb15-1" data-line-number="1"><span class="kw">super</span>.<span class="fu">calculer</span>(<span class="dv">3</span>, <span class="dv">-7</span>); <span class="co">//appel de la fonction de la classe parente</span></a></code></pre></div>
<ol type="1">
<li><strong>Ecrivez cette classe <code>Soustraction</code> et exécuter votre programme.</strong></li>
<li><strong>Dessinez le diagramme UML correspondant.</strong></li>
</ol>
<h4 id="un-peu-dabstraction">Un peu d’abstraction</h4>
<p>D’une manière générale, on peut considérer que <code>Multiplication</code>, <code>Addition</code> et <code>Soustraction</code> sont des calculs arithmétiques.</p>
<p>Ces classes ont toutes en commun une méthode nommée <code>calculer</code>. D’ailleurs, lors des appels de ces méthodes on avait toujours quelque chose de cette forme:</p>
<div class="sourceCode" id="cb16"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb16-1" data-line-number="1">uneInstanceDeCalcul.<span class="fu">calculer</span>(<span class="dv">3</span>, <span class="dv">5</span>);</a></code></pre></div>
<p>Nous pouvons déclarer cette méthode directement dans la classe <code>Calcul</code> et nous allons la déclarer comme étant abstraite. <code>Calcul</code> sera une <strong>abstraction</strong> des autres opérations.</p>
<p>Pour cela, nous allons d’abord modifier la classe <code>Calcul</code>:</p>
<div class="sourceCode" id="cb17"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb17-1" data-line-number="1"><span class="kw">public</span> <span class="kw">abstract</span> <span class="kw">class</span> Calcul {</a>
<a class="sourceLine" id="cb17-2" data-line-number="2">    <span class="dt">int</span> resultat ;</a>
<a class="sourceLine" id="cb17-3" data-line-number="3">    <span class="kw">public</span> <span class="kw">abstract</span> <span class="dt">void</span> <span class="fu">calculer</span>(<span class="dt">int</span> a, <span class="dt">int</span> b);</a>
<a class="sourceLine" id="cb17-4" data-line-number="4">}</a></code></pre></div>
<p>Puis nous allons remplacer les types des variables par le type <code>Calcul</code> dans la classe <code>Calculer</code>:</p>
<div class="sourceCode" id="cb18"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb18-1" data-line-number="1"><span class="kw">public</span> <span class="kw">class</span> Calculer {</a>
<a class="sourceLine" id="cb18-2" data-line-number="2">    <span class="kw">public</span> <span class="dt">static</span> <span class="dt">void</span> <span class="fu">main</span>(<span class="bu">String</span>[] args) {</a>
<a class="sourceLine" id="cb18-3" data-line-number="3">        Calcul premierCalcul = <span class="kw">new</span> <span class="fu">Multiplication</span>();</a>
<a class="sourceLine" id="cb18-4" data-line-number="4">    premierCalcul.<span class="fu">calculer</span>(<span class="dv">3</span>, <span class="dv">5</span>); <span class="co">// appel de méthode</span></a>
<a class="sourceLine" id="cb18-5" data-line-number="5">    <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(<span class="st">&quot;Le résultat de 3 multiplié par 5:&quot;</span>);</a>
<a class="sourceLine" id="cb18-6" data-line-number="6">    <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(premierCalcul.<span class="fu">resultat</span>);</a>
<a class="sourceLine" id="cb18-7" data-line-number="7"></a>
<a class="sourceLine" id="cb18-8" data-line-number="8">    <span class="co">//...</span></a>
<a class="sourceLine" id="cb18-9" data-line-number="9">    }</a>
<a class="sourceLine" id="cb18-10" data-line-number="10">}</a></code></pre></div>
<p>On constate ici que la compilation passe et que le programme se comporte exactement de la même manière.</p>
<p>Alors quel est l’intérêt de procéder ainsi ? <em>Essayez de remplacer l’un des constructeurs des sous-classes de <code>Calcul</code> par l’un des autres et ré-exécutez le programme pour observer les effets.</em></p>
<p>Le diagramme de classes ci-dessous représente cette classe abstraite, ajoutez-y la classe <code>Soustraction</code>:</p>
<figure>
<img src="images/Heritage-Calcul-Abstract.png" alt="Calcul abstrait" /><figcaption>Calcul abstrait</figcaption>
</figure>
<h5 id="généralisation-héritage">Généralisation, héritage</h5>
<p>Dans l’exemple précédent, on fait une généralisation: <code>Calcul</code> généralise les classes <code>Multiplication</code>, <code>Addition</code> et <code>Soustraction</code>.</p>
<p>A l’inverse, les classes <code>Multiplication</code>, <code>Addition</code> et <code>Soustraction</code> héritent de la classe <code>Calcul</code>: on dit aussi que ces classe spécialisent la classe <code>Calcul</code>. Elles sont spécialisées pour une opération donnée.</p>
<hr />
<p>Nous allons maintenant observer l’héritage dans la documentation de Java.</p>
<h4 id="découverte-de-la-documentation-javadoc">Découverte de la documentation Javadoc</h4>
<p>Ouvrez la documentation JAVA 8 qui se trouve ici : <a href="https://docs.oracle.com/javase/8/docs/api/index.html?overview-summary.html" class="uri">https://docs.oracle.com/javase/8/docs/api/index.html?overview-summary.html</a></p>
<p>Les chaînes de caractères en Java sont gérées par la classe <code>String</code>.</p>
<p>Essayez de trouver la classe <code>String</code> dans cette documentation.</p>
<p>Faites un diagramme UML représentant cette classe (avec au moins sa classe parente).</p>
<p>Toute classe Java hérite toujours de la classe Object. Cette classe contient deux méthodes intéressantes: <code>getClass()</code> et <code>toString()</code></p>
<p>Nous allons expérimenter cela dans ce qui suit.</p>
<h5 id="la-méthode-tostring">La méthode toString()</h5>
<p>Nous allons partir de notre programme <code>Hello World</code> pour lui ajouter quelques fonctionnalités.</p>
<p>Pour cela, nous allons dupliquer cette classe <strong>avec notre explorateur de fichier</strong> (sans utiliser les fonctions d’Eclipse) et en renommant le fichier <code>Exemple.java</code> (toujours dans le même répertoire).</p>
<p>Une fois cela fait, essayez de compiler et de lancer le programme. Que constatez-vous ?</p>
<p>Vous allez modifier le <code>main(String[])</code> en remplaçant le <code>system.out.println</code> comme suit:</p>
<div class="sourceCode" id="cb19"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb19-1" data-line-number="1"><span class="kw">public</span> <span class="dt">static</span> <span class="dt">void</span> <span class="fu">main</span>(<span class="bu">String</span>[] args) {</a>
<a class="sourceLine" id="cb19-2" data-line-number="2">    <span class="bu">Object</span> instance = <span class="kw">new</span> <span class="fu">Exemple</span>();</a>
<a class="sourceLine" id="cb19-3" data-line-number="3">    <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(instance); <span class="co">// Affiche</span></a>
<a class="sourceLine" id="cb19-4" data-line-number="4">}</a></code></pre></div>
<p>Lancez le programme (en sélectionnant la classe <code>Exemple</code> comme classe à exécuter). Que constatez-vous ?</p>
<p>Maintenant, vous allez modifier la classe en ajoutant une méthode nommée <code>toString()</code> :</p>
<div class="sourceCode" id="cb20"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb20-1" data-line-number="1">  <span class="kw">public</span> <span class="bu">String</span> <span class="fu">toString</span>(){</a>
<a class="sourceLine" id="cb20-2" data-line-number="2">    <span class="kw">return</span> <span class="st">&quot;Je suis Exemple:&quot;</span> + <span class="kw">super</span>.<span class="fu">toString</span>();</a>
<a class="sourceLine" id="cb20-3" data-line-number="3">  }</a></code></pre></div>
<p>Dans cet exemple, nous venons de concaténer deux chaînes de caractères. C’est l’opérateur <code>+</code> qui permet cela : l’instruction <code>&quot;ab&quot; + &quot;cd&quot;</code> renvoie la valeur <code>&quot;abcd&quot;</code>.</p>
<p>Relancez le programme. Que constatez-vous ?</p>
<p>À nouveau, vous allez modifier la classe en modifiant la méthode <code>toString()</code> :</p>
<div class="sourceCode" id="cb21"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb21-1" data-line-number="1">  <span class="kw">public</span> <span class="bu">String</span> <span class="fu">toString</span>(){</a>
<a class="sourceLine" id="cb21-2" data-line-number="2">    <span class="kw">return</span> <span class="st">&quot;Je suis Exemple (&quot;</span> + <span class="fu">getClass</span>() +<span class="st">&quot;  ):&quot;</span>+ <span class="kw">super</span>.<span class="fu">toString</span>();</a>
<a class="sourceLine" id="cb21-3" data-line-number="3">  }</a></code></pre></div>
<p>Relancez le programme. Que constatez-vous ?</p>
<p>Avez-vous des questions ? A quoi sert la méthode <code>toString()</code> ?</p>
<h5 id="un-peu-duml">Un peu d’UML</h5>
<p>Faites un diagramme UML représentant cette classe <code>Exemple</code> ainsi que la classe <code>Object</code>. Représentez également la classe <code>String</code> sur ce diagramme</p>
<hr />
<h2 id="représentation-textuelle-dune-personne">Représentation textuelle d’une Personne</h2>
<p>Nous allons définir une classe personne comme suit:</p>
<div class="sourceCode" id="cb22"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb22-1" data-line-number="1"><span class="kw">public</span> <span class="kw">class</span> Personne {</a>
<a class="sourceLine" id="cb22-2" data-line-number="2">    <span class="bu">String</span> nom;</a>
<a class="sourceLine" id="cb22-3" data-line-number="3">    <span class="bu">String</span> prenom;</a>
<a class="sourceLine" id="cb22-4" data-line-number="4">    <span class="bu">String</span> dateNaissance;</a>
<a class="sourceLine" id="cb22-5" data-line-number="5">    <span class="bu">String</span> adresseMail;</a>
<a class="sourceLine" id="cb22-6" data-line-number="6">    <span class="bu">String</span> telephone;</a>
<a class="sourceLine" id="cb22-7" data-line-number="7"></a>
<a class="sourceLine" id="cb22-8" data-line-number="8">    <span class="kw">public</span> <span class="dt">static</span> <span class="dt">void</span> <span class="fu">main</span>(<span class="bu">String</span>[] args) {</a>
<a class="sourceLine" id="cb22-9" data-line-number="9">        Personne utilisateur = <span class="kw">new</span> <span class="fu">Personne</span>();</a>
<a class="sourceLine" id="cb22-10" data-line-number="10"></a>
<a class="sourceLine" id="cb22-11" data-line-number="11">        utilisateur.<span class="fu">nom</span>           = <span class="st">&quot;McEnroe&quot;</span>;</a>
<a class="sourceLine" id="cb22-12" data-line-number="12">        utilisateur.<span class="fu">prenom</span>        = <span class="st">&quot;John&quot;</span>;</a>
<a class="sourceLine" id="cb22-13" data-line-number="13">        utilisateur.<span class="fu">dateNaissance</span> = <span class="st">&quot;10/10/1960&quot;</span>;</a>
<a class="sourceLine" id="cb22-14" data-line-number="14">        utilisateur.<span class="fu">adresseMail</span>   = <span class="st">&quot;johnmcenroe@usa.tennis.com&quot;</span>;</a>
<a class="sourceLine" id="cb22-15" data-line-number="15">        utilisateur.<span class="fu">telephone</span>     = <span class="st">&quot;+001 203 204 205&quot;</span>;</a>
<a class="sourceLine" id="cb22-16" data-line-number="16"></a>
<a class="sourceLine" id="cb22-17" data-line-number="17">        <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(utilisateur.<span class="fu">nom</span>);</a>
<a class="sourceLine" id="cb22-18" data-line-number="18">        <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(utilisateur.<span class="fu">prenom</span>);</a>
<a class="sourceLine" id="cb22-19" data-line-number="19">        <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(utilisateur);</a>
<a class="sourceLine" id="cb22-20" data-line-number="20">    }</a>
<a class="sourceLine" id="cb22-21" data-line-number="21">}</a></code></pre></div>
<p>Exécutez ce programme. Que constatez-vous ?</p>
<p>Les attributs de cette classe sont:</p>
<ul>
<li>nom</li>
<li>prenom</li>
<li>dateNaissance</li>
<li>adresseMail</li>
<li>telephone</li>
</ul>
<p>Aux attributs de cette classe, on va pouvoir rajouter des méthodes:</p>
<div class="sourceCode" id="cb23"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb23-1" data-line-number="1"><span class="kw">public</span> <span class="kw">class</span> Personne {</a>
<a class="sourceLine" id="cb23-2" data-line-number="2">    <span class="bu">String</span> nom;</a>
<a class="sourceLine" id="cb23-3" data-line-number="3">    <span class="bu">String</span> prenom;</a>
<a class="sourceLine" id="cb23-4" data-line-number="4">    <span class="bu">String</span> dateNaissance;</a>
<a class="sourceLine" id="cb23-5" data-line-number="5">    <span class="bu">String</span> adresseMail;</a>
<a class="sourceLine" id="cb23-6" data-line-number="6">    <span class="bu">String</span> telephone;</a>
<a class="sourceLine" id="cb23-7" data-line-number="7"></a>
<a class="sourceLine" id="cb23-8" data-line-number="8">    <span class="kw">public</span> <span class="dt">static</span> <span class="dt">void</span> <span class="fu">main</span>(<span class="bu">String</span>[] args) {</a>
<a class="sourceLine" id="cb23-9" data-line-number="9">        Personne utilisateur = <span class="kw">new</span> <span class="fu">Personne</span>();</a>
<a class="sourceLine" id="cb23-10" data-line-number="10"></a>
<a class="sourceLine" id="cb23-11" data-line-number="11">        utilisateur.<span class="fu">nom</span>           = <span class="st">&quot;McEnroe&quot;</span>;</a>
<a class="sourceLine" id="cb23-12" data-line-number="12">        utilisateur.<span class="fu">prenom</span>        = <span class="st">&quot;John&quot;</span>;</a>
<a class="sourceLine" id="cb23-13" data-line-number="13">        utilisateur.<span class="fu">dateNaissance</span> = <span class="st">&quot;10/10/1960&quot;</span>;</a>
<a class="sourceLine" id="cb23-14" data-line-number="14">        utilisateur.<span class="fu">adresseMail</span>   = <span class="st">&quot;johnmcenroe@usa.tennis.com&quot;</span>;</a>
<a class="sourceLine" id="cb23-15" data-line-number="15">        utilisateur.<span class="fu">telephone</span>     = <span class="st">&quot;+001 203 204 205&quot;</span>;</a>
<a class="sourceLine" id="cb23-16" data-line-number="16"></a>
<a class="sourceLine" id="cb23-17" data-line-number="17">        <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(utilisateur.<span class="fu">nom</span>);</a>
<a class="sourceLine" id="cb23-18" data-line-number="18">        <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(utilisateur.<span class="fu">prenom</span>);</a>
<a class="sourceLine" id="cb23-19" data-line-number="19">        <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(utilisateur);</a>
<a class="sourceLine" id="cb23-20" data-line-number="20">    }</a>
<a class="sourceLine" id="cb23-21" data-line-number="21">  <span class="kw">public</span> <span class="bu">String</span> <span class="fu">getNomPrenom</span>(){</a>
<a class="sourceLine" id="cb23-22" data-line-number="22">    <span class="kw">return</span> nom+<span class="st">&quot; &quot;</span>+prenom; <span class="co">//Concaténation des chaines nom, &quot; &quot; et prenom</span></a>
<a class="sourceLine" id="cb23-23" data-line-number="23">  }</a>
<a class="sourceLine" id="cb23-24" data-line-number="24"></a>
<a class="sourceLine" id="cb23-25" data-line-number="25">  <span class="kw">public</span> <span class="bu">String</span> <span class="fu">getPrenomNom</span>(){</a>
<a class="sourceLine" id="cb23-26" data-line-number="26">    <span class="kw">return</span> prenom+<span class="st">&quot; &quot;</span>+nom;</a>
<a class="sourceLine" id="cb23-27" data-line-number="27">  }</a>
<a class="sourceLine" id="cb23-28" data-line-number="28">}</a></code></pre></div>
<p>Ces méthodes sont des méthodes d’instance: elles sont liées à un exemplaire de la classe Personne. On peut les utiliser en ajoutant à la fin de la méthode <code>main(String[])</code> les lignes suivantes:</p>
<div class="sourceCode" id="cb24"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb24-1" data-line-number="1"><span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(utilisateur.<span class="fu">getNomPrenom</span>());</a>
<a class="sourceLine" id="cb24-2" data-line-number="2"><span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(utilisateur.<span class="fu">getPrenomNom</span>());</a></code></pre></div>
<p>Que constatez-vous ?</p>
<p>Nous allons maintenant modifier l’affichage obtenu avec la ligne suivante du <code>main(String[])</code>:</p>
<div class="sourceCode" id="cb25"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb25-1" data-line-number="1"><span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(utilisateur); <span class="co">// Dépend de la méthode toString()</span></a></code></pre></div>
<p>Pour cela, nous surchargeons la méthode toString qui était déjà définie dans la classe Object:</p>
<div class="sourceCode" id="cb26"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb26-1" data-line-number="1"><span class="kw">public</span> <span class="bu">String</span> <span class="fu">toString</span>(){</a>
<a class="sourceLine" id="cb26-2" data-line-number="2">  <span class="kw">return</span> nom+<span class="st">&quot; &quot;</span>+prenom+<span class="st">&quot; &quot;</span>+dateNaissance+<span class="st">&quot; &quot;</span></a>
<a class="sourceLine" id="cb26-3" data-line-number="3">      +adresseMail+<span class="st">&quot; &quot;</span>+telephone;</a>
<a class="sourceLine" id="cb26-4" data-line-number="4">}</a></code></pre></div>
<p>Que constatez-vous ?</p>
<h3 id="représentation-textuelle-dun-calcul">Représentation textuelle d’un calcul</h3>
<p>Vous allez maintenant reprendre les classes <code>Calcul</code> et ses sous-classes. Modifiez la méthode toString() de cette classe pour que le code suivant:</p>
<div class="sourceCode" id="cb27"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb27-1" data-line-number="1">Calcul calcul = <span class="kw">new</span> <span class="fu">Multiplication</span>();</a>
<a class="sourceLine" id="cb27-2" data-line-number="2">calcul.<span class="fu">calculer</span>(<span class="dv">4</span>,<span class="dv">8</span>);</a>
<a class="sourceLine" id="cb27-3" data-line-number="3"><span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(calcul);</a></code></pre></div>
<p>Produise <strong>exactement</strong> la sortie suivante une fois exécutée:</p>
<pre><code>Le résultat de l&#39;opération Multiplication de 4 et 8 donne 32.</code></pre>
<p>Vous avez la possibilité de rajouter de nouveaux attributs à vos classes afin de stocker (par exemple) les opérandes ou toute information utile.</p>
<h2 id="manipulation-de-chaînes-de-caractères">Manipulation de chaînes de caractères</h2>
<p>Dans la classe <code>Personne</code>, nous avons utilisé des chaînes de caractères avec l’opérateur <code>+</code> : nous avons concaténé des chaînes de caractères entre elles.</p>
<p>Nous allons utiliser ici la classe <code>String</code> afin d’en découvrir quelques aspects importants.</p>
<h3 id="quelques-expériences-étonnantes">Quelques expériences étonnantes</h3>
<p>Exécuter le programme suivant:</p>
<div class="sourceCode" id="cb29"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb29-1" data-line-number="1"></a>
<a class="sourceLine" id="cb29-2" data-line-number="2"><span class="kw">public</span> <span class="kw">class</span> ExerciceChaine {</a>
<a class="sourceLine" id="cb29-3" data-line-number="3">    <span class="kw">public</span> <span class="dt">static</span> <span class="dt">void</span> <span class="fu">main</span>(<span class="bu">String</span>[] args) {</a>
<a class="sourceLine" id="cb29-4" data-line-number="4">        <span class="bu">String</span> uneChaine = <span class="st">&quot;Bonjour&quot;</span> ;</a>
<a class="sourceLine" id="cb29-5" data-line-number="5">        <span class="bu">String</span> autreChaine = <span class="st">&quot;Bonjour&quot;</span> ;</a>
<a class="sourceLine" id="cb29-6" data-line-number="6"></a>
<a class="sourceLine" id="cb29-7" data-line-number="7">        ExerciceChaine ec = <span class="kw">new</span> <span class="fu">ExerciceChaine</span>();</a>
<a class="sourceLine" id="cb29-8" data-line-number="8">        <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(<span class="st">&quot;-- Deux chaines identiques&quot;</span>);</a>
<a class="sourceLine" id="cb29-9" data-line-number="9">        ec.<span class="fu">testChaines</span>(uneChaine, autreChaine);</a>
<a class="sourceLine" id="cb29-10" data-line-number="10"></a>
<a class="sourceLine" id="cb29-11" data-line-number="11">        <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(<span class="st">&quot;-- Une nouvelle instance&quot;</span>);</a>
<a class="sourceLine" id="cb29-12" data-line-number="12">        autreChaine = <span class="kw">new</span> <span class="bu">String</span>(<span class="st">&quot;Bonjour&quot;</span>);</a>
<a class="sourceLine" id="cb29-13" data-line-number="13">        ec.<span class="fu">testChaines</span>(uneChaine, autreChaine);</a>
<a class="sourceLine" id="cb29-14" data-line-number="14"></a>
<a class="sourceLine" id="cb29-15" data-line-number="15">        <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(<span class="st">&quot;-- Une concaténation simple&quot;</span>);</a>
<a class="sourceLine" id="cb29-16" data-line-number="16">        autreChaine = <span class="st">&quot;Bon&quot;</span> + <span class="st">&quot;jour&quot;</span> ;</a>
<a class="sourceLine" id="cb29-17" data-line-number="17">        ec.<span class="fu">testChaines</span>(uneChaine, autreChaine);</a>
<a class="sourceLine" id="cb29-18" data-line-number="18"></a>
<a class="sourceLine" id="cb29-19" data-line-number="19">        <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(<span class="st">&quot;-- Une concaténation avec des variables différentes&quot;</span>);</a>
<a class="sourceLine" id="cb29-20" data-line-number="20">        autreChaine = <span class="st">&quot;Bon&quot;</span> ;</a>
<a class="sourceLine" id="cb29-21" data-line-number="21">        <span class="bu">String</span> troisiemeChaine = <span class="st">&quot;jour&quot;</span>;</a>
<a class="sourceLine" id="cb29-22" data-line-number="22">        autreChaine = autreChaine + troisiemeChaine;</a>
<a class="sourceLine" id="cb29-23" data-line-number="23">        ec.<span class="fu">testChaines</span>(uneChaine, autreChaine);</a>
<a class="sourceLine" id="cb29-24" data-line-number="24">    }</a>
<a class="sourceLine" id="cb29-25" data-line-number="25">    <span class="kw">public</span> <span class="dt">void</span> <span class="fu">testChaines</span>(<span class="bu">String</span> a, <span class="bu">String</span> b){</a>
<a class="sourceLine" id="cb29-26" data-line-number="26">        <span class="kw">if</span>(a == b){</a>
<a class="sourceLine" id="cb29-27" data-line-number="27">            <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(<span class="st">&quot;Les chaînes &#39;&quot;</span>+ a + <span class="st">&quot;&#39; et &#39;&quot;</span>+b+ <span class="st">&quot;&#39; sont les mêmes&quot;);</span></a>
<a class="sourceLine" id="cb29-28" data-line-number="28">        }</a>
<a class="sourceLine" id="cb29-29" data-line-number="29">        <span class="kw">else</span>{</a>
<a class="sourceLine" id="cb29-30" data-line-number="30">            <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(<span class="st">&quot;Les chaînes &#39;&quot;</span>+ a + <span class="st">&quot;&#39; et &#39;&quot;</span>+b+ <span class="st">&quot;&#39; sont différentes&quot;</span>);</a>
<a class="sourceLine" id="cb29-31" data-line-number="31">        }</a>
<a class="sourceLine" id="cb29-32" data-line-number="32">    }</a>
<a class="sourceLine" id="cb29-33" data-line-number="33">}</a></code></pre></div>
<p>Remplacez la méthode <code>testChaines(String, String)</code> par la suivante:</p>
<div class="sourceCode" id="cb30"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb30-1" data-line-number="1"><span class="kw">public</span> <span class="dt">void</span> <span class="fu">testChaines</span>(<span class="bu">String</span> a, <span class="bu">String</span> b){</a>
<a class="sourceLine" id="cb30-2" data-line-number="2">  <span class="kw">if</span>(a.<span class="fu">equals</span>(b)){</a>
<a class="sourceLine" id="cb30-3" data-line-number="3">    <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(<span class="st">&quot;Les chaînes &#39;&quot;</span>+ a + <span class="st">&quot;&#39; et &#39;&quot;</span>+b+ <span class="st">&quot;&#39; sont les mêmes&quot;);</span></a>
<a class="sourceLine" id="cb30-4" data-line-number="4">  }</a>
<a class="sourceLine" id="cb30-5" data-line-number="5">  <span class="kw">else</span>{</a>
<a class="sourceLine" id="cb30-6" data-line-number="6">    <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(<span class="st">&quot;Les chaînes &#39;&quot;</span>+ a + <span class="st">&quot;&#39; et &#39;&quot;</span>+b+ <span class="st">&quot;&#39; sont différentes&quot;</span>);</a>
<a class="sourceLine" id="cb30-7" data-line-number="7">  }</a>
<a class="sourceLine" id="cb30-8" data-line-number="8">}</a></code></pre></div>
<p>Que constatez-vous ?</p>
<p>Allez voir dans la Javadoc à quoi correspond la méthode <code>equals(Object)</code>.</p>
<p>Pourquoi est-elle utile ?</p>
<h3 id="quelques-méthodes-pour-utiliser-les-string">Quelques méthodes pour utiliser les String</h3>
<p>Exécutez le programme suivant:</p>
<div class="sourceCode" id="cb31"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb31-1" data-line-number="1"><span class="kw">public</span> <span class="dt">static</span> <span class="dt">void</span> <span class="fu">main</span>(<span class="bu">String</span>[] args) {</a>
<a class="sourceLine" id="cb31-2" data-line-number="2">  <span class="bu">String</span> chaine = <span class="st">&quot;Quelques caractères&quot;</span>;</a>
<a class="sourceLine" id="cb31-3" data-line-number="3"></a>
<a class="sourceLine" id="cb31-4" data-line-number="4">  <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(chaine.<span class="fu">length</span>());</a>
<a class="sourceLine" id="cb31-5" data-line-number="5">  <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(chaine.<span class="fu">substring</span>(<span class="dv">2</span>));</a>
<a class="sourceLine" id="cb31-6" data-line-number="6">  <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(chaine.<span class="fu">substring</span>(<span class="dv">5</span>,<span class="dv">10</span>));</a>
<a class="sourceLine" id="cb31-7" data-line-number="7">  <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(chaine.<span class="fu">startsWith</span>(<span class="st">&quot;Que&quot;</span>));</a>
<a class="sourceLine" id="cb31-8" data-line-number="8">  <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(chaine.<span class="fu">startsWith</span>(<span class="st">&quot;que&quot;</span>));</a>
<a class="sourceLine" id="cb31-9" data-line-number="9">  <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(chaine.<span class="fu">endsWith</span>(<span class="st">&quot;res&quot;</span>));</a>
<a class="sourceLine" id="cb31-10" data-line-number="10">  <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(chaine.<span class="fu">endsWith</span>(<span class="st">&quot;re&quot;</span>));</a>
<a class="sourceLine" id="cb31-11" data-line-number="11">  <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(chaine.<span class="fu">indexOf</span>(<span class="st">&quot;ra&quot;</span>));</a>
<a class="sourceLine" id="cb31-12" data-line-number="12">  <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(chaine.<span class="fu">toLowerCase</span>());</a>
<a class="sourceLine" id="cb31-13" data-line-number="13">  <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(chaine.<span class="fu">toUpperCase</span>());</a>
<a class="sourceLine" id="cb31-14" data-line-number="14">}</a></code></pre></div>
<p>Aidez-vous de la Javadoc pour comprendre ce que font chacune de ces méthodes.</p>
<p>En utilisant la chaîne &quot; Je suis une chaîne moi aussi &quot; (attention aux espaces en début et fin de chaîne), testez les effets des méthodes suivantes:</p>
<ul>
<li><code>lastIndexOf(String)</code></li>
<li><code>trim()</code></li>
<li><code>toString()</code></li>
</ul>
<p>Que constatez-vous ? Est-ce logique ?</p>
<h3 id="parcours-dune-chaîne-et-boucles">Parcours d’une chaîne et boucles</h3>
<p>Nous allons utiliser une boucle simple pour récupérer chaque caractère d’une chaîne.</p>
<div class="sourceCode" id="cb32"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb32-1" data-line-number="1"><span class="kw">for</span> (<span class="dt">int</span> i = <span class="dv">0</span> ; i &lt; chaine.<span class="fu">length</span>(); i++) {</a>
<a class="sourceLine" id="cb32-2" data-line-number="2">  <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(chaine.<span class="fu">charAt</span>(i));</a>
<a class="sourceLine" id="cb32-3" data-line-number="3">}</a></code></pre></div>
<p>Analysez le code ci-dessus et posez des questions si vous ne le comprenez-pas.</p>
<h4 id="exercice-palindrome">Exercice: palindrome</h4>
<p>Ecrivez un programme qui détermine si une chaîne entrée au clavier est un palindrome (un mot qui se lit dans les deux sens).</p>
<p><strong>Pour récupérer des chaînes de caractères entrés par un utilisateur voir l’annexe <code>RecuperationDeDonneesDansLaConsole</code></strong></p>
<h2 id="créer-des-objets">Créer des objets</h2>
<p>La création d’objet en Java se fait avec le mot clef <code>new</code>.</p>
<p>L’opération effectuée avec <code>new</code> est appelée une instantiation: on crée une instance (c’est-à-dire un “exemplaire”) d’une classe.</p>
<p>Cette instance est un exemplaire indépendant des autres objets de cette classe.</p>
<h3 id="création-dune-nouvelle-classe">Création d’une nouvelle classe</h3>
<p>Vous allez implémenter une classe nommée <code>Fleur</code> dans le paquet <code>com.example.java.nature</code></p>
<p>Cette classe se fera sur le modèle suivant:</p>
<figure>
<img src="images/Fleur.png" alt="Diagramme de classe: Fleur" /><figcaption>Diagramme de classe: Fleur</figcaption>
</figure>
<p>Implémentez cette classe de sorte que <code>toString()</code> renvoie une valeur ressemblant à <code>nomDeLaFleur(3)</code> (avec <code>nom = &quot;nomDeLaFleur&quot;</code> et <code>identifiant = 3</code></p>
<p>Essayez d’instancier cette classe à partir de la méthode <code>main(String[])</code> de <code>Exemple</code> et d’afficher cette instance avec un <code>System.out.println(String)</code>.</p>
<p>Que constatez-vous ?</p>
<p>Est-on limité par quelque chose ici ?</p>
<h4 id="constructeur">Constructeur</h4>
<p>Pour pouvoir créer cette classe, il existe un constructeur par défaut. Sauf qu’il ne permet pas de modifier les valeurs des attributs.</p>
<p>Créer un nouveau constructeur sur le modèle suivant:</p>
<div class="sourceCode" id="cb33"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb33-1" data-line-number="1"><span class="kw">public</span> <span class="fu">Fleur</span>(<span class="bu">String</span> nom, <span class="dt">int</span> identifiant){</a>
<a class="sourceLine" id="cb33-2" data-line-number="2">  <span class="kw">this</span>.<span class="fu">nom</span> = nom;</a>
<a class="sourceLine" id="cb33-3" data-line-number="3">  <span class="kw">this</span>.<span class="fu">identifiant</span> = identifiant;</a>
<a class="sourceLine" id="cb33-4" data-line-number="4">}</a></code></pre></div>
<p>Essayez d’utiliser ce constructeur et d’afficher l’instance depuis la méthode <code>main(String[])</code></p>
<p>Créez ainsi plusieurs instances de <code>Fleur</code> et affichez-les.</p>
</body>
</html>