EISTI-ING1-GI
/
Java-2017-2018


			
				
					
						
						
							123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885
							<!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>Structures de contrôles</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="pandoc.css">
  <!--[if lt IE 9]>
    <script src="//cdnjs.cloudflare.com/ajax/libs/html5shiv/3.7.3/html5shiv-printshiv.min.js"></script>
  <![endif]-->
</head>
<body>
<div class="doctitle">Structures de contrôles</div>
<nav id="TOC">
<ul>
<li><a href="#introduction">Introduction</a></li>
<li><a href="#environnement-détude">Environnement d’étude</a><ul>
<li><a href="#création-et-configuration-du-projet">Création et configuration du projet</a></li>
<li><a href="#création-du-paquet">Création du paquet</a></li>
<li><a href="#remarque-importante">Remarque importante</a></li>
<li><a href="#organisation-des-tests-unitaires">Organisation des tests unitaires</a></li>
<li><a href="#classe-abstraite-controle">Classe abstraite Controle</a><ul>
<li><a href="#sous-classe-de-contrôle">Sous-classe de contrôle</a></li>
<li><a href="#comparaison-valeur-renvoyée-attendue">Comparaison valeur renvoyée / attendue</a></li>
<li><a href="#assertion">Assertion</a></li>
<li><a href="#initialisation-du-test">Initialisation du test</a></li>
</ul></li>
<li><a href="#code-source-des-tests">Code source des tests</a></li>
</ul></li>
<li><a href="#structures-de-contrôles">Structures de contrôles</a><ul>
<li><a href="#branchement">Branchement</a><ul>
<li><a href="#if">if</a></li>
<li><a href="#if-else">if-else</a></li>
<li><a href="#switch-case">switch-case</a></li>
<li><a href="#opérateur-ternaire">Opérateur ternaire</a></li>
</ul></li>
<li><a href="#boucles">Boucles</a><ul>
<li><a href="#for">for</a></li>
<li><a href="#while-do-while">while / do-while</a></li>
</ul></li>
<li><a href="#contrôle-des-boucles">Contrôle des boucles</a><ul>
<li><a href="#break">break</a></li>
<li><a href="#continue">continue</a></li>
</ul></li>
</ul></li>
<li><a href="#enum">Enum</a><ul>
<li><a href="#pourquoi-les-enum">Pourquoi les Enum</a><ul>
<li><a href="#les-constantes-avant-les-enum">Les constantes (avant les Enum)</a></li>
<li><a href="#définition-des-enum">Définition des Enum</a></li>
<li><a href="#enum-exemple-de-déclaration">Enum: exemple de déclaration</a></li>
<li><a href="#méthodes-statiques-dans-les-enum">Méthodes statiques dans les Enum</a></li>
</ul></li>
<li><a href="#enum-comme-des-instances">Enum comme des instances</a></li>
<li><a href="#application-nombre-de-jours-dans-le-mois">Application : nombre de jours dans le mois</a></li>
</ul></li>
<li><a href="#exercices">Exercices</a><ul>
<li><a href="#gestion-dune-liste-dentiers">Gestion d’une liste d’entiers</a></li>
</ul></li>
</ul>
</nav>
<h1 id="introduction">Introduction</h1>
<p>Cette section vous propose de réaliser différents programmes pour aborder les structures de contrôles.</p>
<p>Les concepts abordés ici sont:</p>
<ul>
<li><code>if/else</code></li>
<li><code>switch/case</code></li>
<li>boucles</li>
<li>Enum</li>
</ul>
<p>Nous allons également utiliser les tests unitaires pour tester nos programmes en utilisant la librairie <strong>JUnit4</strong>.</p>
<h1 id="environnement-détude">Environnement d’étude</h1>
<p>Pour étudier les structures de contrôles, nous allons utiliser un framework de tests unitaires : JUnit version 4</p>
<div class="information">
<p>Le fonctionnement de ce framework n’est pas expliqué ici. Vous devrez suivre les modèles donnés et les adapter aux demandes faites dans ce document.</p>
</div>
<h2 id="création-et-configuration-du-projet">Création et configuration du projet</h2>
<p>Créez un projet nommé <code>Controle</code>.</p>
<p>Allez dans les propriétés du projet.</p>
<p>Allez dans <code>Java Build Path &gt; Libraries &gt; Add Library...</code></p>
<p>Dans la fenêtre <code>Add library</code> sélectionnez <code>JUnit</code> puis cliquez sur <code>Next</code></p>
<p>Choisissez la version de la librairie <code>JUnit 4</code>.</p>
<p>Cliquez sur <code>Finish</code> puis <code>OK</code></p>
<p>Cliquez bouton droit sur le projet et sélectionnez <code>New &gt; Source Folder</code> :</p>
<ul>
<li>Entrez la valeur <code>test</code> dans le champ <code>Folder name</code></li>
<li>Cliquez sur <code>Finish</code></li>
</ul>
<h2 id="création-du-paquet">Création du paquet</h2>
<p>Dans chacun des répertoires sources (<code>src</code> et <code>test</code>) ajoutez un package nommé <code>com.example.controles</code></p>
<h2 id="remarque-importante">Remarque importante</h2>
<p>Pour <strong>tout</strong> le code qui suit, le paquet à utiliser sera <code>com.example.controles</code>.</p>
<div class="incremental">
<p>Deux répertoires contiendront les sources:</p>
<ul>
<li><code>src</code> (pour le code à tester)</li>
<li><code>test</code> (pour les tests)</li>
</ul>
<div class="information">
<p>L’<strong>indication sur le répertoire</strong> (<code>src</code> ou <code>test</code>) indique que la classe sera créée dans le paquet <code>com.example.controles</code> du répertoire correspondant.</p>
</div>
</div>
<h2 id="organisation-des-tests-unitaires">Organisation des tests unitaires</h2>
<p>Pour une classe à tester, on crée la classe de test correspondante:</p>
<ul>
<li><code>ControleIf</code> sera testé dans <code>TestControleIf</code></li>
<li><code>ControleIfElse</code> sera testé dans <code>TestControleIfElse</code></li>
</ul>
<div class="warning">
<p>Emplacement des fichiers</p>
<ul>
<li>Dans le répertoire <code>src</code>
<ul>
<li><code>ControleIf</code></li>
<li><code>ControleIfElse</code></li>
<li>Toutes les classes dont le nom commence par <code>Controle</code></li>
</ul></li>
<li>Dans le répertoire <code>test</code>
<ul>
<li><code>TestControleIf</code></li>
<li><code>TestControleIfElse</code></li>
<li>Toutes les classes dont le nom commence par <code>TestControle</code></li>
</ul></li>
</ul>
</div>
<h2 id="classe-abstraite-controle">Classe abstraite Controle</h2>
<p>Nous allons nous doter d’une classe abstraite qui sera facilement réutilisable pour tester notre code.</p>
<p>Créez la classe abstraite <code>Controle</code> dans le répertoire <code>src</code> en utilisant le code source 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="kw">package</span><span class="im"> com.example.controles;</span></a>
<a class="sourceLine" id="cb1-2" data-line-number="2"></a>
<a class="sourceLine" id="cb1-3" data-line-number="3"><span class="kw">public</span> <span class="kw">abstract</span> <span class="kw">class</span> Controle {</a>
<a class="sourceLine" id="cb1-4" data-line-number="4">    <span class="kw">public</span> <span class="kw">abstract</span> <span class="bu">Object</span> <span class="fu">lancer</span>(<span class="bu">String</span>[] args);</a>
<a class="sourceLine" id="cb1-5" data-line-number="5">}</a></code></pre></div>
<h3 id="sous-classe-de-contrôle">Sous-classe de contrôle</h3>
<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="kw">package</span><span class="im"> com.example.controles;</span></a>
<a class="sourceLine" id="cb2-2" data-line-number="2"></a>
<a class="sourceLine" id="cb2-3" data-line-number="3"><span class="kw">public</span> <span class="kw">class</span> ControleIf <span class="kw">extends</span> Controle {</a>
<a class="sourceLine" id="cb2-4" data-line-number="4">    <span class="kw">public</span> <span class="bu">Object</span> <span class="fu">lancer</span>(<span class="bu">String</span>[] args) {</a>
<a class="sourceLine" id="cb2-5" data-line-number="5">        <span class="bu">Object</span> returnedValue = <span class="kw">null</span>;</a>
<a class="sourceLine" id="cb2-6" data-line-number="6">        <span class="kw">if</span>(args.<span class="fu">length</span> &lt;= <span class="dv">0</span>)</a>
<a class="sourceLine" id="cb2-7" data-line-number="7">            returnedValue = <span class="kw">null</span>;</a>
<a class="sourceLine" id="cb2-8" data-line-number="8">        <span class="kw">if</span>(args.<span class="fu">length</span> &lt;= <span class="dv">1</span>)</a>
<a class="sourceLine" id="cb2-9" data-line-number="9">            returnedValue = args[<span class="dv">0</span>];</a>
<a class="sourceLine" id="cb2-10" data-line-number="10">        <span class="kw">if</span>(args.<span class="fu">length</span> == <span class="dv">2</span>)</a>
<a class="sourceLine" id="cb2-11" data-line-number="11">            returnedValue = args[<span class="dv">1</span>];</a>
<a class="sourceLine" id="cb2-12" data-line-number="12">        <span class="kw">if</span>(args.<span class="fu">length</span> &gt;= <span class="dv">3</span>)</a>
<a class="sourceLine" id="cb2-13" data-line-number="13">            returnedValue = args[<span class="dv">2</span>];</a>
<a class="sourceLine" id="cb2-14" data-line-number="14">        <span class="kw">return</span> returnedValue;</a>
<a class="sourceLine" id="cb2-15" data-line-number="15">    }</a>
<a class="sourceLine" id="cb2-16" data-line-number="16">}</a></code></pre></div>
<h3 id="comparaison-valeur-renvoyée-attendue">Comparaison valeur renvoyée / attendue</h3>
<p>Pour tester, on utilise une assertion. La méthode <code>assertEquals</code> permet de tester l’égalité de deux valeurs :</p>
<ul>
<li>une valeur de référence (la valeur que l’on s’attend à obtenir);</li>
<li>une valeur renvoyée par une méthode (la valeur que l’on teste).</li>
</ul>
<p>On n’écrit en général qu’une seule assertion par test (même s’il est possible d’en écrire plusieurs):</p>
<div class="sourceCode" id="cb3"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb3-1" data-line-number="1"><span class="at">@Test</span></a>
<a class="sourceLine" id="cb3-2" data-line-number="2"><span class="kw">public</span> <span class="dt">void</span> <span class="fu">testControleIfUneChaine</span>(){</a>
<a class="sourceLine" id="cb3-3" data-line-number="3">  <span class="fu">assertEquals</span>(<span class="st">&quot;Test une seule chaîne&quot;</span>,</a>
<a class="sourceLine" id="cb3-4" data-line-number="4">      <span class="st">&quot;Un&quot;</span>, controle.<span class="fu">lancer</span>(<span class="kw">new</span> <span class="bu">String</span>[]{<span class="st">&quot;Un&quot;</span>}));</a>
<a class="sourceLine" id="cb3-5" data-line-number="5">}</a></code></pre></div>
<div class="incremental">
<p>Toujours mettre <code>@Test</code> avant la méthode de test</p>
</div>
<div class="incremental">
<p>Utilisation d’assertion</p>
</div>
<h3 id="assertion">Assertion</h3>
<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="fu">assertEquals</span>(<span class="st">&quot;Désignation du test&quot;</span>,</a>
<a class="sourceLine" id="cb4-2" data-line-number="2">    <span class="st">&quot;Valeur attendue (String)&quot;</span>, instance.<span class="fu">renvoieValeurString</span>());</a></code></pre></div>
<div class="incremental">
<p>Pour nos travaux, uniquement une méthode qui renvoie un <code>String</code></p>
</div>
<h3 id="initialisation-du-test">Initialisation du test</h3>
<p>Création de l’objet <code>controle</code></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="kw">public</span> <span class="kw">class</span> TestControleIf {</a>
<a class="sourceLine" id="cb5-2" data-line-number="2">  <span class="kw">protected</span> Controle controle ;</a>
<a class="sourceLine" id="cb5-3" data-line-number="3">  <span class="at">@Before</span></a>
<a class="sourceLine" id="cb5-4" data-line-number="4">  <span class="kw">public</span> <span class="dt">void</span> <span class="fu">initControles</span>(){</a>
<a class="sourceLine" id="cb5-5" data-line-number="5">    controle = <span class="kw">new</span> <span class="fu">ControleIf</span>();</a>
<a class="sourceLine" id="cb5-6" data-line-number="6">  }</a>
<a class="sourceLine" id="cb5-7" data-line-number="7">  <span class="co">//...</span></a>
<a class="sourceLine" id="cb5-8" data-line-number="8">}</a></code></pre></div>
<div class="incremental">
<p><code>@Before</code> désigne la méthode pour initialiser</p>
</div>
<div class="incremental">
<p>Méthode appelée avant chaque méthode de test (marquée par <code>@Test</code>)</p>
<p>Ceci permet de trouver plus facilement quelle assertion n’a pas été respectée.</p>
<p>Il existe d’autres méthodes que <code>assertEquals</code>. Voir la Javadoc de JUnit 4 qui est disponible <a href="http://junit.org/junit4/javadoc/latest/index.html">sur cette page</a>.</p>
</div>
<h2 id="code-source-des-tests">Code source des tests</h2>
<p>Le code source des tests est déjà écrit et est disponible <a href="data/ch4-Controles-test.zip">ici</a></p>
<h1 id="structures-de-contrôles">Structures de contrôles</h1>
<p>Dans cette partie, il vous est demandé de tester et vérifier si le fonctionnement des différents codes proposés est bien celui attendu.</p>
<p>Plus d’information sur les structures de contrôles est donné <a href="https://docs.oracle.com/javase/tutorial/java/nutsandbolts/flow.html">ici</a>.</p>
<h2 id="branchement">Branchement</h2>
<h3 id="if">if</h3>
<p>Créez une classe <code>ControleIf</code> dans le répertoire <code>src</code> :</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="kw">package</span><span class="im"> com.example.controles;</span></a>
<a class="sourceLine" id="cb6-2" data-line-number="2"></a>
<a class="sourceLine" id="cb6-3" data-line-number="3"><span class="kw">public</span> <span class="kw">class</span> ControleIf <span class="kw">extends</span> Controle {</a>
<a class="sourceLine" id="cb6-4" data-line-number="4"></a>
<a class="sourceLine" id="cb6-5" data-line-number="5">    <span class="at">@Override</span></a>
<a class="sourceLine" id="cb6-6" data-line-number="6">    <span class="kw">public</span> <span class="bu">Object</span> <span class="fu">lancer</span>(<span class="bu">String</span>[] args) {</a>
<a class="sourceLine" id="cb6-7" data-line-number="7">    <span class="bu">Object</span> returnedValue = <span class="kw">null</span>;</a>
<a class="sourceLine" id="cb6-8" data-line-number="8">        <span class="kw">if</span>(args.<span class="fu">length</span> &lt;= <span class="dv">0</span>)</a>
<a class="sourceLine" id="cb6-9" data-line-number="9">            returnedValue = <span class="kw">null</span>;</a>
<a class="sourceLine" id="cb6-10" data-line-number="10">        <span class="kw">if</span>(args.<span class="fu">length</span> &lt;= <span class="dv">1</span>)</a>
<a class="sourceLine" id="cb6-11" data-line-number="11">            returnedValue = args[<span class="dv">0</span>];</a>
<a class="sourceLine" id="cb6-12" data-line-number="12">        <span class="kw">if</span>(args.<span class="fu">length</span> == <span class="dv">2</span>)</a>
<a class="sourceLine" id="cb6-13" data-line-number="13">            returnedValue = args[<span class="dv">1</span>];</a>
<a class="sourceLine" id="cb6-14" data-line-number="14">        <span class="kw">if</span>(args.<span class="fu">length</span> &gt;= <span class="dv">3</span>)</a>
<a class="sourceLine" id="cb6-15" data-line-number="15">            returnedValue = args[<span class="dv">2</span>];</a>
<a class="sourceLine" id="cb6-16" data-line-number="16">        <span class="kw">return</span> returnedValue;</a>
<a class="sourceLine" id="cb6-17" data-line-number="17">    }</a>
<a class="sourceLine" id="cb6-18" data-line-number="18">}</a></code></pre></div>
<h4 id="tester-manuellement">Tester manuellement</h4>
<p>Dans le répertoire <code>src</code>:</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="kw">package</span><span class="im"> com.example.controles;</span></a>
<a class="sourceLine" id="cb7-2" data-line-number="2"></a>
<a class="sourceLine" id="cb7-3" data-line-number="3"><span class="kw">public</span> <span class="kw">class</span> VerifierIf {</a>
<a class="sourceLine" id="cb7-4" data-line-number="4">    <span class="kw">private</span> Controle controle ;</a>
<a class="sourceLine" id="cb7-5" data-line-number="5">    <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="cb7-6" data-line-number="6">        Controle controle = <span class="kw">new</span> <span class="fu">ControleIf</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>(controle.<span class="fu">lancer</span>(<span class="kw">new</span> <span class="bu">String</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>(controle.<span class="fu">lancer</span>(<span class="kw">new</span> <span class="bu">String</span>[]{<span class="st">&quot;Un&quot;</span>}));</a>
<a class="sourceLine" id="cb7-9" data-line-number="9">        <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(controle.<span class="fu">lancer</span>(<span class="kw">new</span> <span class="bu">String</span>[]{<span class="st">&quot;Un&quot;</span>, <span class="st">&quot;Deux&quot;</span>}));</a>
<a class="sourceLine" id="cb7-10" data-line-number="10">        <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(controle.<span class="fu">lancer</span>(<span class="kw">new</span> <span class="bu">String</span>[]{<span class="st">&quot;Un&quot;</span>, <span class="st">&quot;Deux&quot;</span>, <span class="st">&quot;Trois&quot;</span>}));</a>
<a class="sourceLine" id="cb7-11" data-line-number="11">    }</a>
<a class="sourceLine" id="cb7-12" data-line-number="12">}</a></code></pre></div>
<h4 id="tester-avec-des-junit">Tester avec des JUnit</h4>
<h5 id="création-dune-classe-de-test">Création d’une classe de test</h5>
<p>Créez la classe de test <code>TestControleIf</code> dans le répertoire <code>test</code> en utilisant le code source suivant:</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.controles;</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">import</span><span class="im"> org.junit.Before;</span></a>
<a class="sourceLine" id="cb8-4" data-line-number="4"></a>
<a class="sourceLine" id="cb8-5" data-line-number="5"><span class="kw">public</span> <span class="kw">class</span> TestControleIf {</a>
<a class="sourceLine" id="cb8-6" data-line-number="6">  <span class="kw">protected</span> Controle controle ;</a>
<a class="sourceLine" id="cb8-7" data-line-number="7">    <span class="at">@Before</span></a>
<a class="sourceLine" id="cb8-8" data-line-number="8">    <span class="kw">public</span> <span class="dt">void</span> <span class="fu">initControle</span>(){</a>
<a class="sourceLine" id="cb8-9" data-line-number="9">        controle = <span class="kw">new</span> <span class="fu">ControleIf</span>();</a>
<a class="sourceLine" id="cb8-10" data-line-number="10">    }</a>
<a class="sourceLine" id="cb8-11" data-line-number="11">}</a></code></pre></div>
<p>Ajoutez les méthodes permettant de tester dans le corps de la classe <code>TestControleIf</code> (voir ci-dessous).</p>
<p>Les imports suivants seront nécessaires:</p>
<ul>
<li><code>import org.junit.Test</code></li>
<li><code>import static org.junit.Assert.assertEquals</code></li>
</ul>
<p>Une <strong>bonne pratique</strong> consiste à ne mettre qu’une seule assertion par méthode de test.</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="at">@Test</span></a>
<a class="sourceLine" id="cb9-2" data-line-number="2"><span class="kw">public</span> <span class="dt">void</span> <span class="fu">testControleIfUneChaine</span>(){</a>
<a class="sourceLine" id="cb9-3" data-line-number="3">  <span class="fu">assertEquals</span>(<span class="st">&quot;Test une seule chaîne&quot;</span>,</a>
<a class="sourceLine" id="cb9-4" data-line-number="4">      <span class="st">&quot;Un&quot;</span>, controle.<span class="fu">lancer</span>(<span class="kw">new</span> <span class="bu">String</span>[]{<span class="st">&quot;Un&quot;</span>}));</a>
<a class="sourceLine" id="cb9-5" data-line-number="5">}</a>
<a class="sourceLine" id="cb9-6" data-line-number="6"></a>
<a class="sourceLine" id="cb9-7" data-line-number="7"><span class="at">@Test</span></a>
<a class="sourceLine" id="cb9-8" data-line-number="8"><span class="kw">public</span> <span class="dt">void</span> <span class="fu">testControleIfDeuxChaine</span>(){</a>
<a class="sourceLine" id="cb9-9" data-line-number="9">  <span class="fu">assertEquals</span>(<span class="st">&quot;Test deux chaînes&quot;</span>,</a>
<a class="sourceLine" id="cb9-10" data-line-number="10">      <span class="st">&quot;Deux&quot;</span>, controle.<span class="fu">lancer</span>(<span class="kw">new</span> <span class="bu">String</span>[]{<span class="st">&quot;Un&quot;</span>, <span class="st">&quot;Deux&quot;</span>}));</a>
<a class="sourceLine" id="cb9-11" data-line-number="11">}</a></code></pre></div>
<h5 id="exécution-des-tests">Exécution des tests</h5>
<p>Lancez les tests en allant dans le menu <code>Run &gt; Run As &gt; JUnit Test</code></p>
<p>Ajoutez les cas pour les tableaux de chaînes suivants:</p>
<ul>
<li><code>{&quot;Un&quot;, &quot;Deux&quot;}</code></li>
<li><code>{&quot;Un&quot;, &quot;Deux&quot;, &quot;Trois&quot;}</code></li>
<li><code>{&quot;Un&quot;, &quot;Deux&quot;, &quot;Trois&quot;, &quot;Quatre&quot;}</code></li>
</ul>
<h4 id="modification-du-programme">Modification du programme</h4>
<p>Ajoutez la ligne suivante juste après le troisième <code>if</code>:</p>
<div class="sourceCode" id="cb10"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb10-1" data-line-number="1">  <span class="kw">if</span>(args.<span class="fu">length</span> &gt;= <span class="dv">3</span>)</a>
<a class="sourceLine" id="cb10-2" data-line-number="2">    <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(<span class="st">&quot;Bonjour&quot;</span>);</a>
<a class="sourceLine" id="cb10-3" data-line-number="3">    returnedValue = args[<span class="dv">2</span>];</a></code></pre></div>
<p>Relancez les tests. Que se passe-t-il ? Est-ce normal ?</p>
<h4 id="recommandation-utilisation-des-blocs-dinstruction">Recommandation: utilisation des blocs d’instruction</h4>
<p>Un bloc de code est une série d’instructions entre deux accolades <code>{...}</code>.</p>
<p>Bien qu’il soit parfaitement possible de n’utiliser qu’une seule instruction dans un <code>if</code> comme montré ci-dessus, il est plutôt <strong>recommandé</strong> d’utiliser des blocs de code <strong>systématiquement</strong>.</p>
<p>Il est parfaitement possible de ne mettre qu’une seule instruction dans un bloc, et c’est même <strong>recommandé</strong> dans les structures de contrôles:</p>
<div class="sourceCode" id="cb11"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb11-1" data-line-number="1"><span class="kw">if</span>(args.<span class="fu">length</span> &lt;= <span class="dv">0</span>)    {</a>
<a class="sourceLine" id="cb11-2" data-line-number="2">  returnedValue = <span class="kw">null</span>;</a>
<a class="sourceLine" id="cb11-3" data-line-number="3">}</a>
<a class="sourceLine" id="cb11-4" data-line-number="4"><span class="kw">if</span>(args.<span class="fu">length</span> &lt;= <span class="dv">1</span>){</a>
<a class="sourceLine" id="cb11-5" data-line-number="5">  returnedValue = args[<span class="dv">0</span>];</a>
<a class="sourceLine" id="cb11-6" data-line-number="6">}</a>
<a class="sourceLine" id="cb11-7" data-line-number="7"><span class="kw">if</span>(args.<span class="fu">length</span> == <span class="dv">2</span>){</a>
<a class="sourceLine" id="cb11-8" data-line-number="8">  returnedValue = args[<span class="dv">1</span>];</a>
<a class="sourceLine" id="cb11-9" data-line-number="9">}</a>
<a class="sourceLine" id="cb11-10" data-line-number="10"><span class="kw">if</span>(args.<span class="fu">length</span> &gt;= <span class="dv">3</span>){</a>
<a class="sourceLine" id="cb11-11" data-line-number="11">  <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(<span class="st">&quot;Bonjour&quot;</span>);</a>
<a class="sourceLine" id="cb11-12" data-line-number="12">  returnedValue = args[<span class="dv">2</span>];</a>
<a class="sourceLine" id="cb11-13" data-line-number="13">}</a>
<a class="sourceLine" id="cb11-14" data-line-number="14"><span class="kw">return</span> returnedValue;</a></code></pre></div>
<p>Entre le code ci-dessus et la précédente version de la classe <code>ControleIf</code> le fonctionnement est exactement le même. La <strong>seule différence</strong> est que si on ajoute une ligne en oubliant d’ajouter des accolades (ce qui arrive fréquemment), le code continue à fonctionner correctement.</p>
<div class="incremental">
<p>Outre l’aération et la lisibilité du code, cela le rend donc plus robuste en cas de modification.</p>
</div>
<h3 id="if-else">if-else</h3>
<p>L’instruction <code>else</code> s’utilise comme suit:</p>
<div class="sourceCode" id="cb12"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb12-1" data-line-number="1"><span class="kw">package</span><span class="im"> com.example.controles;</span></a>
<a class="sourceLine" id="cb12-2" data-line-number="2"></a>
<a class="sourceLine" id="cb12-3" data-line-number="3"><span class="kw">public</span> <span class="kw">class</span> ControleIfElse <span class="kw">extends</span> Controle {</a>
<a class="sourceLine" id="cb12-4" data-line-number="4">    <span class="at">@Override</span></a>
<a class="sourceLine" id="cb12-5" data-line-number="5">    <span class="kw">public</span> <span class="bu">Object</span> <span class="fu">lancer</span>(<span class="bu">String</span>[] args) {</a>
<a class="sourceLine" id="cb12-6" data-line-number="6">        <span class="bu">Object</span> returnedValue ;</a>
<a class="sourceLine" id="cb12-7" data-line-number="7">        <span class="kw">if</span> (args.<span class="fu">length</span> &gt; <span class="dv">0</span> &amp;&amp; args[<span class="dv">0</span>] != <span class="st">&quot;&quot;</span>){</a>
<a class="sourceLine" id="cb12-8" data-line-number="8">            returnedValue = args[<span class="dv">0</span>];</a>
<a class="sourceLine" id="cb12-9" data-line-number="9">        }</a>
<a class="sourceLine" id="cb12-10" data-line-number="10">        <span class="kw">else</span> {</a>
<a class="sourceLine" id="cb12-11" data-line-number="11">            returnedValue = <span class="st">&quot;N/A&quot;</span>;</a>
<a class="sourceLine" id="cb12-12" data-line-number="12">        }</a>
<a class="sourceLine" id="cb12-13" data-line-number="13">        <span class="kw">return</span> returnedValue;</a>
<a class="sourceLine" id="cb12-14" data-line-number="14">    }</a>
<a class="sourceLine" id="cb12-15" data-line-number="15">}</a></code></pre></div>
<h4 id="tester-manuellement-1">Tester manuellement</h4>
<p>Dans le répertoire <code>src</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.controles;</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> VerifierIfElse {</a>
<a class="sourceLine" id="cb13-4" data-line-number="4">    <span class="kw">private</span> Controle controle ;</a>
<a class="sourceLine" id="cb13-5" data-line-number="5">    <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="cb13-6" data-line-number="6">        Controle controle = <span class="kw">new</span> <span class="fu">ControleIfElse</span>();</a>
<a class="sourceLine" id="cb13-7" data-line-number="7">        <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(controle.<span class="fu">lancer</span>(<span class="kw">new</span> <span class="bu">String</span>[]{}));</a>
<a class="sourceLine" id="cb13-8" data-line-number="8">        <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(controle.<span class="fu">lancer</span>(<span class="kw">new</span> <span class="bu">String</span>[]{<span class="st">&quot;Un&quot;</span>}));</a>
<a class="sourceLine" id="cb13-9" data-line-number="9">        <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(controle.<span class="fu">lancer</span>(<span class="kw">new</span> <span class="bu">String</span>[]{<span class="st">&quot;Un&quot;</span>, <span class="st">&quot;Deux&quot;</span>}));</a>
<a class="sourceLine" id="cb13-10" data-line-number="10">        <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(controle.<span class="fu">lancer</span>(<span class="kw">new</span> <span class="bu">String</span>[]{<span class="st">&quot;Un&quot;</span>, <span class="st">&quot;Deux&quot;</span>, <span class="st">&quot;Trois&quot;</span>}));</a>
<a class="sourceLine" id="cb13-11" data-line-number="11">    }</a>
<a class="sourceLine" id="cb13-12" data-line-number="12">}</a></code></pre></div>
<h4 id="tester-avec-junit">Tester avec JUnit</h4>
<p>Créez la classe <code>ControleIfElse</code> et testez-la dans une méthode comme suit:</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="at">@Before</span></a>
<a class="sourceLine" id="cb14-2" data-line-number="2"><span class="kw">public</span> <span class="dt">void</span> <span class="fu">initControle</span>(){</a>
<a class="sourceLine" id="cb14-3" data-line-number="3">  controle = <span class="kw">new</span> <span class="fu">ControleIfElse</span>();</a>
<a class="sourceLine" id="cb14-4" data-line-number="4">}</a>
<a class="sourceLine" id="cb14-5" data-line-number="5"><span class="at">@Test</span></a>
<a class="sourceLine" id="cb14-6" data-line-number="6"><span class="kw">public</span> <span class="dt">void</span> <span class="fu">testControleIfElse</span>(){</a>
<a class="sourceLine" id="cb14-7" data-line-number="7">  <span class="fu">assertEquals</span>(<span class="st">&quot;Test une seule chaîne&quot;</span>,</a>
<a class="sourceLine" id="cb14-8" data-line-number="8">      <span class="st">&quot;Un&quot;</span>, controle.<span class="fu">lancer</span>(<span class="kw">new</span> <span class="bu">String</span>[]{<span class="st">&quot;Un&quot;</span>}));</a>
<a class="sourceLine" id="cb14-9" data-line-number="9">}</a></code></pre></div>
<p>Ajoutez une instruction <code>assertEquals</code> permettant de vérifier l’exécution du bloc <code>else</code> (la valeur à tester doit être <code>&quot;N/A&quot;</code>).</p>
<p>Testez au moins deux autres cas.</p>
<h3 id="switch-case">switch-case</h3>
<h4 id="les-cascades-de-if-else">Les cascades de if-else</h4>
<p>On peut critiquer le code suivant du point de vue de :</p>
<ul>
<li>sa maintenabilité</li>
<li>sa lisibilité</li>
</ul>
<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">package</span><span class="im"> com.example.controles;</span></a>
<a class="sourceLine" id="cb15-2" data-line-number="2"></a>
<a class="sourceLine" id="cb15-3" data-line-number="3"><span class="kw">public</span> <span class="kw">class</span> ControleCascadeIfElse <span class="kw">extends</span> Controle {</a>
<a class="sourceLine" id="cb15-4" data-line-number="4">  <span class="kw">public</span> <span class="bu">Object</span> <span class="fu">lancer</span>(<span class="bu">String</span>[] args) {</a>
<a class="sourceLine" id="cb15-5" data-line-number="5">    <span class="bu">String</span> returnedValue;</a>
<a class="sourceLine" id="cb15-6" data-line-number="6">    <span class="dt">int</span> valeurChoix = <span class="bu">Integer</span>.<span class="fu">parseInt</span>(args[<span class="dv">0</span>]);</a>
<a class="sourceLine" id="cb15-7" data-line-number="7">        <span class="kw">if</span>(valeurChoix == <span class="dv">1</span>){</a>
<a class="sourceLine" id="cb15-8" data-line-number="8">            returnedValue = <span class="st">&quot;Menu Préférences&quot;</span>;</a>
<a class="sourceLine" id="cb15-9" data-line-number="9">        }</a>
<a class="sourceLine" id="cb15-10" data-line-number="10">        <span class="kw">else</span> <span class="kw">if</span> (valeurChoix == <span class="dv">2</span>){</a>
<a class="sourceLine" id="cb15-11" data-line-number="11">            returnedValue = <span class="st">&quot;Menu Edition&quot;</span>;</a>
<a class="sourceLine" id="cb15-12" data-line-number="12">        }</a>
<a class="sourceLine" id="cb15-13" data-line-number="13">        <span class="kw">else</span> <span class="kw">if</span> (valeurChoix == <span class="dv">3</span>){</a>
<a class="sourceLine" id="cb15-14" data-line-number="14">            returnedValue = <span class="st">&quot;Bonjour&quot;</span>;</a>
<a class="sourceLine" id="cb15-15" data-line-number="15">        }</a>
<a class="sourceLine" id="cb15-16" data-line-number="16">        <span class="kw">else</span> <span class="kw">if</span> (valeurChoix == <span class="dv">4</span>){</a>
<a class="sourceLine" id="cb15-17" data-line-number="17">            returnedValue = <span class="st">&quot;Au revoir&quot;</span>;</a>
<a class="sourceLine" id="cb15-18" data-line-number="18">        }</a>
<a class="sourceLine" id="cb15-19" data-line-number="19">        <span class="kw">else</span> <span class="kw">if</span> (valeurChoix == <span class="dv">5</span>){</a>
<a class="sourceLine" id="cb15-20" data-line-number="20">            returnedValue = <span class="st">&quot;Sortir&quot;</span>;</a>
<a class="sourceLine" id="cb15-21" data-line-number="21">        }</a>
<a class="sourceLine" id="cb15-22" data-line-number="22">        <span class="kw">else</span> {</a>
<a class="sourceLine" id="cb15-23" data-line-number="23">            returnedValue = <span class="st">&quot;Saisir votre choix (1,2,3,4 ou 5) : &quot;</span>;</a>
<a class="sourceLine" id="cb15-24" data-line-number="24">        }</a>
<a class="sourceLine" id="cb15-25" data-line-number="25">        <span class="kw">return</span> returnedValue;</a>
<a class="sourceLine" id="cb15-26" data-line-number="26">  }</a>
<a class="sourceLine" id="cb15-27" data-line-number="27">}</a></code></pre></div>
<h5 id="tester-manuellement-2">Tester manuellement</h5>
<p>Dans le répertoire <code>src</code>, créer les deux classes suivantes:</p>
<div class="sourceCode" id="cb16"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb16-1" data-line-number="1"><span class="kw">package</span><span class="im"> com.example.controles;</span></a>
<a class="sourceLine" id="cb16-2" data-line-number="2"></a>
<a class="sourceLine" id="cb16-3" data-line-number="3"><span class="kw">public</span> <span class="kw">abstract</span> <span class="kw">class</span> VerifierDifferentsCas {</a>
<a class="sourceLine" id="cb16-4" data-line-number="4">    <span class="kw">protected</span> Controle controle ;</a>
<a class="sourceLine" id="cb16-5" data-line-number="5"></a>
<a class="sourceLine" id="cb16-6" data-line-number="6">    <span class="kw">public</span> <span class="kw">abstract</span> <span class="dt">void</span> <span class="fu">initControle</span>();</a>
<a class="sourceLine" id="cb16-7" data-line-number="7"></a>
<a class="sourceLine" id="cb16-8" data-line-number="8">    <span class="kw">public</span> <span class="dt">void</span> <span class="fu">verifier</span>(){</a>
<a class="sourceLine" id="cb16-9" data-line-number="9">        <span class="fu">initControle</span>();</a>
<a class="sourceLine" id="cb16-10" data-line-number="10">        <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(controle.<span class="fu">lancer</span>(<span class="kw">new</span> <span class="bu">String</span>[]{<span class="st">&quot;1&quot;</span>}));</a>
<a class="sourceLine" id="cb16-11" data-line-number="11">        <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(controle.<span class="fu">lancer</span>(<span class="kw">new</span> <span class="bu">String</span>[]{<span class="st">&quot;2&quot;</span>}));</a>
<a class="sourceLine" id="cb16-12" data-line-number="12">        <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(controle.<span class="fu">lancer</span>(<span class="kw">new</span> <span class="bu">String</span>[]{<span class="st">&quot;3&quot;</span>}));</a>
<a class="sourceLine" id="cb16-13" data-line-number="13">        <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(controle.<span class="fu">lancer</span>(<span class="kw">new</span> <span class="bu">String</span>[]{<span class="st">&quot;4&quot;</span>}));</a>
<a class="sourceLine" id="cb16-14" data-line-number="14">        <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(controle.<span class="fu">lancer</span>(<span class="kw">new</span> <span class="bu">String</span>[]{<span class="st">&quot;5&quot;</span>}));</a>
<a class="sourceLine" id="cb16-15" data-line-number="15">        <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(controle.<span class="fu">lancer</span>(<span class="kw">new</span> <span class="bu">String</span>[]{<span class="st">&quot;0&quot;</span>}));</a>
<a class="sourceLine" id="cb16-16" data-line-number="16">    }</a>
<a class="sourceLine" id="cb16-17" data-line-number="17">}</a></code></pre></div>
<p>Classe de vérification:</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">package</span><span class="im"> com.example.controles;</span></a>
<a class="sourceLine" id="cb17-2" data-line-number="2"></a>
<a class="sourceLine" id="cb17-3" data-line-number="3"><span class="kw">public</span> <span class="kw">class</span> VerifierCascadeIfElse <span class="kw">extends</span> VerifierDifferentsCas {</a>
<a class="sourceLine" id="cb17-4" data-line-number="4">    <span class="at">@Override</span></a>
<a class="sourceLine" id="cb17-5" data-line-number="5">    <span class="kw">public</span> <span class="dt">void</span> <span class="fu">initControle</span>() {</a>
<a class="sourceLine" id="cb17-6" data-line-number="6">        controle = <span class="kw">new</span> <span class="fu">ControleCascadeIfElse</span>();</a>
<a class="sourceLine" id="cb17-7" data-line-number="7">    }</a>
<a class="sourceLine" id="cb17-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="cb17-9" data-line-number="9">        VerifierDifferentsCas verificateur = <span class="kw">new</span> <span class="fu">VerifierCascadeIfElse</span>();</a>
<a class="sourceLine" id="cb17-10" data-line-number="10">        verificateur.<span class="fu">verifier</span>();</a>
<a class="sourceLine" id="cb17-11" data-line-number="11">    }</a>
<a class="sourceLine" id="cb17-12" data-line-number="12">}</a></code></pre></div>
<h5 id="test-avec-junit">Test avec JUnit</h5>
<p>Ce code fonctionne et peut être testé avec les tests unitaires suivants:</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">package</span><span class="im"> com.example.controles;</span></a>
<a class="sourceLine" id="cb18-2" data-line-number="2"></a>
<a class="sourceLine" id="cb18-3" data-line-number="3"><span class="kw">import</span><span class="im"> org.junit.Test;</span></a>
<a class="sourceLine" id="cb18-4" data-line-number="4"><span class="kw">import</span><span class="im"> org.junit.Before;</span></a>
<a class="sourceLine" id="cb18-5" data-line-number="5"><span class="kw">import static</span><span class="im"> org.junit.Assert.assertEquals ;</span></a>
<a class="sourceLine" id="cb18-6" data-line-number="6"></a>
<a class="sourceLine" id="cb18-7" data-line-number="7"><span class="kw">public</span> <span class="kw">abstract</span> <span class="kw">class</span> TestControleDifferentsCas {</a>
<a class="sourceLine" id="cb18-8" data-line-number="8">    <span class="kw">protected</span> Controle controle ;</a>
<a class="sourceLine" id="cb18-9" data-line-number="9"></a>
<a class="sourceLine" id="cb18-10" data-line-number="10">    <span class="at">@Before</span></a>
<a class="sourceLine" id="cb18-11" data-line-number="11">    <span class="kw">public</span> <span class="kw">abstract</span> <span class="dt">void</span> <span class="fu">initControle</span>();</a>
<a class="sourceLine" id="cb18-12" data-line-number="12"></a>
<a class="sourceLine" id="cb18-13" data-line-number="13">    <span class="at">@Test</span></a>
<a class="sourceLine" id="cb18-14" data-line-number="14">    <span class="kw">public</span> <span class="dt">void</span> <span class="fu">testControleMenuPreferences</span>(){</a>
<a class="sourceLine" id="cb18-15" data-line-number="15">        <span class="fu">assertEquals</span>(<span class="st">&quot;Test 1&quot;</span>,</a>
<a class="sourceLine" id="cb18-16" data-line-number="16">                <span class="st">&quot;Menu Préférences&quot;</span>, controle.<span class="fu">lancer</span>(<span class="kw">new</span> <span class="bu">String</span>[]{<span class="st">&quot;1&quot;</span>}));</a>
<a class="sourceLine" id="cb18-17" data-line-number="17">    }</a>
<a class="sourceLine" id="cb18-18" data-line-number="18">    <span class="at">@Test</span></a>
<a class="sourceLine" id="cb18-19" data-line-number="19">    <span class="kw">public</span> <span class="dt">void</span> <span class="fu">testControleMenuEdition</span>(){</a>
<a class="sourceLine" id="cb18-20" data-line-number="20">        <span class="fu">assertEquals</span>(<span class="st">&quot;Test 2&quot;</span>,</a>
<a class="sourceLine" id="cb18-21" data-line-number="21">                <span class="st">&quot;Menu Edition&quot;</span>, controle.<span class="fu">lancer</span>(<span class="kw">new</span> <span class="bu">String</span>[]{<span class="st">&quot;2&quot;</span>}));</a>
<a class="sourceLine" id="cb18-22" data-line-number="22">    }</a>
<a class="sourceLine" id="cb18-23" data-line-number="23">  <span class="co">/*</span></a>
<a class="sourceLine" id="cb18-24" data-line-number="24"><span class="co">   * COMPLETEZ LES TESTS</span></a>
<a class="sourceLine" id="cb18-25" data-line-number="25"><span class="co">   */</span></a>
<a class="sourceLine" id="cb18-26" data-line-number="26">}</a></code></pre></div>
<p>Créez une classe <code>TestControleCascadeIfElse</code> qui dérive de <code>TestControleDifferentsCas</code> et ajoutez y la méthode suivante :</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="at">@Override</span></a>
<a class="sourceLine" id="cb19-2" data-line-number="2"><span class="kw">public</span> <span class="dt">void</span> <span class="fu">initControle</span>() {</a>
<a class="sourceLine" id="cb19-3" data-line-number="3">    controle = <span class="kw">new</span> <span class="fu">ControleCascadeIfElse</span>();</a>
<a class="sourceLine" id="cb19-4" data-line-number="4">}</a></code></pre></div>
<p>Complétez les cas de test manquant dans le code précédent.</p>
<h4 id="la-structure-de-branchement-switch-case">La structure de branchement switch-case</h4>
<p>Voici un code équivalent avec une structure <code>switch-case</code>.</p>
<div class="incremental">
<p>L’instruction <code>break</code> permet de stopper l’exécution du <code>switch</code> et d’en sortir immédiatement (vous pouvez essayer de la supprimer pour observer l’effet sur le déroulement du 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">package</span><span class="im"> com.example.controles;</span></a>
<a class="sourceLine" id="cb20-2" data-line-number="2"></a>
<a class="sourceLine" id="cb20-3" data-line-number="3"><span class="kw">public</span> <span class="kw">class</span> ControleSwitchCase <span class="kw">extends</span> Controle {</a>
<a class="sourceLine" id="cb20-4" data-line-number="4"></a>
<a class="sourceLine" id="cb20-5" data-line-number="5">    <span class="at">@Override</span></a>
<a class="sourceLine" id="cb20-6" data-line-number="6">    <span class="kw">public</span> <span class="bu">Object</span> <span class="fu">lancer</span>(<span class="bu">String</span>[] args) {</a>
<a class="sourceLine" id="cb20-7" data-line-number="7">        <span class="bu">String</span> returnedValue;</a>
<a class="sourceLine" id="cb20-8" data-line-number="8">        <span class="dt">int</span> valeurChoix = <span class="bu">Integer</span>.<span class="fu">parseInt</span>(args[<span class="dv">0</span>]);</a>
<a class="sourceLine" id="cb20-9" data-line-number="9">        <span class="kw">switch</span>(valeurChoix){</a>
<a class="sourceLine" id="cb20-10" data-line-number="10">        <span class="kw">case</span> <span class="dv">1</span>:</a>
<a class="sourceLine" id="cb20-11" data-line-number="11">            returnedValue = <span class="st">&quot;Menu Préférences&quot;</span>;</a>
<a class="sourceLine" id="cb20-12" data-line-number="12">            <span class="kw">break</span>;</a>
<a class="sourceLine" id="cb20-13" data-line-number="13">        <span class="kw">case</span> <span class="dv">2</span>:</a>
<a class="sourceLine" id="cb20-14" data-line-number="14">            returnedValue = <span class="st">&quot;Menu Edition&quot;</span>;</a>
<a class="sourceLine" id="cb20-15" data-line-number="15">            <span class="kw">break</span>;</a>
<a class="sourceLine" id="cb20-16" data-line-number="16">        <span class="kw">case</span> <span class="dv">3</span>:</a>
<a class="sourceLine" id="cb20-17" data-line-number="17">            returnedValue = <span class="st">&quot;Bonjour&quot;</span>;</a>
<a class="sourceLine" id="cb20-18" data-line-number="18">            <span class="kw">break</span>;</a>
<a class="sourceLine" id="cb20-19" data-line-number="19">        <span class="kw">case</span> <span class="dv">4</span>:</a>
<a class="sourceLine" id="cb20-20" data-line-number="20">            returnedValue = <span class="st">&quot;Au revoir&quot;</span>;</a>
<a class="sourceLine" id="cb20-21" data-line-number="21">            <span class="kw">break</span>;</a>
<a class="sourceLine" id="cb20-22" data-line-number="22">        <span class="kw">case</span> <span class="dv">5</span>:</a>
<a class="sourceLine" id="cb20-23" data-line-number="23">            returnedValue = <span class="st">&quot;Sortir&quot;</span>;</a>
<a class="sourceLine" id="cb20-24" data-line-number="24">    <span class="kw">default</span>:</a>
<a class="sourceLine" id="cb20-25" data-line-number="25">            returnedValue = <span class="st">&quot;Saisir votre choix (1,2,3,4 ou 5) : &quot;</span>;</a>
<a class="sourceLine" id="cb20-26" data-line-number="26">    }</a>
<a class="sourceLine" id="cb20-27" data-line-number="27">    <span class="kw">return</span> returnedValue;</a>
<a class="sourceLine" id="cb20-28" data-line-number="28">    }</a>
<a class="sourceLine" id="cb20-29" data-line-number="29">}</a></code></pre></div>
<h5 id="tester-manuellement-3">Tester manuellement</h5>
<p>Retestez ce code avec les tests précédents (en créant une nouvelle classe <code>VerifierSwitchCase</code> dérivant de <code>VerifierDifferentsCas</code> et en y instanciant <code>ControleSwitchCase</code>) et vérifiez que son fonctionnement est correct.</p>
<p>Ce code fonctionne-t-il ? Que manque-t-il ?</p>
<h5 id="test-avec-junit-1">Test avec JUnit</h5>
<p>Retestez ce code avec les tests précédents (en dérivant de <code>TestControleDifferentsCas</code> et en y instanciant <code>ControleSwitchCase</code>) et vérifiez que son fonctionnement est correct.</p>
<p>Ce code fonctionne-t-il ? Que manque-t-il ?</p>
</div>
<h4 id="string-et-switch-case">String et switch-case</h4>
<p>Il est possible de faire des switch-case sur des String depuis la version 7 de Java. Vous serez peut-être amenés à maintenir du code avec une version plus ancienne.</p>
<p>Vous ne pourrez donc pas utiliser la syntaxe suivante avec ces versions :</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">switch</span>(choix){</a>
<a class="sourceLine" id="cb21-2" data-line-number="2">    <span class="kw">case</span> <span class="st">&quot;1&quot;</span>: <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(<span class="st">&quot;Menu Préférences&quot;</span>);</a>
<a class="sourceLine" id="cb21-3" data-line-number="3">      <span class="kw">break</span>;</a>
<a class="sourceLine" id="cb21-4" data-line-number="4">    <span class="kw">case</span> <span class="st">&quot;2&quot;</span>: <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(<span class="st">&quot;Menu Edition&quot;</span>);</a>
<a class="sourceLine" id="cb21-5" data-line-number="5">      <span class="kw">break</span>;</a>
<a class="sourceLine" id="cb21-6" data-line-number="6">    <span class="kw">default</span>: <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(<span class="st">&quot;Recommencez !&quot;</span>);</a>
<a class="sourceLine" id="cb21-7" data-line-number="7">    }</a></code></pre></div>
<hr />
<h3 id="opérateur-ternaire">Opérateur ternaire</h3>
<p>Etudiez maintenant le fonctionnement de cette méthode :</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="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="cb22-2" data-line-number="2">    <span class="kw">if</span>( a == <span class="kw">null</span> ? b == <span class="kw">null</span> : a.<span class="fu">equals</span>(b) ){</a>
<a class="sourceLine" id="cb22-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="cb22-4" data-line-number="4">    }</a>
<a class="sourceLine" id="cb22-5" data-line-number="5">    <span class="kw">else</span>{</a>
<a class="sourceLine" id="cb22-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="cb22-7" data-line-number="7">    }</a>
<a class="sourceLine" id="cb22-8" data-line-number="8">}</a></code></pre></div>
<p>L’opérateur ternaire <code>? :</code> qui est utilisé ici fonctionne comme suit.</p>
<p>Le code :</p>
<div class="sourceCode" id="cb23"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb23-1" data-line-number="1">x = <span class="dv">1</span> ;</a>
<a class="sourceLine" id="cb23-2" data-line-number="2">a = (x == <span class="dv">1</span> ? <span class="dv">2</span> : <span class="dv">3</span>);</a>
<a class="sourceLine" id="cb23-3" data-line-number="3"><span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(a);</a></code></pre></div>
<p>Conduit à l’affichage suivant: <code>2</code></p>
<p>Le code :</p>
<div class="sourceCode" id="cb24"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb24-1" data-line-number="1">x = <span class="dv">4</span> ;</a>
<a class="sourceLine" id="cb24-2" data-line-number="2">a = (x == <span class="dv">1</span> ? <span class="dv">2</span> : <span class="dv">3</span>);</a>
<a class="sourceLine" id="cb24-3" data-line-number="3"><span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(a);</a></code></pre></div>
<p>Conduit à l’affichage suivant: <code>3</code></p>
<p>Le code équivalent à <code>(x == 1 ? 2 : 3)</code> est :</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="dt">int</span> <span class="fu">f</span>(<span class="dt">int</span> x){</a>
<a class="sourceLine" id="cb25-2" data-line-number="2">  <span class="kw">if</span>(x == <span class="dv">1</span>){</a>
<a class="sourceLine" id="cb25-3" data-line-number="3">    <span class="kw">return</span> <span class="dv">2</span>;</a>
<a class="sourceLine" id="cb25-4" data-line-number="4">  }<span class="kw">else</span>{</a>
<a class="sourceLine" id="cb25-5" data-line-number="5">    <span class="kw">return</span> <span class="dv">3</span>;</a>
<a class="sourceLine" id="cb25-6" data-line-number="6">  }</a>
<a class="sourceLine" id="cb25-7" data-line-number="7">}</a></code></pre></div>
<p>Les deux codes suivants sont donc équivalents:</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="co">//Première version</span></a>
<a class="sourceLine" id="cb26-2" data-line-number="2">a = (x == <span class="dv">1</span> ? <span class="dv">2</span> : <span class="dv">3</span>);</a>
<a class="sourceLine" id="cb26-3" data-line-number="3"></a>
<a class="sourceLine" id="cb26-4" data-line-number="4"><span class="co">//Seconde version</span></a>
<a class="sourceLine" id="cb26-5" data-line-number="5">a = <span class="fu">f</span>(x);</a></code></pre></div>
<p>Quel est l’intérêt de cette notation ?</p>
<p>Quel peut être son inconvénient ?</p>
<h5 id="exercice">Exercice</h5>
<p>Créez les tests unitaires permettant de vérifier le fonctionnement de la méthode <code>testChaines(String, String)</code></p>
<p>Réécrivez cette méthode en n’utilisant que des <code>if-else</code> et vérifiez son fonctionnement.</p>
<h2 id="boucles">Boucles</h2>
<h3 id="for">for</h3>
<p>Le premier mode d’utilisation de la boucle <code>for</code> se fait comme en langage <code>C</code>:</p>
<div class="sourceCode" id="cb27"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb27-1" data-line-number="1"><span class="kw">for</span> ( initialisation; condition; mise à jour ) {</a>
<a class="sourceLine" id="cb27-2" data-line-number="2">   instructions;</a>
<a class="sourceLine" id="cb27-3" data-line-number="3">}</a></code></pre></div>
<p>Ainsi le parcours d’un tableau se fait ainsi:</p>
<div class="sourceCode" id="cb28"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb28-1" data-line-number="1"><span class="kw">public</span> <span class="bu">Object</span> <span class="fu">lancer</span>(<span class="bu">String</span>[] args) {</a>
<a class="sourceLine" id="cb28-2" data-line-number="2">  <span class="bu">StringBuffer</span> sb = <span class="kw">new</span> <span class="bu">StringBuffer</span>();</a>
<a class="sourceLine" id="cb28-3" data-line-number="3">  <span class="kw">for</span>(<span class="dt">int</span> i = <span class="dv">0</span> ; i &lt; args.<span class="fu">length</span>; i++){</a>
<a class="sourceLine" id="cb28-4" data-line-number="4">    sb.<span class="fu">append</span>(args[i]);</a>
<a class="sourceLine" id="cb28-5" data-line-number="5">  }</a>
<a class="sourceLine" id="cb28-6" data-line-number="6">  <span class="kw">return</span> sb.<span class="fu">toString</span>();</a>
<a class="sourceLine" id="cb28-7" data-line-number="7">}</a></code></pre></div>
<p>Une utilisation pour le parcours de listes (vues au prochain chapitre) est la suivante:</p>
<div class="sourceCode" id="cb29"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb29-1" data-line-number="1"><span class="kw">for</span> (&lt;<span class="bu">Type</span>&gt; membreListe : liste){</a>
<a class="sourceLine" id="cb29-2" data-line-number="2">  instructions;</a>
<a class="sourceLine" id="cb29-3" data-line-number="3">}</a></code></pre></div>
<p>Exemple avec un <code>StringBuffer</code>:</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="bu">Object</span> <span class="fu">lancer</span>(<span class="bu">String</span>[] args) {</a>
<a class="sourceLine" id="cb30-2" data-line-number="2">  <span class="bu">StringBuffer</span> sb = <span class="kw">new</span> <span class="bu">StringBuffer</span>();</a>
<a class="sourceLine" id="cb30-3" data-line-number="3">  <span class="kw">for</span>(<span class="bu">String</span> str : args){</a>
<a class="sourceLine" id="cb30-4" data-line-number="4">    sb.<span class="fu">append</span>(str);</a>
<a class="sourceLine" id="cb30-5" data-line-number="5">  }</a>
<a class="sourceLine" id="cb30-6" data-line-number="6">  <span class="kw">return</span> sb.<span class="fu">toString</span>();</a>
<a class="sourceLine" id="cb30-7" data-line-number="7">}</a></code></pre></div>
<h3 id="while-do-while">while / do-while</h3>
<p>La structure <code>while</code> permet de réaliser une boucle <code>tant-que</code> :</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="bu">Object</span> <span class="fu">lancer</span>(<span class="bu">String</span>[] args) {</a>
<a class="sourceLine" id="cb31-2" data-line-number="2">  <span class="bu">StringBuffer</span> sb = <span class="kw">new</span> <span class="bu">StringBuffer</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="dt">int</span> i = args.<span class="fu">length</span> - <span class="dv">1</span>;</a>
<a class="sourceLine" id="cb31-5" data-line-number="5">  <span class="kw">while</span>(i &gt;= <span class="dv">0</span>){</a>
<a class="sourceLine" id="cb31-6" data-line-number="6">    sb.<span class="fu">insert</span>(<span class="dv">0</span>, args[i]);</a>
<a class="sourceLine" id="cb31-7" data-line-number="7">    i --;</a>
<a class="sourceLine" id="cb31-8" data-line-number="8">  }</a>
<a class="sourceLine" id="cb31-9" data-line-number="9">  <span class="kw">return</span> sb.<span class="fu">toString</span>();</a>
<a class="sourceLine" id="cb31-10" data-line-number="10">}</a></code></pre></div>
<p>La boucle <code>répéter-tant-que</code> est réalisable en utilisant la structure <code>do-while</code>:</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">public</span> <span class="bu">Object</span> <span class="fu">lancer</span>(<span class="bu">String</span>[] args) {</a>
<a class="sourceLine" id="cb32-2" data-line-number="2">  <span class="bu">StringBuffer</span> sb = <span class="kw">new</span> <span class="bu">StringBuffer</span>();</a>
<a class="sourceLine" id="cb32-3" data-line-number="3"></a>
<a class="sourceLine" id="cb32-4" data-line-number="4">  <span class="dt">int</span> i = args.<span class="fu">length</span> - <span class="dv">1</span>;</a>
<a class="sourceLine" id="cb32-5" data-line-number="5"></a>
<a class="sourceLine" id="cb32-6" data-line-number="6">  <span class="kw">do</span></a>
<a class="sourceLine" id="cb32-7" data-line-number="7">  {</a>
<a class="sourceLine" id="cb32-8" data-line-number="8">    sb.<span class="fu">insert</span>(<span class="dv">0</span>, args[i]);</a>
<a class="sourceLine" id="cb32-9" data-line-number="9">    i --;</a>
<a class="sourceLine" id="cb32-10" data-line-number="10">  } <span class="kw">while</span>(i &gt;= <span class="dv">0</span>);</a>
<a class="sourceLine" id="cb32-11" data-line-number="11"></a>
<a class="sourceLine" id="cb32-12" data-line-number="12">  <span class="kw">return</span> sb.<span class="fu">toString</span>();</a>
<a class="sourceLine" id="cb32-13" data-line-number="13">}</a></code></pre></div>
<p>Testez cette boucle avec le tableau suivant:</p>
<ul>
<li><code>new String[]{}</code></li>
</ul>
<p>Corrigez le code si nécessaire.</p>
<h2 id="contrôle-des-boucles">Contrôle des boucles</h2>
<h3 id="break">break</h3>
<p>Cette instruction (déjà vue avec <code>switch</code>), permet de stopper l’exécution en cours d’une boucle.</p>
<p>Exemple d’utilisation de <code>break</code>:</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="bu">Object</span> <span class="fu">lancer</span>(<span class="bu">String</span>[] args) {</a>
<a class="sourceLine" id="cb33-2" data-line-number="2">  <span class="bu">StringBuffer</span> sb = <span class="kw">new</span> <span class="bu">StringBuffer</span>();</a>
<a class="sourceLine" id="cb33-3" data-line-number="3">  <span class="kw">for</span>(<span class="dt">int</span> i = <span class="dv">0</span> ; i &lt; args.<span class="fu">length</span>; i++){</a>
<a class="sourceLine" id="cb33-4" data-line-number="4">    <span class="kw">if</span>(i == <span class="dv">2</span>){</a>
<a class="sourceLine" id="cb33-5" data-line-number="5">      <span class="kw">break</span> ;</a>
<a class="sourceLine" id="cb33-6" data-line-number="6">    }</a>
<a class="sourceLine" id="cb33-7" data-line-number="7">    sb.<span class="fu">append</span>(args[i]);</a>
<a class="sourceLine" id="cb33-8" data-line-number="8">  }</a>
<a class="sourceLine" id="cb33-9" data-line-number="9">  <span class="kw">return</span> sb.<span class="fu">toString</span>();</a>
<a class="sourceLine" id="cb33-10" data-line-number="10">}</a></code></pre></div>
<p>L’exécution du code précédent :</p>
<ul>
<li>appelé avec le tableau <code>new String[]{&quot;Un&quot;, &quot;Deux&quot;, &quot;Trois&quot;, &quot;Quatre&quot;}</code></li>
<li>renverra la chaîne <code>UnDeux</code></li>
</ul>
<h3 id="continue">continue</h3>
<p>Cette instruction (déjà vue avec <code>switch</code>), permet de ne pas exécuter la suite du bloc d’instruction pour l’itération courante.</p>
<p>Exemple d’utilisation de <code>continue</code>:</p>
<div class="sourceCode" id="cb34"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb34-1" data-line-number="1"><span class="kw">public</span> <span class="bu">Object</span> <span class="fu">lancer</span>(<span class="bu">String</span>[] args) {</a>
<a class="sourceLine" id="cb34-2" data-line-number="2">  <span class="bu">StringBuffer</span> sb = <span class="kw">new</span> <span class="bu">StringBuffer</span>();</a>
<a class="sourceLine" id="cb34-3" data-line-number="3">  <span class="kw">for</span>(<span class="dt">int</span> i = <span class="dv">0</span> ; i &lt; args.<span class="fu">length</span>; i++){</a>
<a class="sourceLine" id="cb34-4" data-line-number="4">    <span class="kw">if</span>(i == <span class="dv">2</span>){</a>
<a class="sourceLine" id="cb34-5" data-line-number="5">      <span class="kw">continue</span> ;</a>
<a class="sourceLine" id="cb34-6" data-line-number="6">    }</a>
<a class="sourceLine" id="cb34-7" data-line-number="7">    sb.<span class="fu">append</span>(args[i]);</a>
<a class="sourceLine" id="cb34-8" data-line-number="8">  }</a>
<a class="sourceLine" id="cb34-9" data-line-number="9">  <span class="kw">return</span> sb.<span class="fu">toString</span>();</a>
<a class="sourceLine" id="cb34-10" data-line-number="10">}</a></code></pre></div>
<p>L’exécution du code précédent :</p>
<ul>
<li>appelé avec le tableau <code>new String[]{&quot;Un&quot;, &quot;Deux&quot;, &quot;Trois&quot;, &quot;Quatre&quot;}</code></li>
<li>renverra la chaîne <code>UnDeuxQuatre</code></li>
</ul>
<h1 id="enum">Enum</h1>
<p>Dans cette partie, nous allons étudier une fonctionnalité importante du langage Java:</p>
<ul>
<li>les <code>Enum</code></li>
</ul>
<p>Les <code>Enum</code> sont notamment associés à la structure de contrôle <code>switch</code>.</p>
<h2 id="pourquoi-les-enum">Pourquoi les Enum</h2>
<h3 id="les-constantes-avant-les-enum">Les constantes (avant les Enum)</h3>
<p>Nous pouvons remplacer les éléments pour chaque <code>case</code> d’un <code>switch</code> par des constantes:</p>
<div class="sourceCode" id="cb35"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb35-1" data-line-number="1"><span class="kw">public</span> <span class="kw">class</span> AvantLesEnums {</a>
<a class="sourceLine" id="cb35-2" data-line-number="2">    <span class="kw">public</span> <span class="dt">static</span> <span class="dt">final</span> <span class="bu">String</span> CHOIX_MENU_PREFERENCES = <span class="st">&quot;1&quot;</span>;</a>
<a class="sourceLine" id="cb35-3" data-line-number="3">    <span class="kw">public</span> <span class="dt">static</span> <span class="dt">final</span> <span class="bu">String</span> CHOIX_MENU_EDITION     = <span class="st">&quot;2&quot;</span>;</a>
<a class="sourceLine" id="cb35-4" data-line-number="4">    <span class="kw">public</span> <span class="dt">static</span> <span class="dt">final</span> <span class="bu">String</span> CHOIX_SORTIR           = <span class="st">&quot;2&quot;</span>;</a>
<a class="sourceLine" id="cb35-5" data-line-number="5"></a>
<a class="sourceLine" id="cb35-6" data-line-number="6">    <span class="kw">public</span> <span class="dt">void</span> <span class="fu">appliquerChoix</span>(<span class="bu">String</span> choix){</a>
<a class="sourceLine" id="cb35-7" data-line-number="7">        <span class="kw">if</span>(choix == CHOIX_SORTIR){</a>
<a class="sourceLine" id="cb35-8" data-line-number="8">            <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(<span class="st">&quot;Sortie du programme&quot;</span>);</a>
<a class="sourceLine" id="cb35-9" data-line-number="9">            <span class="bu">System</span>.<span class="fu">exit</span>(<span class="dv">0</span>);</a>
<a class="sourceLine" id="cb35-10" data-line-number="10">        }</a>
<a class="sourceLine" id="cb35-11" data-line-number="11">        <span class="kw">switch</span>(choix){</a>
<a class="sourceLine" id="cb35-12" data-line-number="12">        <span class="kw">case</span> CHOIX_MENU_PREFERENCES: <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(<span class="st">&quot;Menu Préférences&quot;</span>);</a>
<a class="sourceLine" id="cb35-13" data-line-number="13">        <span class="kw">break</span>;</a>
<a class="sourceLine" id="cb35-14" data-line-number="14">        <span class="kw">case</span> CHOIX_MENU_EDITION: <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(<span class="st">&quot;Menu Edition&quot;</span>);</a>
<a class="sourceLine" id="cb35-15" data-line-number="15">        <span class="kw">break</span>;</a>
<a class="sourceLine" id="cb35-16" data-line-number="16">        <span class="kw">default</span>: <span class="fu">appliquerAutreCommande</span>(choix);</a>
<a class="sourceLine" id="cb35-17" data-line-number="17">        }</a>
<a class="sourceLine" id="cb35-18" data-line-number="18">    }</a>
<a class="sourceLine" id="cb35-19" data-line-number="19">    <span class="kw">public</span> <span class="dt">void</span> <span class="fu">appliquerAutreCommande</span>(<span class="bu">String</span> choix){}</a>
<a class="sourceLine" id="cb35-20" data-line-number="20"></a>
<a class="sourceLine" id="cb35-21" data-line-number="21">    <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="cb35-22" data-line-number="22">        AvantLesEnums avantLesEnums = <span class="kw">new</span> <span class="fu">AvantLesEnums</span>();</a>
<a class="sourceLine" id="cb35-23" data-line-number="23"></a>
<a class="sourceLine" id="cb35-24" data-line-number="24">        avantLesEnums.<span class="fu">appliquerChoix</span>(<span class="st">&quot;2&quot;</span>);</a>
<a class="sourceLine" id="cb35-25" data-line-number="25">    }</a>
<a class="sourceLine" id="cb35-26" data-line-number="26">}</a></code></pre></div>
<p>Ceci rend le code plus lisible. Cependant, il exite un risque pour que deux constantes soient de même valeur (ici <code>CHOIX_SORTIR</code> est identique à <code>CHOIX_MENU_EDITION</code>)</p>
<div class="incremental">
<p>Dans ce cas, le risque de dysfonctionement du programme est important, sans qu’il soit nécessairement détecté par le compilateur.</p>
<p>Pour palier à cela, nous pouvons utiliser les <code>Enum</code>.</p>
</div>
<h3 id="définition-des-enum">Définition des Enum</h3>
<p>Les <code>Enum</code> permettent de définir un ensemble de valeurs pour lesquels il est certain que chacune d’elles seront distinctes, tout en étant <em>typée</em>.</p>
<div class="incremental">
<p>De plus, elle peuvent être utilisées dans une structure <code>switch...case</code> comme n’importe quelle valeur constante, à la différence qu’on est assuré qu’aucune valeur ne peut être confondue avec une autre.</p>
<p>Utilisation particulièrement utile dans un <code>switch...case</code></p>
</div>
<h3 id="enum-exemple-de-déclaration">Enum: exemple de déclaration</h3>
<p>On définit un Enum à la manière d’une classe, mais avec le mot clé <code>enum</code>:</p>
<div class="sourceCode" id="cb36"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb36-1" data-line-number="1"><span class="kw">public</span> <span class="kw">enum</span> ItemMenuPrincipal {</a>
<a class="sourceLine" id="cb36-2" data-line-number="2">    MENU_PREFERENCES, MENU_EDITION, MENU_SORTIR;</a>
<a class="sourceLine" id="cb36-3" data-line-number="3">}</a></code></pre></div>
<div class="incremental">
<p><strong>Intérêt</strong> :</p>
<ul>
<li>plus besoin de mettre de valeurs</li>
<li>les valeurs sont toutes différentes</li>
</ul>
<div class="sourceCode" id="cb37"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb37-1" data-line-number="1"><span class="kw">import static</span><span class="im"> com.example.enumeration.ItemMenuPrincipal.*;</span></a>
<a class="sourceLine" id="cb37-2" data-line-number="2"></a>
<a class="sourceLine" id="cb37-3" data-line-number="3"><span class="kw">public</span> <span class="kw">class</span> AvecLesEnums {</a>
<a class="sourceLine" id="cb37-4" data-line-number="4">    <span class="kw">public</span> <span class="dt">void</span> <span class="fu">appliquerChoix</span>(ItemMenuPrincipal choix){</a>
<a class="sourceLine" id="cb37-5" data-line-number="5">        <span class="kw">if</span>(choix == MENU_SORTIR){</a>
<a class="sourceLine" id="cb37-6" data-line-number="6">            <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(<span class="st">&quot;Sortie du programme&quot;</span>);</a>
<a class="sourceLine" id="cb37-7" data-line-number="7">            <span class="bu">System</span>.<span class="fu">exit</span>(<span class="dv">0</span>);</a>
<a class="sourceLine" id="cb37-8" data-line-number="8">        }</a>
<a class="sourceLine" id="cb37-9" data-line-number="9">        <span class="kw">switch</span>(choix){</a>
<a class="sourceLine" id="cb37-10" data-line-number="10">        <span class="kw">case</span> MENU_PREFERENCES: <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(<span class="st">&quot;Menu Préférences&quot;</span>);</a>
<a class="sourceLine" id="cb37-11" data-line-number="11">        <span class="kw">break</span>;</a>
<a class="sourceLine" id="cb37-12" data-line-number="12">        <span class="kw">case</span> MENU_EDITION: <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(<span class="st">&quot;Menu Edition&quot;</span>);</a>
<a class="sourceLine" id="cb37-13" data-line-number="13">        <span class="kw">break</span>;</a>
<a class="sourceLine" id="cb37-14" data-line-number="14">        <span class="kw">default</span>: <span class="fu">appliquerAutreCommande</span>(choix);</a>
<a class="sourceLine" id="cb37-15" data-line-number="15">        }</a>
<a class="sourceLine" id="cb37-16" data-line-number="16">    }</a>
<a class="sourceLine" id="cb37-17" data-line-number="17">}</a></code></pre></div>
</div>
<h3 id="méthodes-statiques-dans-les-enum">Méthodes statiques dans les Enum</h3>
<p>On peut ajouter des méthodes de classe à un <code>enum</code></p>
<div class="sourceCode" id="cb38"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb38-1" data-line-number="1"><span class="kw">public</span> <span class="kw">enum</span> ItemMenuPrincipal {</a>
<a class="sourceLine" id="cb38-2" data-line-number="2">    MENU_PREFERENCES, MENU_EDITION, DIRE_BONJOUR, DIRE_AU_REVOIR, MENU_SORTIR;</a>
<a class="sourceLine" id="cb38-3" data-line-number="3"></a>
<a class="sourceLine" id="cb38-4" data-line-number="4">    <span class="kw">public</span> <span class="dt">static</span> ItemMenuPrincipal <span class="fu">getItem</span>(<span class="bu">String</span> identifiant){</a>
<a class="sourceLine" id="cb38-5" data-line-number="5">        <span class="kw">switch</span> (identifiant) {</a>
<a class="sourceLine" id="cb38-6" data-line-number="6">        <span class="kw">case</span> <span class="st">&quot;1&quot;</span>:</a>
<a class="sourceLine" id="cb38-7" data-line-number="7">            <span class="kw">return</span> MENU_PREFERENCES;</a>
<a class="sourceLine" id="cb38-8" data-line-number="8">        <span class="kw">case</span> <span class="st">&quot;2&quot;</span>:</a>
<a class="sourceLine" id="cb38-9" data-line-number="9">            <span class="kw">return</span> MENU_EDITION;</a>
<a class="sourceLine" id="cb38-10" data-line-number="10">        <span class="kw">case</span> <span class="st">&quot;3&quot;</span>:</a>
<a class="sourceLine" id="cb38-11" data-line-number="11">            <span class="kw">return</span> MENU_SORTIR;</a>
<a class="sourceLine" id="cb38-12" data-line-number="12">        }</a>
<a class="sourceLine" id="cb38-13" data-line-number="13">        <span class="kw">return</span> <span class="kw">null</span>;</a>
<a class="sourceLine" id="cb38-14" data-line-number="14">    }</a>
<a class="sourceLine" id="cb38-15" data-line-number="15">}</a></code></pre></div>
<p>Ajoutez un <code>main</code> dans la classe <code>AvecLesEnums</code> sur le modèle du <code>main</code> de la classe <code>AvantLesEnums</code> et vérifiez ce programme.</p>
<h2 id="enum-comme-des-instances">Enum comme des instances</h2>
<p>On peut gérer les <code>enum</code> comme des objets, et leur ajouter des méthodes, des constructeurs:</p>
<div class="sourceCode" id="cb39"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb39-1" data-line-number="1"><span class="kw">public</span> <span class="kw">enum</span> ItemMenuPrincipal {</a>
<a class="sourceLine" id="cb39-2" data-line-number="2">    <span class="fu">MENU_PREFERENCES</span>(<span class="st">&quot;Menu Préférences&quot;</span>),</a>
<a class="sourceLine" id="cb39-3" data-line-number="3">    <span class="fu">MENU_EDITION</span>(<span class="st">&quot;Menu Edition&quot;</span>),</a>
<a class="sourceLine" id="cb39-4" data-line-number="4">    <span class="fu">MENU_SORTIR</span>(<span class="st">&quot;Sortie du programme&quot;</span>);</a>
<a class="sourceLine" id="cb39-5" data-line-number="5"></a>
<a class="sourceLine" id="cb39-6" data-line-number="6">    <span class="kw">private</span> <span class="bu">String</span> representation;</a>
<a class="sourceLine" id="cb39-7" data-line-number="7"></a>
<a class="sourceLine" id="cb39-8" data-line-number="8">    <span class="kw">private</span> <span class="fu">ItemMenuPrincipal</span>(<span class="bu">String</span> representation){</a>
<a class="sourceLine" id="cb39-9" data-line-number="9">        <span class="kw">this</span>.<span class="fu">representation</span> = representation;</a>
<a class="sourceLine" id="cb39-10" data-line-number="10">    }</a>
<a class="sourceLine" id="cb39-11" data-line-number="11"></a>
<a class="sourceLine" id="cb39-12" data-line-number="12">    <span class="kw">public</span> <span class="bu">String</span> <span class="fu">toString</span>(){</a>
<a class="sourceLine" id="cb39-13" data-line-number="13">        <span class="kw">return</span> representation;</a>
<a class="sourceLine" id="cb39-14" data-line-number="14">    }</a>
<a class="sourceLine" id="cb39-15" data-line-number="15"></a>
<a class="sourceLine" id="cb39-16" data-line-number="16">    <span class="kw">public</span> <span class="dt">static</span> ItemMenuPrincipal <span class="fu">getItem</span>(<span class="bu">String</span> identifiant){</a>
<a class="sourceLine" id="cb39-17" data-line-number="17">        <span class="kw">switch</span> (identifiant) {</a>
<a class="sourceLine" id="cb39-18" data-line-number="18">        <span class="kw">case</span> <span class="st">&quot;1&quot;</span>:</a>
<a class="sourceLine" id="cb39-19" data-line-number="19">            <span class="kw">return</span> MENU_PREFERENCES;</a>
<a class="sourceLine" id="cb39-20" data-line-number="20">        <span class="kw">case</span> <span class="st">&quot;2&quot;</span>:</a>
<a class="sourceLine" id="cb39-21" data-line-number="21">            <span class="kw">return</span> MENU_EDITION;</a>
<a class="sourceLine" id="cb39-22" data-line-number="22">        <span class="kw">case</span> <span class="st">&quot;3&quot;</span>:</a>
<a class="sourceLine" id="cb39-23" data-line-number="23">            <span class="kw">return</span> MENU_SORTIR;</a>
<a class="sourceLine" id="cb39-24" data-line-number="24">        }</a>
<a class="sourceLine" id="cb39-25" data-line-number="25">        <span class="kw">return</span> <span class="kw">null</span>;</a>
<a class="sourceLine" id="cb39-26" data-line-number="26">    }</a>
<a class="sourceLine" id="cb39-27" data-line-number="27">}</a></code></pre></div>
<p>Modifiez la méthode <code>appliquerChoix</code> de la classe <code>AvecLesEnums</code> en supprimant les chaînes écrites <em>en dur</em>.</p>
<p>On peut même ajouter des comportements (nous reprenons ici les classes <code>Calcul</code> et dérivées :</p>
<div class="sourceCode" id="cb40"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb40-1" data-line-number="1"><span class="kw">public</span> <span class="kw">enum</span> <span class="bu">Operation</span> {</a>
<a class="sourceLine" id="cb40-2" data-line-number="2">    <span class="fu">ADDITION</span>(<span class="st">&quot;+&quot;</span>, <span class="kw">new</span> <span class="fu">Addition</span>()),</a>
<a class="sourceLine" id="cb40-3" data-line-number="3">    <span class="fu">SOUSTRACTION</span>(<span class="st">&quot;-&quot;</span>, <span class="kw">new</span> <span class="fu">Soustraction</span>()),</a>
<a class="sourceLine" id="cb40-4" data-line-number="4">    <span class="fu">MULTIPLICATION</span>(<span class="st">&quot;x&quot;</span>, <span class="kw">new</span> <span class="fu">Multiplication</span>());</a>
<a class="sourceLine" id="cb40-5" data-line-number="5"></a>
<a class="sourceLine" id="cb40-6" data-line-number="6">    <span class="kw">private</span> <span class="bu">String</span> representation;</a>
<a class="sourceLine" id="cb40-7" data-line-number="7">    <span class="kw">private</span> Calcul calcul ;</a>
<a class="sourceLine" id="cb40-8" data-line-number="8"></a>
<a class="sourceLine" id="cb40-9" data-line-number="9">    <span class="kw">private</span> <span class="bu">Operation</span>(<span class="bu">String</span> representation, Calcul calcul){</a>
<a class="sourceLine" id="cb40-10" data-line-number="10">        <span class="kw">this</span>.<span class="fu">representation</span> = representation;</a>
<a class="sourceLine" id="cb40-11" data-line-number="11">        <span class="kw">this</span>.<span class="fu">calcul</span> = calcul;</a>
<a class="sourceLine" id="cb40-12" data-line-number="12">    }</a>
<a class="sourceLine" id="cb40-13" data-line-number="13"></a>
<a class="sourceLine" id="cb40-14" data-line-number="14">    <span class="kw">public</span> <span class="dt">int</span> <span class="fu">execute</span>(<span class="dt">int</span> operandeA, <span class="dt">int</span> operandeB){</a>
<a class="sourceLine" id="cb40-15" data-line-number="15">        calcul.<span class="fu">calculer</span>(operandeA, operandeB);</a>
<a class="sourceLine" id="cb40-16" data-line-number="16">        <span class="kw">return</span> calcul.<span class="fu">getResultat</span>();</a>
<a class="sourceLine" id="cb40-17" data-line-number="17">    }</a>
<a class="sourceLine" id="cb40-18" data-line-number="18">}</a></code></pre></div>
<p>Ce qui permet notamment de simplifier le code par ailleurs :</p>
<div class="sourceCode" id="cb41"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb41-1" data-line-number="1"><span class="bu">Operation</span> op = ADDITION;</a>
<a class="sourceLine" id="cb41-2" data-line-number="2">op.<span class="fu">execute</span>(<span class="dv">10</span>, <span class="dv">23</span>);</a></code></pre></div>
<div class="important">
<p><strong>Attention</strong>: pour que ce code compile, il faut ajouter un <code>import static</code> en début de fichier.</p>
</div>
<div class="sourceCode" id="cb42"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb42-1" data-line-number="1"><span class="kw">import static</span><span class="im"> com.example.calculatrice.Operation.*;</span></a></code></pre></div>
<h2 id="application-nombre-de-jours-dans-le-mois">Application : nombre de jours dans le mois</h2>
<p>Écrire un <code>enum</code> <code>Mois</code> permettant de récupérer :</p>
<ul>
<li>le nom du mois</li>
<li>le numéro du mois</li>
<li>le nombre de jour dans le mois (en fonction d’un paramètre: l’année)</li>
</ul>
<p>On rappelle que :</p>
<ul>
<li>le mois de février compte 28 jours sauf si l’année est bissextile (29 jours dans ce cas)</li>
<li>une année est bissextile si elle est divisible par 4</li>
<li>une année <strong>n’est pas</strong> bissextile si elle est divisible par 100 (exception faite des années divisibles par 400, qui sont elles bissextiles).</li>
</ul>
<p>Vous écrirez les tests unitaires permettant de tester cet <code>enum</code>.</p>
<h1 id="exercices">Exercices</h1>
<h2 id="gestion-dune-liste-dentiers">Gestion d’une liste d’entiers</h2>
<p>Nous allons définir une classe <code>TableauEntier</code> permettant de stocker des entiers dans une structure dynamique.</p>
<p>Cette classe doit empêcher tout modification non contrôlée de ses attributs (encapsulation).</p>
<p>Pour cela, vous allez utiliser un tableau d’entiers (<code>int[]</code>) dans lequel vous devrez gérer les opérations d’ajout, de suppression et d’insertion des valeurs.</p>
<p>La taille initiale de ce tableau sera <code>5</code> et sera incrémentée de 5 en 5, quand le nombre d’éléments dépassera la taille disponible.</p>
<p>Pour cela nous allons définir les méthodes suivantes:</p>
<ul>
<li><code>void inserer(int index, int valeur)</code> : insère un entier dans le tableau en à l’index donné. Si l’index dépasse la taille du tableau, l’ajout se fait en dernière position (après avoir augmenté la taille du tableau).</li>
<li><code>void supprimer(int index)</code> : supprime l’entier situé à l’index donné en paramètre du tableau. Les autres valeurs sont alors décalées pour éviter les espaces vides.</li>
<li><code>int taille()</code> : donne la taille du tableau</li>
<li><code>public String toString()</code> : récupère une représentation sous forme de chaîne de caractères du tableau.
<ul>
<li>Chaque entier est séparé par une virgule</li>
<li>l’ensemble est encadré par des <code>[]</code></li>
<li>Exemple : <code>&quot;[1,3,45]&quot;</code></li>
</ul></li>
</ul>
<p>Si le tableau <code>int[]</code> devient trop petit, vous devrez en définir un nouveau plus grand et recopier son contenu.</p>
<p>La classe <code>EssaiTableauEntier</code> comportera une méthode <code>main(String[] args)</code> et permettra de tester votre classe, par exemple en demandant à l’utilisateur de saisir des informations.</p>
</body>
</html>