EISTI-ING1-GI
/
Java-2017-2018


			
				
					
						
						
							123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668
							<!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>Les exceptions</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">Les exceptions</div>
<nav id="TOC">
<ul>
<li><a href="#les-exceptions">Les Exceptions</a><ul>
<li><a href="#déroulement-dun-programme">Déroulement d’un programme</a></li>
<li><a href="#traitement-des-événements-exceptionnels-en-java">Traitement des événements exceptionnels en Java</a></li>
<li><a href="#exemples-de-code">Exemples de code</a><ul>
<li><a href="#traitement-facultatif">Traitement facultatif</a></li>
<li><a href="#traitement-imposé-à-la-compilation">Traitement imposé à la compilation</a></li>
<li><a href="#exemple-readshort">Exemple : readShort</a></li>
</ul></li>
</ul></li>
<li><a href="#gestion-des-exceptions">Gestion des exceptions</a><ul>
<li><a href="#traitement-dans-la-méthode-où-lexception-se-produit">Traitement dans la méthode où l’exception se produit</a></li>
<li><a href="#traitement-dans-la-méthode-appelante">Traitement dans la méthode appelante</a></li>
</ul></li>
<li><a href="#types-dexceptions">Types d’exceptions</a><ul>
<li><a href="#le-type-throwable">Le type Throwable</a></li>
<li><a href="#exceptions-non-vérifiées">Exceptions non vérifiées</a><ul>
<li><a href="#runtime-exception">Runtime Exception</a></li>
<li><a href="#error">Error</a></li>
</ul></li>
<li><a href="#exceptions-vérifiées">Exceptions vérifiées</a><ul>
<li><a href="#exceptions-à-traiter-obligatoirement">Exceptions à traiter obligatoirement</a></li>
<li><a href="#exemples-dévénements-anormaux">Exemples d’événements anormaux</a></li>
</ul></li>
<li><a href="#hiérarchie-de-classes">Hiérarchie de classes</a></li>
</ul></li>
<li><a href="#exemple-concret">Exemple concret</a></li>
<li><a href="#création-et-levée-de-vos-propres-exceptions">Création et levée de vos propres exceptions</a><ul>
<li><a href="#création-dexception">Création d’exception</a><ul>
<li><a href="#création-dexception-1">Création d’exception</a></li>
</ul></li>
<li><a href="#levée-dexception">Levée d’exception</a><ul>
<li><a href="#programme">Programme</a></li>
<li><a href="#explications">Explications</a></li>
</ul></li>
</ul></li>
<li><a href="#exercices">Exercices</a><ul>
<li><a href="#calcul">Calcul</a></li>
<li><a href="#le-nom-de-lexception">Le nom de l’exception</a></li>
<li><a href="#factorielle">Factorielle</a></li>
<li><a href="#gestion-de-mot-de-passe">Gestion de mot de passe</a></li>
</ul></li>
</ul>
</nav>
<h1 id="les-exceptions">Les Exceptions</h1>
<h2 id="déroulement-dun-programme">Déroulement d’un programme</h2>
<p>Lors de l’exécution d’un programme, on a une chaîne d’appel.</p>
<div class="incremental">
<p>Chaque élément de la chaîne est sollicité par un appelant (<code>caller</code>).</p>
</div>
<div class="incremental">
<p>L’élément sollicité est nommé <em>appelé</em> (<code>callee</code>).</p>
<p>L’exemple qui suit montre la lecture de données sur un support de stockage.</p>
<figure>
<img src="images/ExceptionsPileAppelReseau.png" alt="Déroulement normal d’un programme" /><figcaption>Déroulement normal d’un programme</figcaption>
</figure>
<p>A chaque niveau d’appel, un problème peut survenir.</p>
<figure>
<img src="images/ExceptionsPileAppelReseauErreurs.png" alt="Erreurs possibles" /><figcaption>Erreurs possibles</figcaption>
</figure>
<p>Quelle décision doit prendre un élément <em>appelé</em> quant au traitement du problème ?</p>
<ul>
<li>Peut-il continuer l’exécution du programme comme si rien ne s’était passé ?
<ul>
<li>dans ce cas il risque de compromettre le bon fonctionnement de son appelant</li>
</ul></li>
<li>Comment prévenir l’appelant que son exécution ne s’est pas déroulée correctement ? quel mécanisme utiliser pour renvoyer ?
<ul>
<li>une valeur indiquant une erreur</li>
<li>un événement inattendu ?</li>
</ul></li>
</ul>
<p>Et de tous les appelants de la chaîne, quel est celui qui doit traiter l’événement exceptionnel ?</p>
<p>Java propose un mécanisme puissant permettant de gérer tous ces cas de figure</p>
</div>
<h2 id="traitement-des-événements-exceptionnels-en-java">Traitement des événements exceptionnels en Java</h2>
<p>Les exceptions sont des anomalies susceptibles de se produire dans un programme Java, écartant celui—ci du comportement normal ou souhaité.</p>
<p>On dit alors qu’une exception est <strong>levée</strong>.</p>
<p>Les origines des exceptions sont diverses :</p>
<ul>
<li>manque de mémoire,</li>
<li>division par zéro,</li>
<li>tentative d’ouverture d’un fichier inexistant,</li>
<li>etc.</li>
</ul>
<p>Le comportement à adopter sera différent suivant la nature des exceptions.</p>
<p>Le compilateur Java impose la gestion des exceptions lorsque vous tentez d’utiliser des méthodes prévoyants des exceptions.</p>
<p><strong>Par exemple</strong>, la méthode <a href="https://docs.oracle.com/javase/8/docs/api/java/io/DataInputStream.html"><code>readShort</code> de la classe <code>DataInputStream</code></a> qui lit depuis un fichier peut éventuellement lever des exceptions <code>IOException</code>; elle est donc définie avec un modificateur spécial <code>throws</code> qui signale ces erreurs potentielles.</p>
<div class="sourceCode" id="cb1"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb1-1" data-line-number="1"></a>
<a class="sourceLine" id="cb1-2" data-line-number="2"><span class="kw">public</span> <span class="dt">final</span> <span class="dt">short</span> <span class="fu">readShort</span>() <span class="kw">throws</span> <span class="bu">IOException</span></a></code></pre></div>
<h2 id="exemples-de-code">Exemples de code</h2>
<h3 id="traitement-facultatif">Traitement facultatif</h3>
<p>Un exemple d’exception dont le traitement n’est pas imposé :</p>
<div class="sourceCode" id="cb2"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb2-1" data-line-number="1"><span class="kw">public</span> <span class="kw">class</span> ExceptionDemo {</a>
<a class="sourceLine" id="cb2-2" data-line-number="2">    <span class="kw">public</span> <span class="dt">void</span> <span class="fu">testTableau</span>(){</a>
<a class="sourceLine" id="cb2-3" data-line-number="3">        <span class="dt">int</span>[] tableauEntier = <span class="kw">new</span> <span class="dt">int</span>[<span class="dv">5</span>];</a>
<a class="sourceLine" id="cb2-4" data-line-number="4">        tableauEntier[<span class="dv">6</span>] = <span class="dv">12</span>; <span class="co">//On est en dehors des limites du tableau</span></a>
<a class="sourceLine" id="cb2-5" data-line-number="5">    }</a>
<a class="sourceLine" id="cb2-6" data-line-number="6"></a>
<a class="sourceLine" id="cb2-7" data-line-number="7">    <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="cb2-8" data-line-number="8">        <span class="kw">new</span> <span class="fu">ExceptionDemo</span>().<span class="fu">testTableau</span>(); <span class="co">//ArrayIndexOutOfBoundsException</span></a>
<a class="sourceLine" id="cb2-9" data-line-number="9">    }</a>
<a class="sourceLine" id="cb2-10" data-line-number="10">}</a></code></pre></div>
<h3 id="traitement-imposé-à-la-compilation">Traitement imposé à la compilation</h3>
<p>Un exemple d’exception dont le traitement est imposé par le compilateur:</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="kw">import</span><span class="im"> java.io.File;</span></a>
<a class="sourceLine" id="cb3-2" data-line-number="2"><span class="kw">import</span><span class="im"> java.io.FileInputStream;</span></a>
<a class="sourceLine" id="cb3-3" data-line-number="3"><span class="kw">public</span> <span class="kw">class</span> ExceptionDemo {</a>
<a class="sourceLine" id="cb3-4" data-line-number="4">  <span class="kw">public</span> <span class="dt">void</span> <span class="fu">testFichier</span>(){</a>
<a class="sourceLine" id="cb3-5" data-line-number="5">    <span class="bu">File</span> file = <span class="kw">new</span> <span class="bu">File</span>(<span class="st">&quot;NExistePas.txt&quot;</span>);</a>
<a class="sourceLine" id="cb3-6" data-line-number="6">    <span class="co">//Ci-dessous: ERREUR de COMPILATION</span></a>
<a class="sourceLine" id="cb3-7" data-line-number="7">    <span class="co">//Unhandled exception type FileNotFoundException    ExceptionDemo.java</span></a>
<a class="sourceLine" id="cb3-8" data-line-number="8">    <span class="bu">FileInputStream</span> fis = <span class="kw">new</span> <span class="bu">FileInputStream</span>(file);</a>
<a class="sourceLine" id="cb3-9" data-line-number="9">    }</a>
<a class="sourceLine" id="cb3-10" data-line-number="10">    <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="cb3-11" data-line-number="11">    <span class="kw">new</span> <span class="fu">ExceptionDemo</span>().<span class="fu">testFichier</span>();</a>
<a class="sourceLine" id="cb3-12" data-line-number="12">  }</a>
<a class="sourceLine" id="cb3-13" data-line-number="13">}</a></code></pre></div>
<h3 id="exemple-readshort">Exemple : readShort</h3>
<p>Cet exemple montre la méthode <code>readShort</code> lève une exception:</p>
<div class="sourceCode" id="cb4"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb4-1" data-line-number="1"><span class="bu">File</span> f = <span class="kw">new</span> <span class="bu">File</span>(filename);</a>
<a class="sourceLine" id="cb4-2" data-line-number="2"></a>
<a class="sourceLine" id="cb4-3" data-line-number="3">FileInputstream fis = <span class="kw">new</span> <span class="bu">FileInputStream</span>(f);</a>
<a class="sourceLine" id="cb4-4" data-line-number="4"><span class="bu">BufferedInputStream</span> bis = <span class="kw">new</span> <span class="bu">BufferedInputStream</span>(fis,(<span class="dt">int</span>)f.<span class="fu">length</span>());</a>
<a class="sourceLine" id="cb4-5" data-line-number="5"><span class="bu">DataInputStream</span> dis = <span class="kw">new</span> <span class="bu">DataInputStream</span>(bis);</a>
<a class="sourceLine" id="cb4-6" data-line-number="6"></a>
<a class="sourceLine" id="cb4-7" data-line-number="7"><span class="dt">short</span> magicNumber = dis.<span class="fu">readShort</span>(); <span class="co">//Levée d&#39;IOException</span></a></code></pre></div>
<p>La méthode <code>readshort</code> est définie comme suit :</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="dt">final</span> <span class="dt">short</span> <span class="fu">readShort</span>() <span class="kw">throws</span> <span class="bu">IOException</span></a></code></pre></div>
<p>En Java on est obligé de traiter les exceptions dans le code, sinon il ne peut être compilé et le message suivant est affiché :</p>
<pre><code>Exception java.lang.InterruptedException
must be caught or it must be declared in the throws clause of this method.</code></pre>
<p>La méthode <code>readShort</code> levant une exception, le code de l’exemple précédent ne passe pas à la compilation.</p>
<h1 id="gestion-des-exceptions">Gestion des exceptions</h1>
<p>Lorsqu’une exception est levée, le déroulement du code est interrompu et le traitement des exceptions consiste alors à rechercher quelles dispositions prendre.</p>
<p>Au niveau de la programmation, il est possible de prévoir deux modes de codage :</p>
<ol type="1">
<li>Soit la méthode dont le code a été interrompu dispose des informations suffisantes</li>
</ol>
<p>pour corriger certaines anomalies observées</p>
<pre><code>(ou bien pour émettre des messages d’erreur explicites).</code></pre>
<p>Dans ce cas, la méthode décide de traiter elle-même certaines exceptions dans des <em>blocs <code>catch</code></em> associés à un <em>bloc <code>try</code></em>.</p>
<ol start="2" type="1">
<li>Soit la méthode concernée ne dispose pas elle-même des informations suffisantes</li>
</ol>
<p>pour traiter certains types d’exceptions,</p>
<pre><code>mais les méthodes appelantes peuvent disposer de ces informations.</code></pre>
<p>Dans ce cas les exceptions sont déclarées dans la <em>clause <code>throws</code></em> de la signature de la méthode afin que les méthodes appelantes soient informées des types d’exccptions susceptibles d’être levées par une méthode.</p>
<h2 id="traitement-dans-la-méthode-où-lexception-se-produit">Traitement dans la méthode où l’exception se produit</h2>
<p>Reprenons l’exemple précédent :</p>
<div class="sourceCode" id="cb9"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb9-1" data-line-number="1"><span class="kw">public</span> <span class="dt">void</span> <span class="fu">lireImageRGB</span>(<span class="bu">String</span> filename ) {</a>
<a class="sourceLine" id="cb9-2" data-line-number="2">  <span class="bu">File</span> f = <span class="kw">new</span> <span class="bu">File</span>(filename);</a>
<a class="sourceLine" id="cb9-3" data-line-number="3"></a>
<a class="sourceLine" id="cb9-4" data-line-number="4">  FileInputstream fis = <span class="kw">new</span> <span class="bu">FileInputStream</span>(f);</a>
<a class="sourceLine" id="cb9-5" data-line-number="5">  BufferedInputstream bis = <span class="kw">new</span> <span class="bu">BufferedInputStream</span>(fis,(<span class="dt">int</span>)f.<span class="fu">length</span>());</a>
<a class="sourceLine" id="cb9-6" data-line-number="6">  DataInputstream dis = <span class="kw">new</span> <span class="bu">DataInputStream</span>(bis);</a>
<a class="sourceLine" id="cb9-7" data-line-number="7"></a>
<a class="sourceLine" id="cb9-8" data-line-number="8">  <span class="dt">short</span> magicNumber = dis.<span class="fu">readShort</span>();</a>
<a class="sourceLine" id="cb9-9" data-line-number="9">  <span class="co">//...</span></a>
<a class="sourceLine" id="cb9-10" data-line-number="10">}</a></code></pre></div>
<p>La première étape consiste à inclure le code susceptible de lever des exceptions dans un <em>bloc <code>try { ... }</code></em></p>
<p>A un <em>bloc <code>try</code></em> doivent être associées une ou plusieurs <em>clauses <code>catch</code></em> et éventuellement un <em>bloc <code>finally</code></em>.</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">public</span> <span class="dt">void</span> <span class="fu">lireImageRGB</span>(<span class="bu">String</span> filename ) {</a>
<a class="sourceLine" id="cb10-2" data-line-number="2">    <span class="kw">try</span> {</a>
<a class="sourceLine" id="cb10-3" data-line-number="3">      <span class="bu">File</span> f = <span class="kw">new</span> <span class="bu">File</span>(filename);</a>
<a class="sourceLine" id="cb10-4" data-line-number="4">      <span class="bu">FileInputStream</span> fis = <span class="kw">new</span> <span class="bu">FileInputStream</span>(f);</a>
<a class="sourceLine" id="cb10-5" data-line-number="5">      <span class="bu">BufferedInputStream</span> bis = <span class="kw">new</span> <span class="bu">BufferedInputStream</span>(fis,(<span class="dt">int</span>)f.<span class="fu">length</span>());</a>
<a class="sourceLine" id="cb10-6" data-line-number="6">      <span class="bu">DataInputStream</span> dis = <span class="kw">new</span> <span class="bu">DataInputStream</span>(bis);</a>
<a class="sourceLine" id="cb10-7" data-line-number="7">      <span class="dt">short</span> magicNumber = dis.<span class="fu">readShort</span>();</a>
<a class="sourceLine" id="cb10-8" data-line-number="8">    }</a>
<a class="sourceLine" id="cb10-9" data-line-number="9">    <span class="kw">catch</span> ( <span class="bu">Exception</span> e ) {</a>
<a class="sourceLine" id="cb10-10" data-line-number="10">      <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(<span class="st">&quot; exception: &quot;</span> + e.<span class="fu">getMessage</span>());</a>
<a class="sourceLine" id="cb10-11" data-line-number="11">      e.<span class="fu">printStackTrace</span>();</a>
<a class="sourceLine" id="cb10-12" data-line-number="12">    }</a>
<a class="sourceLine" id="cb10-13" data-line-number="13">}</a></code></pre></div>
<p>Ou plus finement (il est <strong>toujours préférable</strong> de gérer les exceptions selon leur type) :</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">import</span><span class="im"> java.io.BufferedInputStream;</span></a>
<a class="sourceLine" id="cb11-2" data-line-number="2"><span class="kw">import</span><span class="im"> java.io.DataInputStream;</span></a>
<a class="sourceLine" id="cb11-3" data-line-number="3"><span class="kw">import</span><span class="im"> java.io.File;</span></a>
<a class="sourceLine" id="cb11-4" data-line-number="4"><span class="kw">import</span><span class="im"> java.io.FileInputStream;</span></a>
<a class="sourceLine" id="cb11-5" data-line-number="5"><span class="kw">import</span><span class="im"> java.io.FileNotFoundException;</span></a>
<a class="sourceLine" id="cb11-6" data-line-number="6"><span class="kw">import</span><span class="im"> java.io.IOException;</span></a>
<a class="sourceLine" id="cb11-7" data-line-number="7"><span class="kw">public</span> <span class="kw">class</span> GestionExceptionProgramme {</a>
<a class="sourceLine" id="cb11-8" data-line-number="8">    <span class="kw">public</span> <span class="dt">void</span> <span class="fu">lireImageRGB</span>(<span class="bu">String</span> filename ) {</a>
<a class="sourceLine" id="cb11-9" data-line-number="9">        <span class="bu">DataInputStream</span> dis = <span class="kw">null</span>;</a>
<a class="sourceLine" id="cb11-10" data-line-number="10">        <span class="kw">try</span> {</a>
<a class="sourceLine" id="cb11-11" data-line-number="11">            <span class="bu">File</span> f = <span class="kw">new</span> <span class="bu">File</span>(filename);</a>
<a class="sourceLine" id="cb11-12" data-line-number="12">            <span class="bu">FileInputStream</span> fis = <span class="kw">new</span> <span class="bu">FileInputStream</span>(f);</a>
<a class="sourceLine" id="cb11-13" data-line-number="13">            <span class="bu">BufferedInputStream</span> bis = <span class="kw">new</span> <span class="bu">BufferedInputStream</span>(fis,(<span class="dt">int</span>)f.<span class="fu">length</span>());</a>
<a class="sourceLine" id="cb11-14" data-line-number="14">            dis = <span class="kw">new</span> <span class="bu">DataInputStream</span>(bis);</a>
<a class="sourceLine" id="cb11-15" data-line-number="15">            <span class="dt">short</span> magicNumber = dis.<span class="fu">readShort</span> () ;</a>
<a class="sourceLine" id="cb11-16" data-line-number="16">        }</a>
<a class="sourceLine" id="cb11-17" data-line-number="17">        <span class="kw">catch</span> ( <span class="bu">FileNotFoundException</span> f ) { <span class="co">// sous—classe de IOException</span></a>
<a class="sourceLine" id="cb11-18" data-line-number="18">            <span class="bu">System</span>.<span class="fu">err</span>.<span class="fu">println</span>(<span class="st">&quot;exception: &quot;</span> + f.<span class="fu">getMessage</span>());</a>
<a class="sourceLine" id="cb11-19" data-line-number="19">            f.<span class="fu">printStackTrace</span>();</a>
<a class="sourceLine" id="cb11-20" data-line-number="20">        }</a>
<a class="sourceLine" id="cb11-21" data-line-number="21">        <span class="kw">catch</span> ( <span class="bu">IOException</span> e ) { <span class="co">// sous—classe de Exception</span></a>
<a class="sourceLine" id="cb11-22" data-line-number="22">            <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(<span class="st">&quot;exception: &quot;</span> + e.<span class="fu">getMessage</span>());</a>
<a class="sourceLine" id="cb11-23" data-line-number="23">            e.<span class="fu">printStackTrace</span>();</a>
<a class="sourceLine" id="cb11-24" data-line-number="24">        }</a>
<a class="sourceLine" id="cb11-25" data-line-number="25">        <span class="kw">finally</span> { <span class="co">//Ferme proprement le fichier</span></a>
<a class="sourceLine" id="cb11-26" data-line-number="26">            <span class="kw">try</span> {</a>
<a class="sourceLine" id="cb11-27" data-line-number="27">                <span class="kw">if</span> (dis != <span class="kw">null</span>){ dis.<span class="fu">close</span>(); }</a>
<a class="sourceLine" id="cb11-28" data-line-number="28">            } <span class="kw">catch</span> (<span class="bu">IOException</span> e) {</a>
<a class="sourceLine" id="cb11-29" data-line-number="29">                e.<span class="fu">printStackTrace</span>();</a>
<a class="sourceLine" id="cb11-30" data-line-number="30">            }</a>
<a class="sourceLine" id="cb11-31" data-line-number="31">        }</a>
<a class="sourceLine" id="cb11-32" data-line-number="32">    }</a>
<a class="sourceLine" id="cb11-33" data-line-number="33">    <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="cb11-34" data-line-number="34">        <span class="kw">new</span> <span class="fu">GestionExceptionProgramme</span>()</a>
<a class="sourceLine" id="cb11-35" data-line-number="35">          .<span class="fu">lireImageRGB</span>(<span class="st">&quot;UnFichierInexistant.jpg&quot;</span>);</a>
<a class="sourceLine" id="cb11-36" data-line-number="36">    }</a>
<a class="sourceLine" id="cb11-37" data-line-number="37">}</a></code></pre></div>
<p>Le <em>bloc <code>try</code></em> commence avant la ligne <code>File f = new File(filename);</code> car le constructeur de la classe <code>File</code> peut lui aussi lever une exception de type <code>NullPointerException</code>, dans le cas où le nom de fichier passé en paramètre est égal à <code>null</code>.</p>
<p>Si une exception se produit dans un <em>bloc <code>try</code></em>, l’exécution de code est interrompue et les <em>clauses <code>catch</code></em> qui lui sont associées sont examinées dans l’ordre pour chercher si l’unc d’elles a prévu un traitement de l’exception produite. Les <em>clauses <code>catch</code></em> sont comme des méthodes recevant un seul argument.</p>
<p>Si une <em>clause <code>catch</code></em> correspond à l’exception, elle prend le contrôle de l’exécution.</p>
<p>Le code d’un bloc associé à une <em>clause <code>finally</code></em> est exécuté dans tous les cas, soit après une exécution normale du <em>bloc <code>try</code></em> soit après traitement d’une exception</p>
<h2 id="traitement-dans-la-méthode-appelante">Traitement dans la méthode appelante</h2>
<p>Pour indiquer que l’<code>Exception</code> n’est pas gérée dans la méthode <code>lireImageRGB()</code> et que par conséquent, elle le sera dans la méthode appelante, on utilise la <em>clause <code>throws</code></em>.</p>
<p>Reprenons l’exemple précédent :</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">public</span> <span class="dt">void</span> <span class="fu">lireImageRGB</span>(<span class="bu">String</span> filename ) <span class="kw">throws</span> <span class="bu">Exception</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="bu">File</span> f = <span class="kw">new</span> <span class="bu">File</span>(filename);</a>
<a class="sourceLine" id="cb12-4" data-line-number="4"></a>
<a class="sourceLine" id="cb12-5" data-line-number="5">  <span class="bu">FileInputStream</span> fis = <span class="kw">new</span> <span class="bu">FileInputStream</span>(f);</a>
<a class="sourceLine" id="cb12-6" data-line-number="6">  <span class="bu">BufferedInputStream</span> bis = <span class="kw">new</span> <span class="bu">BufferedInputStream</span>(fis, (<span class="dt">int</span>)f.<span class="fu">length</span>());</a>
<a class="sourceLine" id="cb12-7" data-line-number="7">  <span class="bu">DataInputStream</span> dis = <span class="kw">new</span> <span class="bu">DataInputStream</span>(bis);</a>
<a class="sourceLine" id="cb12-8" data-line-number="8"></a>
<a class="sourceLine" id="cb12-9" data-line-number="9">  <span class="dt">short</span> magicNumber = dis.<span class="fu">readShort</span>();</a>
<a class="sourceLine" id="cb12-10" data-line-number="10"></a>
<a class="sourceLine" id="cb12-11" data-line-number="11">}</a></code></pre></div>
<p>ou plus finement</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">public</span> <span class="dt">void</span> <span class="fu">lireImageRGB</span>(<span class="bu">String</span> filename )</a>
<a class="sourceLine" id="cb13-2" data-line-number="2">    <span class="kw">throws</span>  <span class="bu">FileNotFoundException</span>,</a>
<a class="sourceLine" id="cb13-3" data-line-number="3">            <span class="bu">IOException</span>  {</a>
<a class="sourceLine" id="cb13-4" data-line-number="4"></a>
<a class="sourceLine" id="cb13-5" data-line-number="5">  <span class="bu">File</span> f = <span class="kw">new</span> <span class="bu">File</span>(filename);</a>
<a class="sourceLine" id="cb13-6" data-line-number="6">  <span class="bu">FileInputStream</span> fis = <span class="kw">new</span> <span class="bu">FileInputStream</span>(f);</a>
<a class="sourceLine" id="cb13-7" data-line-number="7">  <span class="bu">BufferedInputStream</span> bis = <span class="kw">new</span> <span class="bu">BufferedInputStream</span>(fis, (<span class="dt">int</span>)f.<span class="fu">length</span>());</a>
<a class="sourceLine" id="cb13-8" data-line-number="8">  <span class="bu">DataInputStream</span> dis = <span class="kw">new</span> <span class="bu">DataInputStream</span>(bis);</a>
<a class="sourceLine" id="cb13-9" data-line-number="9">  <span class="dt">short</span> magicNumber = dis.<span class="fu">readShort</span>();</a>
<a class="sourceLine" id="cb13-10" data-line-number="10">}</a></code></pre></div>
<h1 id="types-dexceptions">Types d’exceptions</h1>
<h2 id="le-type-throwable">Le type Throwable</h2>
<p>Une exception est un objet (instance d’une classe qui hérite de la classe <code>Throwable</code>) qui possède des données et des méthodes membres.</p>
<figure>
<img src="images/ClassesException.png" alt="La classe Exception" /><figcaption>La classe <code>Exception</code></figcaption>
</figure>
<p><code>Throwable</code> a deux sous-classes : <code>Error</code> et <code>Exception</code>.</p>
<p>Les instances d’<code>Error</code> sont des erreurs internes de l’environnement d’exécution Java (la machine virtuelle). Ces erreurs sont rares, et habituellement fatales; ces exceptions ne doivent pas être levées, ni capturées dans un programme.</p>
<p>Les sous-classes d’<code>Exception</code> sont réparties entre deux catégories :</p>
<h2 id="exceptions-non-vérifiées">Exceptions non vérifiées</h2>
<h3 id="runtime-exception">Runtime Exception</h3>
<p>Un bloc <code>try/catch</code> n’est pas imposé pour traiter ces exceptions</p>
<ul>
<li>Les exceptions d’exécution (<em>runtime exceptions</em>), sous-classes de la classe <code>RuntimeException</code> telles que:
<ul>
<li>ArrayIndexOutOfBoundsException</li>
<li>SecurityException,</li>
<li>ou NullPointerException.</li>
</ul>
<p>Ces exceptions sont généralement liées à un défaut de robustesse du code.</p>
<p>Mettre des <code>try/catch</code> pour ces exceptions rendrait le code illisible.</p></li>
</ul>
<h3 id="error">Error</h3>
<p>Les erreurs font parties des objets Throwables non vérifiés:</p>
<ul>
<li>il n’est pas imposé d’écrire un bloc <code>try...catch</code> pour les gérer</li>
</ul>
<h2 id="exceptions-vérifiées">Exceptions vérifiées</h2>
<h3 id="exceptions-à-traiter-obligatoirement">Exceptions à traiter obligatoirement</h3>
<p>Bloc <code>try/catch</code> obligatoire</p>
<ul>
<li>Exceptions qui correspondent à des évènements <em>anormaux</em>, échappant au contrôle du programme</li>
</ul>
<h3 id="exemples-dévénements-anormaux">Exemples d’événements anormaux</h3>
<ul>
<li><code>EOFException</code>
<ul>
<li>se produit lorsque vous lisez dans un fichier</li>
<li>et que celui-ci se termine prématurément.</li>
</ul></li>
</ul>
<h2 id="hiérarchie-de-classes">Hiérarchie de classes</h2>
<p>La hiérarchie des exceptions est comme celle des autres classes, les super-classes correspondant à des erreurs plus générales, et les sous-classes à des erreurs plus spécifiques.</p>
<p>La plupart des exceptions font partie du package <code>java.lang</code> (qui inclut <code>Throwable</code>, <code>Exception</code> et <code>RuntimeException</code>). Mais un grand nombre d’autres packages définissent d’autres exceptions, et ces exceptions sont utilisées dans toute la bibliothèque de classes.</p>
<p><strong>Par exemple</strong></p>
<p>Le package <code>java.io</code> définit une classe générale d’exceptions appelée <code>IOException</code>, qui est sous-classée non seulement dans le package <code>java.io</code> pour les exceptions (d’entrée et de sortie (<code>EOFException</code>, <code>FileNotFoundException</code>), mais aussi dans les classes du package <code>java.net</code> pour les exceptions de réseau telles que <code>MalFormedURLException</code>.</p>
<p>Ci dessous, est représentée une partie de la hiérarchie des exceptions.</p>
<div class="nonincremental">
<ul>
<li><p><code>java.lang.Exception</code></p>
<ul>
<li><code>java.lang.ClassNotFoundException</code></li>
<li><code>java.lang.CloneNotSupportedException</code></li>
<li><code>java.lang.IllegalAccessException</code></li>
<li><code>java.lang.InstantiationException</code></li>
<li><code>java.lang.InterruptedException</code></li>
<li><code>java.lang.NoSuchFieldException</code></li>
<li><code>java.lang.NoSuchMethodException</code></li>
<li><p><code>java.lang.RuntimeException</code></p>
<ul>
<li><code>java.lang.ArithmeticException</code></li>
<li><code>java.lang.ArrayStoreException</code></li>
<li><code>java.lang.ClassCastException</code></li>
<li><code>java.lang.IllegalArgumentException</code>
<ul>
<li><code>java.lang.NumberFormatException</code></li>
</ul></li>
<li><code>java.lang.IllegalMonitorStateException</code></li>
<li><code>java.lang.IllegalStateException</code></li>
<li><code>java.lang.IndexOutOfBoundsException</code>
<ul>
<li><code>java.lang.ArrayIndexOutOfBoundsException</code></li>
<li><code>java.lang.StringIndexOutOfBoundsException</code></li>
</ul></li>
<li><code>java.lang.NegativeArraySizeException</code></li>
<li><code>java.lang.NullPointerException</code></li>
<li><code>java.lang.SecurityException</code></li>
<li><code>java.lang.UnsupportedOperationException</code></li>
</ul></li>
<li><p><code>java.io.IOException</code></p>
<ul>
<li><code>java.io.CharConversionException</code></li>
<li><code>java.io.FileNotFoundException</code></li>
<li><code>java.io.InterruptedIOException</code></li>
<li><code>java.io.ObjectStreamException</code></li>
</ul></li>
</ul></li>
</ul>
</div>
<h1 id="exemple-concret">Exemple concret</h1>
<p>Prenons l’exemple suivant :</p>
<div class="sourceCode" id="cb14"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb14-1" data-line-number="1"></a>
<a class="sourceLine" id="cb14-2" data-line-number="2"><span class="kw">public</span> <span class="kw">class</span> ExceptionCatch {</a>
<a class="sourceLine" id="cb14-3" data-line-number="3">    <span class="dt">int</span> <span class="fu">moyenne</span>(<span class="bu">String</span>[] liste) {</a>
<a class="sourceLine" id="cb14-4" data-line-number="4">        <span class="dt">int</span> somme = <span class="dv">0</span>, entier, nbNotes = <span class="dv">0</span>;</a>
<a class="sourceLine" id="cb14-5" data-line-number="5">        <span class="kw">for</span> (<span class="dt">int</span> i = <span class="dv">0</span>; i &lt; liste.<span class="fu">length</span>;i++) {</a>
<a class="sourceLine" id="cb14-6" data-line-number="6">            <span class="kw">try</span> {</a>
<a class="sourceLine" id="cb14-7" data-line-number="7">                entier = <span class="bu">Integer</span>.<span class="fu">parseInt</span>(liste[i]);</a>
<a class="sourceLine" id="cb14-8" data-line-number="8">                somme += entier;</a>
<a class="sourceLine" id="cb14-9" data-line-number="9">                nbNotes++;</a>
<a class="sourceLine" id="cb14-10" data-line-number="10">            }</a>
<a class="sourceLine" id="cb14-11" data-line-number="11">            <span class="kw">catch</span> (<span class="bu">NumberFormatException</span> e) {</a>
<a class="sourceLine" id="cb14-12" data-line-number="12">                <span class="kw">if</span> ( i == <span class="dv">0</span> ) {</a>
<a class="sourceLine" id="cb14-13" data-line-number="13">                    <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(<span class="st">&quot;La 1ere note n&#39;est pas entiere&quot;</span>);</a>
<a class="sourceLine" id="cb14-14" data-line-number="14">                }</a>
<a class="sourceLine" id="cb14-15" data-line-number="15">                <span class="kw">else</span> {</a>
<a class="sourceLine" id="cb14-16" data-line-number="16">                    <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(<span class="st">&quot;La &quot;</span>+(i+<span class="dv">1</span>)+<span class="st">&quot;eme note n&#39;est pas entiere&quot;</span>);</a>
<a class="sourceLine" id="cb14-17" data-line-number="17">                }</a>
<a class="sourceLine" id="cb14-18" data-line-number="18">            }</a>
<a class="sourceLine" id="cb14-19" data-line-number="19">        }</a>
<a class="sourceLine" id="cb14-20" data-line-number="20">        <span class="kw">return</span> somme/nbNotes;</a>
<a class="sourceLine" id="cb14-21" data-line-number="21">    }</a>
<a class="sourceLine" id="cb14-22" data-line-number="22">    <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>[] argv) {</a>
<a class="sourceLine" id="cb14-23" data-line-number="23">        <span class="bu">String</span>[] liste = {<span class="st">&quot;1&quot;</span>, <span class="st">&quot;5&quot;</span>, <span class="st">&quot;toto&quot;</span>};</a>
<a class="sourceLine" id="cb14-24" data-line-number="24"></a>
<a class="sourceLine" id="cb14-25" data-line-number="25">        <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(</a>
<a class="sourceLine" id="cb14-26" data-line-number="26">                <span class="st">&quot;La moyenne est &quot;</span> + <span class="kw">new</span> <span class="fu">ExceptionCatch</span>().<span class="fu">moyenne</span>(liste));</a>
<a class="sourceLine" id="cb14-27" data-line-number="27">    }</a>
<a class="sourceLine" id="cb14-28" data-line-number="28">}</a></code></pre></div>
<p>On obtient en sortie:</p>
<pre><code>La 3eme note n&#39;est pas entiere
La moyenne est 3</code></pre>
<p>Si on remplace la ligne</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="bu">String</span>[] liste = {<span class="st">&quot;1&quot;</span>, <span class="st">&quot;5&quot;</span>, <span class="st">&quot;toto&quot;</span>};</a></code></pre></div>
<p>Par</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="bu">String</span>[] liste = {<span class="st">&quot;toto&quot;</span>, <span class="st">&quot;15.5&quot;</span>};</a></code></pre></div>
<p>On obtient:</p>
<pre><code>La 1ere note n&#39;est pas entiere
La 2eme note n&#39;est pas entiere
Exception in thread &quot;main&quot; java.lang.ArithmeticException: / by zero
    at ExceptionCatch.moyenne(ExceptionCatch.java:20)
    at ExceptionCatch.main(ExceptionCatch.java:26)</code></pre>
<p>Dans cet exemple deux types d’exceptions peuvent être levées :</p>
<ul>
<li><code>java.lang.NumberFormatException</code> : lancée par la méthode parseInt: de la classe Integer si la chaine de caractères <code>liste[i]</code> ne correspond pas à un entier. Les instructions suivantes ne sont alors pas effectuées. Ici donc, si <code>liste[i]</code> ne décrit pas un entier, les deux instructions qui suivent :</li>
</ul>
<div class="sourceCode" id="cb19"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb19-1" data-line-number="1">  somme+=entier;</a>
<a class="sourceLine" id="cb19-2" data-line-number="2">  nbNotes++;</a></code></pre></div>
<p>ne sont pas effectuées, et on passe à l’instruction <code>println</code> intérieure au “<em>bloc <code>catch</code></em>”, puis on remonte dans la “boucle for” qui reprend son déroulement.</p>
<ul>
<li><code>java.lang.ArithmeticException</code> : si <code>nbNotes</code> vaut 0, une exception, instance de <code>java.lang.ArithmeticException</code> est lancée.</li>
</ul>
<p>Celle—ci n’étant pas attrapée, elle se propage alors jusqu’à la fin du programme, comme on peut le constater sur le deuxième exemple d’exécution.</p>
<p>Mais seule l’exception <code>java.lang.NumberFormatException</code> doit être obligatoirement traitée, soit localement (c’est le cas ici), soit dans la méthode appelante. En effet la méthode <code>parseInt</code> prévoyant cette exception, le compilateur oblige la gestion de l’exception dans le code.</p>
<h1 id="création-et-levée-de-vos-propres-exceptions">Création et levée de vos propres exceptions</h1>
<h2 id="création-dexception">Création d’exception</h2>
<p>Il est possible pour le programmeur de créer ses propres classes d’exception en héritant soit de la classe <code>Exception</code> (sommet de la hiérarchie des classes explicites), soit en cherchant une exception plus proche de celle que l’on veut créer. Par exemple : une exception pour un mauvais format de fichier doit normalement être une <code>IOException</code>.</p>
<p>Les classes d’exceptions ont typiquement deux constructeurs : le premier ne prend pas d’argument, et le second prend une seule chaîne comme argument. Dans le second, vous devez appeler <code>super()</code> dans le constructeur pour vous assurer que la chaine est utilisée au bon endroit dans l’exception.</p>
<p>Les classes d’exceptions ont le même aspect que d’autres classes. Vous pouvez les placer dans leur propres fichiers source et les compiler comme n’importe quelles autres classes.</p>
<h3 id="création-dexception-1">Création d’exception</h3>
<div class="sourceCode" id="cb20"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb20-1" data-line-number="1"><span class="kw">public</span> <span class="kw">class</span> NotesNonValidesException <span class="kw">extends</span> <span class="bu">Exception</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="fu">NotesNonValidesException</span>(<span class="bu">String</span> message) {</a>
<a class="sourceLine" id="cb20-4" data-line-number="4">    <span class="co">// message sera utilisé</span></a>
<a class="sourceLine" id="cb20-5" data-line-number="5">        <span class="kw">super</span>(message); <span class="co">// par la méthode getMessage()</span></a>
<a class="sourceLine" id="cb20-6" data-line-number="6">    }</a>
<a class="sourceLine" id="cb20-7" data-line-number="7"></a>
<a class="sourceLine" id="cb20-8" data-line-number="8">    <span class="kw">public</span> <span class="bu">String</span> <span class="fu">toString</span>() {</a>
<a class="sourceLine" id="cb20-9" data-line-number="9">        <span class="co">// Rappel : cette méthode permet</span></a>
<a class="sourceLine" id="cb20-10" data-line-number="10">        <span class="co">// de convertir l&#39;objet en une</span></a>
<a class="sourceLine" id="cb20-11" data-line-number="11">        <span class="kw">return</span>(<span class="st">&quot;Aucune note n&#39;est valide&quot;</span>); <span class="co">// chaîne de caractères</span></a>
<a class="sourceLine" id="cb20-12" data-line-number="12">    }</a>
<a class="sourceLine" id="cb20-13" data-line-number="13">}</a></code></pre></div>
<h2 id="levée-dexception">Levée d’exception</h2>
<p>L’exception est levée dans le code à l’aide de la <em>clause <code>throw</code></em>.</p>
<p>Reprenons l’exemple précédent (<code>ExceptionCatch</code>). Imaginons que nous voulions éviter, l’exception <code>java.lang.ArithmeticException</code>.</p>
<p>Une solution consiste à tester si <code>nbNotes == 0</code>, avant d’effectuer le calcul de la moyenne et à signaler le problème en levant l’exception créée précédemment (<code>NotesNonValidesException</code>).</p>
<h3 id="programme">Programme</h3>
<div class="sourceCode" id="cb21"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb21-1" data-line-number="1"></a>
<a class="sourceLine" id="cb21-2" data-line-number="2"><span class="kw">public</span> <span class="kw">class</span> TraiterNotes {</a>
<a class="sourceLine" id="cb21-3" data-line-number="3">    <span class="dt">static</span> <span class="dt">int</span> <span class="fu">moyenne</span>(<span class="bu">String</span>[] liste) <span class="kw">throws</span> NotesNonValidesException {</a>
<a class="sourceLine" id="cb21-4" data-line-number="4">        <span class="dt">int</span> somme = <span class="dv">0</span>,entier, nbNotes = <span class="dv">0</span>;</a>
<a class="sourceLine" id="cb21-5" data-line-number="5">        <span class="kw">for</span> (<span class="dt">int</span> i = <span class="dv">0</span>; i &lt; liste.<span class="fu">length</span>;i++){</a>
<a class="sourceLine" id="cb21-6" data-line-number="6">            <span class="kw">try</span> {</a>
<a class="sourceLine" id="cb21-7" data-line-number="7">                entier = <span class="bu">Integer</span>.<span class="fu">parseInt</span>(liste[i]);</a>
<a class="sourceLine" id="cb21-8" data-line-number="8">                somme += entier;</a>
<a class="sourceLine" id="cb21-9" data-line-number="9">                nbNotes++;</a>
<a class="sourceLine" id="cb21-10" data-line-number="10">            }</a>
<a class="sourceLine" id="cb21-11" data-line-number="11">            <span class="kw">catch</span> (<span class="bu">NumberFormatException</span> e) {</a>
<a class="sourceLine" id="cb21-12" data-line-number="12">        <span class="bu">String</span> msg = <span class="st">&quot;n&#39;est pas entiere&quot;</span>;</a>
<a class="sourceLine" id="cb21-13" data-line-number="13">                <span class="kw">if</span> (i == <span class="dv">0</span>) {</a>
<a class="sourceLine" id="cb21-14" data-line-number="14">              msg = <span class="st">&quot;La 1ere note &quot;</span> + msg ;}</a>
<a class="sourceLine" id="cb21-15" data-line-number="15">                <span class="kw">else</span>{ msg = <span class="st">&quot;La &quot;</span>+(i+<span class="dv">1</span>)+<span class="st">&quot; note &quot;</span> + msg ;}</a>
<a class="sourceLine" id="cb21-16" data-line-number="16">            }</a>
<a class="sourceLine" id="cb21-17" data-line-number="17">        }</a>
<a class="sourceLine" id="cb21-18" data-line-number="18">        <span class="kw">if</span> (nbNotes == <span class="dv">0</span>){ <span class="kw">throw</span> <span class="kw">new</span> <span class="fu">NotesNonValidesException</span>(<span class="st">&quot;Dommage&quot;</span>); }</a>
<a class="sourceLine" id="cb21-19" data-line-number="19"></a>
<a class="sourceLine" id="cb21-20" data-line-number="20">        <span class="kw">return</span> somme/nbNotes;</a>
<a class="sourceLine" id="cb21-21" data-line-number="21">    }</a>
<a class="sourceLine" id="cb21-22" data-line-number="22"></a>
<a class="sourceLine" id="cb21-23" data-line-number="23">    <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>[] argv) {</a>
<a class="sourceLine" id="cb21-24" data-line-number="24">        <span class="kw">try</span> {</a>
<a class="sourceLine" id="cb21-25" data-line-number="25">            <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(<span class="st">&quot;La moyenne est &quot;</span>+<span class="fu">moyenne</span>(argv));</a>
<a class="sourceLine" id="cb21-26" data-line-number="26">        }</a>
<a class="sourceLine" id="cb21-27" data-line-number="27">        <span class="kw">catch</span> (NotesNonValidesException e) {</a>
<a class="sourceLine" id="cb21-28" data-line-number="28">            <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(e);</a>
<a class="sourceLine" id="cb21-29" data-line-number="29">            <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(e.<span class="fu">getMessage</span>());</a>
<a class="sourceLine" id="cb21-30" data-line-number="30">        }</a>
<a class="sourceLine" id="cb21-31" data-line-number="31">    }</a>
<a class="sourceLine" id="cb21-32" data-line-number="32">}</a></code></pre></div>
<p>Pour :</p>
<pre><code>java TraiterNotes ha 15.5</code></pre>
<p>On obtient :</p>
<pre><code>La 1ere note n&#39;est: pas entière
La 2eme note n&#39;est pas entiere
Aucune note n&#39;est valide
Dommage</code></pre>
<h3 id="explications">Explications</h3>
<h5 id="throws-notesnonvalidesexception">throws NotesNonvalidesException</h5>
<p>La méthode <code>moyenne</code> indique ainsi qu’il est possible qu’une de ses instructions envoie une exception de type <code>NotesNonValidesException</code> sans que celle-ci soit attrapée par un mécanisme <code>try</code>-<code>catch</code>.</p>
<p>Il est obligatoire d’indiquer ainsi un éventuel lancement d’exception non attrapée, sauf pour les exceptions les plus courantes de l‘API (<code>RuntimeException</code>). Si vous oubliez de signaler par la <em>clause <code>throws</code></em> l’éventualité d’un tel lancement d’exception, le compilateur vous le rappelera.</p>
<h5 id="throw-new-notesnonvalidesexception">throw new NotesNonvalidesException()</h5>
<p>On demande ainsi le lancement d’une instance de <code>NotesNonvalidesException</code>. Une fois lancée, l’exception se propagera comme expliqué dans l’exemple précédent.</p>
<p>Ici, il y aura sortie de la méthode <code>moyenne</code>, on se retrouve alors à l’appel de la la méthode <code>moyenne</code> dans le main, appel qui se trouve dans un <em>bloc <code>try</code></em> suivi d’un <em>bloc <code>catch</code></em> qui attrape les <code>NotesNonValidesException</code> :</p>
<ul>
<li>l’instruction de ce <em>bloc <code>catch</code></em> est effectuée.</li>
<li>Le programme reprend alors son cours normal (pour se terminer).</li>
</ul>
<h1 id="exercices">Exercices</h1>
<h2 id="calcul">Calcul</h2>
<p>Reprendre le programme gérant les opérations mathématique (les sources sont disponibles <a href="data/ch3-Calculs.zip">ici</a>.</p>
<p>Ajoutez l’opération de <code>Division</code></p>
<p>Celle-ci devra lever une exception de division par zéro (nouvelle classe <code>DivisionParZeroException</code>). Bien choisir sa classe parente afin d’avoir un minimum de modifications à faire sur l’ensemble des classes (peut-être y a-t-il déjà une classe pouvant correspondre à ce type d’erreur dans l’API Java ?).</p>
<p>Tester ce programme en rajoutant une clause <code>catch</code> permettant d’afficher un message concernant l’erreur à l’utilisateur.</p>
<h2 id="le-nom-de-lexception">Le nom de l’exception</h2>
<p>Prenez les codes suivants et analysez-les:</p>
<ol type="1">
<li>renommer les exceptions en leur donnant un nom plus explicite.</li>
<li>déterminer comment lancer le programme sans qu’une erreur ne se produise depuis Eclipse (aller pour cela dans le menu <code>Run &gt; Run Configurations...</code> puis dans l’onglet <code>Arguments</code>)</li>
<li>que pensez-vous de la déclaration de la méthode <code>main</code> ? En quoi est-il utile d’indiquer la clause <code>throws</code> ici ?</li>
<li>modifier le code pour que la méthode <code>main</code> traite l’exception</li>
</ol>
<p>Classes E1:</p>
<div class="sourceCode" id="cb24"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb24-1" data-line-number="1"><span class="kw">package</span><span class="im"> com.example.exception;</span></a>
<a class="sourceLine" id="cb24-2" data-line-number="2"></a>
<a class="sourceLine" id="cb24-3" data-line-number="3"><span class="kw">public</span> <span class="kw">class</span> E1 <span class="kw">extends</span> <span class="bu">Exception</span> {</a>
<a class="sourceLine" id="cb24-4" data-line-number="4">    <span class="kw">public</span> <span class="fu">E1</span>(<span class="bu">String</span> mess) {</a>
<a class="sourceLine" id="cb24-5" data-line-number="5">        <span class="kw">super</span>(mess);</a>
<a class="sourceLine" id="cb24-6" data-line-number="6">    }</a>
<a class="sourceLine" id="cb24-7" data-line-number="7">}</a></code></pre></div>
<p>Classe E2:</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="kw">package</span><span class="im"> com.example.exception;</span></a>
<a class="sourceLine" id="cb25-2" data-line-number="2"></a>
<a class="sourceLine" id="cb25-3" data-line-number="3"><span class="kw">public</span> <span class="kw">class</span> E2 <span class="kw">extends</span> <span class="bu">Exception</span> {</a>
<a class="sourceLine" id="cb25-4" data-line-number="4">    <span class="kw">public</span> <span class="fu">E2</span>(<span class="bu">String</span> mess) {</a>
<a class="sourceLine" id="cb25-5" data-line-number="5">        <span class="kw">super</span>(mess);</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>Classe <code>AutoDivision</code> :</p>
<div class="sourceCode" id="cb26"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb26-1" data-line-number="1"><span class="kw">package</span><span class="im"> com.example.exception;</span></a>
<a class="sourceLine" id="cb26-2" data-line-number="2"></a>
<a class="sourceLine" id="cb26-3" data-line-number="3"><span class="kw">public</span> <span class="kw">class</span> AutoDivision {</a>
<a class="sourceLine" id="cb26-4" data-line-number="4">    <span class="kw">private</span> <span class="dt">double</span> x;</a>
<a class="sourceLine" id="cb26-5" data-line-number="5"></a>
<a class="sourceLine" id="cb26-6" data-line-number="6">    <span class="kw">public</span> <span class="fu">AutoDivision</span>(<span class="dt">double</span> x) {</a>
<a class="sourceLine" id="cb26-7" data-line-number="7">        <span class="kw">this</span>.<span class="fu">x</span> = x;</a>
<a class="sourceLine" id="cb26-8" data-line-number="8">    }</a>
<a class="sourceLine" id="cb26-9" data-line-number="9"></a>
<a class="sourceLine" id="cb26-10" data-line-number="10">    <span class="kw">public</span> <span class="dt">double</span> <span class="fu">getX</span>() {</a>
<a class="sourceLine" id="cb26-11" data-line-number="11">        <span class="kw">return</span> x;</a>
<a class="sourceLine" id="cb26-12" data-line-number="12">    }</a>
<a class="sourceLine" id="cb26-13" data-line-number="13"></a>
<a class="sourceLine" id="cb26-14" data-line-number="14">    <span class="kw">public</span> <span class="dt">void</span> <span class="fu">calculer</span>(<span class="dt">double</span> y) <span class="kw">throws</span> E1,E2 {</a>
<a class="sourceLine" id="cb26-15" data-line-number="15">        <span class="kw">if</span> (y == <span class="dv">0</span>){</a>
<a class="sourceLine" id="cb26-16" data-line-number="16">            <span class="kw">throw</span> <span class="kw">new</span> <span class="fu">E1</span>(<span class="st">&quot;Paramètre nul: le paramètre ne peut être égal à zéro&quot;</span>);</a>
<a class="sourceLine" id="cb26-17" data-line-number="17">        }</a>
<a class="sourceLine" id="cb26-18" data-line-number="18">        <span class="kw">if</span> (x * y &lt; <span class="dv">0</span>){</a>
<a class="sourceLine" id="cb26-19" data-line-number="19">            <span class="kw">throw</span> <span class="kw">new</span> <span class="fu">E2</span>(<span class="st">&quot;paramètre de signe opposé à x&quot;</span>);</a>
<a class="sourceLine" id="cb26-20" data-line-number="20">        }</a>
<a class="sourceLine" id="cb26-21" data-line-number="21">        x = x / y;</a>
<a class="sourceLine" id="cb26-22" data-line-number="22">    }</a>
<a class="sourceLine" id="cb26-23" data-line-number="23"></a>
<a class="sourceLine" id="cb26-24" data-line-number="24">    <span class="kw">public</span> <span class="dt">void</span> <span class="fu">executer</span>(<span class="dt">double</span> y) <span class="kw">throws</span> E1 {</a>
<a class="sourceLine" id="cb26-25" data-line-number="25">        <span class="kw">try</span> {</a>
<a class="sourceLine" id="cb26-26" data-line-number="26">            <span class="fu">calculer</span>(y);</a>
<a class="sourceLine" id="cb26-27" data-line-number="27">        }</a>
<a class="sourceLine" id="cb26-28" data-line-number="28">        <span class="kw">catch</span> (E2 e) {</a>
<a class="sourceLine" id="cb26-29" data-line-number="29">            <span class="bu">System</span>.<span class="fu">err</span>.<span class="fu">println</span>(e.<span class="fu">getMessage</span>());</a>
<a class="sourceLine" id="cb26-30" data-line-number="30">        }</a>
<a class="sourceLine" id="cb26-31" data-line-number="31">    }</a>
<a class="sourceLine" id="cb26-32" data-line-number="32"></a>
<a class="sourceLine" id="cb26-33" data-line-number="33">    <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) <span class="kw">throws</span> E1 {</a>
<a class="sourceLine" id="cb26-34" data-line-number="34">        AutoDivision ad = <span class="kw">new</span> <span class="fu">AutoDivision</span>(<span class="bu">Double</span>.<span class="fu">parseDouble</span>(args[<span class="dv">0</span>]));</a>
<a class="sourceLine" id="cb26-35" data-line-number="35">        ad.<span class="fu">executer</span>(<span class="bu">Double</span>.<span class="fu">parseDouble</span>(args[<span class="dv">1</span>]));</a>
<a class="sourceLine" id="cb26-36" data-line-number="36">        <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(<span class="st">&quot;x = &quot;</span> + ad.<span class="fu">getX</span>());</a>
<a class="sourceLine" id="cb26-37" data-line-number="37">        ad.<span class="fu">executer</span>(<span class="bu">Double</span>.<span class="fu">parseDouble</span>(args[<span class="dv">2</span>]));</a>
<a class="sourceLine" id="cb26-38" data-line-number="38">        <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(<span class="st">&quot;x = &quot;</span> + ad.<span class="fu">getX</span>());</a>
<a class="sourceLine" id="cb26-39" data-line-number="39">    }</a>
<a class="sourceLine" id="cb26-40" data-line-number="40">}</a></code></pre></div>
<h2 id="factorielle">Factorielle</h2>
<p>Voici une classe de calcul de factorielle:</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">package</span><span class="im"> com.example.maths;</span></a>
<a class="sourceLine" id="cb27-2" data-line-number="2"></a>
<a class="sourceLine" id="cb27-3" data-line-number="3"><span class="kw">public</span> <span class="kw">class</span> Fonctions {</a>
<a class="sourceLine" id="cb27-4" data-line-number="4">    <span class="kw">private</span> <span class="dt">static</span> <span class="dt">long</span> <span class="fu">factorielleT</span>(<span class="dt">long</span> n, <span class="dt">long</span> acc){</a>
<a class="sourceLine" id="cb27-5" data-line-number="5">        <span class="kw">if</span>(n &lt;= <span class="dv">1</span>){</a>
<a class="sourceLine" id="cb27-6" data-line-number="6">            <span class="kw">return</span> acc;</a>
<a class="sourceLine" id="cb27-7" data-line-number="7">        }</a>
<a class="sourceLine" id="cb27-8" data-line-number="8">        <span class="kw">else</span>{</a>
<a class="sourceLine" id="cb27-9" data-line-number="9">            <span class="kw">return</span> <span class="fu">factorielleT</span>(n - <span class="dv">1</span>, n * acc);</a>
<a class="sourceLine" id="cb27-10" data-line-number="10">        }</a>
<a class="sourceLine" id="cb27-11" data-line-number="11">    }</a>
<a class="sourceLine" id="cb27-12" data-line-number="12">    <span class="kw">public</span> <span class="dt">static</span> <span class="dt">long</span> <span class="fu">factorielle</span>(<span class="dt">long</span> n){</a>
<a class="sourceLine" id="cb27-13" data-line-number="13">        <span class="kw">return</span> <span class="fu">factorielleT</span>(n, <span class="dv">1</span>);</a>
<a class="sourceLine" id="cb27-14" data-line-number="14">    }</a>
<a class="sourceLine" id="cb27-15" data-line-number="15">  <span class="kw">public</span> <span class="dt">static</span> <span class="dt">long</span> <span class="fu">factorielle</span>(<span class="dt">long</span> n){</a>
<a class="sourceLine" id="cb27-16" data-line-number="16">        <span class="kw">return</span> <span class="fu">factorielleT</span>(n, <span class="dv">1</span>);</a>
<a class="sourceLine" id="cb27-17" data-line-number="17">    }</a>
<a class="sourceLine" id="cb27-18" data-line-number="18">}</a></code></pre></div>
<p>Créer les exceptions permettant de gérer deux cas d’erreur:</p>
<ul>
<li>Le nombre passé en paramètre est négatif : <code>NombreNegatifException</code></li>
<li>Le nombre passé en paramètre est trop grand : <code>NombreTropGrandException</code></li>
</ul>
<p>Modifier les méthodes afin de prendre en compte ces exceptions.</p>
<p>A vous de déterminer la valeur maximale pouvant être traitée par cette fonction (les constantes <code>Long.MAX_VALUE</code> et <code>Integer.MAX_VALUE</code> peuvent vous aider). Dans ce cas, il est possible aussi que le nombre retourné devienne négatif : comment faire alors ?</p>
<h2 id="gestion-de-mot-de-passe">Gestion de mot de passe</h2>
<p>Parmi les failles de sécurité réseau, on trouve notamment l’utilisation du dépassement.</p>
<p>Par exemple, sur certaines programmes, un <em>login</em> ou un mot de passe de plus d’un mega-octet peut le faire <em>planter</em>. Ceci donne alors un accès <code>root</code> au système.</p>
<p>Dans d’autre cas, il est possible de faire une injection SQL.</p>
<p>Vous allez écrire un programme capable de gérer ces problèmes avec différents types d’exception.</p>
<ol type="1">
<li>Écrire un programme qui demande en boucle un nom d’utilisateur (<code>login</code>) et un mot de passe (<code>password</code>) jusqu’à recevoir une paire <code>login</code>/<code>password</code> correcte</li>
</ol>
<p>Vous stockerez les données de connexion suivantes en dur dans ce programme: <code>duke</code>/<code>Ellington</code> et <code>alexander</code>/<code>Abreu</code>.</p>
<ol start="2" type="1">
<li>Implémenter les exceptions suivantes:</li>
</ol>
<ul>
<li><code>IncorrectLoginException</code> : levée lorsque l’utilisateur saisit un <code>login</code> inexistant</li>
<li><code>IncorrectPasswordException</code> : levée lorsque le mot de passe est erroné</li>
<li><code>IncorrectInputLengthException</code> : levée lorsque le login ou le mot de passe saisi dépasse 10 caractères</li>
<li><code>SQLInjectionException</code> : levée lorsque le <code>login</code> ou le mot de passe saisi contient un caractère ‘;’ suivi du mot clef <code>SELECT</code> (avec ou sans espaces intermédiaires)</li>
</ul>
<ol start="3" type="1">
<li>Implémenter de façon à utiliser ces exceptions de façon pertinente pour pouvoir tracer ces exceptions. Ainsi, la <code>SQLInjectionException</code> ne devra pas faire l’objet d’un affichage standard d’erreur (l’attaquant ne doit pas savoir que le système sait détecter les injections SQL)</li>
<li>Déterminer les autres cas où l’on pourrait lever la <code>SQLInjectionException</code></li>
</ol>
</body>
</html>