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