|
|
@@ -0,0 +1,523 @@
|
|
|
+<!DOCTYPE html>
|
|
|
+<html xmlns="http://www.w3.org/1999/xhtml" lang="" xml:lang="">
|
|
|
+<head>
|
|
|
+ <meta charset="utf-8" />
|
|
|
+ <meta name="generator" content="pandoc" />
|
|
|
+ <meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes" />
|
|
|
+ <title>Decouvrir Java</title>
|
|
|
+ <style type="text/css">
|
|
|
+ code{white-space: pre-wrap;}
|
|
|
+ span.smallcaps{font-variant: small-caps;}
|
|
|
+ span.underline{text-decoration: underline;}
|
|
|
+ div.column{display: inline-block; vertical-align: top; width: 50%;}
|
|
|
+ </style>
|
|
|
+ <style type="text/css">
|
|
|
+a.sourceLine { display: inline-block; line-height: 1.25; }
|
|
|
+a.sourceLine { pointer-events: none; color: inherit; text-decoration: inherit; }
|
|
|
+a.sourceLine:empty { height: 1.2em; position: absolute; }
|
|
|
+.sourceCode { overflow: visible; }
|
|
|
+code.sourceCode { white-space: pre; position: relative; }
|
|
|
+div.sourceCode { margin: 1em 0; }
|
|
|
+pre.sourceCode { margin: 0; }
|
|
|
+@media screen {
|
|
|
+div.sourceCode { overflow: auto; }
|
|
|
+}
|
|
|
+@media print {
|
|
|
+code.sourceCode { white-space: pre-wrap; }
|
|
|
+a.sourceLine { text-indent: -1em; padding-left: 1em; }
|
|
|
+}
|
|
|
+pre.numberSource a.sourceLine
|
|
|
+ { position: relative; }
|
|
|
+pre.numberSource a.sourceLine:empty
|
|
|
+ { position: absolute; }
|
|
|
+pre.numberSource a.sourceLine::before
|
|
|
+ { content: attr(data-line-number);
|
|
|
+ position: absolute; left: -5em; text-align: right; vertical-align: baseline;
|
|
|
+ border: none; pointer-events: all;
|
|
|
+ -webkit-touch-callout: none; -webkit-user-select: none;
|
|
|
+ -khtml-user-select: none; -moz-user-select: none;
|
|
|
+ -ms-user-select: none; user-select: none;
|
|
|
+ padding: 0 4px; width: 4em;
|
|
|
+ color: #aaaaaa;
|
|
|
+ }
|
|
|
+pre.numberSource { margin-left: 3em; border-left: 1px solid #aaaaaa; padding-left: 4px; }
|
|
|
+div.sourceCode
|
|
|
+ { }
|
|
|
+@media screen {
|
|
|
+a.sourceLine::before { text-decoration: underline; }
|
|
|
+}
|
|
|
+code span.al { color: #ff0000; font-weight: bold; } /* Alert */
|
|
|
+code span.an { color: #60a0b0; font-weight: bold; font-style: italic; } /* Annotation */
|
|
|
+code span.at { color: #7d9029; } /* Attribute */
|
|
|
+code span.bn { color: #40a070; } /* BaseN */
|
|
|
+code span.bu { } /* BuiltIn */
|
|
|
+code span.cf { color: #007020; font-weight: bold; } /* ControlFlow */
|
|
|
+code span.ch { color: #4070a0; } /* Char */
|
|
|
+code span.cn { color: #880000; } /* Constant */
|
|
|
+code span.co { color: #60a0b0; font-style: italic; } /* Comment */
|
|
|
+code span.cv { color: #60a0b0; font-weight: bold; font-style: italic; } /* CommentVar */
|
|
|
+code span.do { color: #ba2121; font-style: italic; } /* Documentation */
|
|
|
+code span.dt { color: #902000; } /* DataType */
|
|
|
+code span.dv { color: #40a070; } /* DecVal */
|
|
|
+code span.er { color: #ff0000; font-weight: bold; } /* Error */
|
|
|
+code span.ex { } /* Extension */
|
|
|
+code span.fl { color: #40a070; } /* Float */
|
|
|
+code span.fu { color: #06287e; } /* Function */
|
|
|
+code span.im { } /* Import */
|
|
|
+code span.in { color: #60a0b0; font-weight: bold; font-style: italic; } /* Information */
|
|
|
+code span.kw { color: #007020; font-weight: bold; } /* Keyword */
|
|
|
+code span.op { color: #666666; } /* Operator */
|
|
|
+code span.ot { color: #007020; } /* Other */
|
|
|
+code span.pp { color: #bc7a00; } /* Preprocessor */
|
|
|
+code span.sc { color: #4070a0; } /* SpecialChar */
|
|
|
+code span.ss { color: #bb6688; } /* SpecialString */
|
|
|
+code span.st { color: #4070a0; } /* String */
|
|
|
+code span.va { color: #19177c; } /* Variable */
|
|
|
+code span.vs { color: #4070a0; } /* VerbatimString */
|
|
|
+code span.wa { color: #60a0b0; font-weight: bold; font-style: italic; } /* Warning */
|
|
|
+ </style>
|
|
|
+ <link rel="stylesheet" href="buttondown.css">
|
|
|
+ <!--[if lt IE 9]>
|
|
|
+ <script src="//cdnjs.cloudflare.com/ajax/libs/html5shiv/3.7.3/html5shiv-printshiv.min.js"></script>
|
|
|
+ <![endif]-->
|
|
|
+</head>
|
|
|
+<body>
|
|
|
+<h1 id="découvrir-java">Découvrir Java</h1>
|
|
|
+<h2 id="introduction">Introduction</h2>
|
|
|
+<p>Dans cette première partie, nous allons découvrir Java sous la forme de petits programmes. Nous n’allons pas tout de suite chercher à faire de programmes complexes, mais nous allons utiliser des mécanismes de la Programmation Orienté Objet et observer leurs effets.</p>
|
|
|
+<p>L’idée va être de se familiariser avec différents concepts: classes, instances, interfaces, héritage et même modèles de conception.</p>
|
|
|
+<p>Nous allons faire collaborer des objets entre eux afin d’observer des comportements selon la manière dont ils sont assemblés.</p>
|
|
|
+<h2 id="premiers-pas">Premiers pas</h2>
|
|
|
+<h3 id="bases-du-langage">Bases du langage</h3>
|
|
|
+<p>Dans cette partie, des exemples sont donnés pour chaque élément de base du langage.</p>
|
|
|
+<p>La documentation Java fournie par Oracle est disponible <a href="https://docs.oracle.com/javase/tutorial/java/nutsandbolts/index.html">ici</a>. Elle reprend l’ensemble des concepts abordés;</p>
|
|
|
+<h4 id="types-primitifs">Types primitifs</h4>
|
|
|
+<p>Plus d’information sur les types primitifs est <a href="https://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html">disponible ici</a></p>
|
|
|
+<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>
|
|
|
+<div class="line-block">Type | Valeurs à tester |<br />
|
|
|
+byte | 8 puis 127 puis 128 puis -128 puis -129 |<br />
|
|
|
+short | -32768 puis -32769 |<br />
|
|
|
+int | déterminez les valeurs possibles à utiliser |<br />
|
|
|
+long | 2L puis déterminez les valeurs possibles à utiliser |<br />
|
|
|
+float | 1.5f puis 1.5 puis déterminez les valeurs possibles à utiliser |<br />
|
|
|
+double | 3.8 puis 9.7d |<br />
|
|
|
+char | ’<br />
|
|
|
+String | “” puis “cd” |<br />
|
|
|
+boolean | false puis true|</div>
|
|
|
+<p>Pour chacun des types, trouvez quelle est la valeur par défaut.</p>
|
|
|
+<h4 id="tableaux">Tableaux</h4>
|
|
|
+<p>https://docs.oracle.com/javase/tutorial/java/nutsandbolts/arrays.html</p>
|
|
|
+<p>Exemple de programme</p>
|
|
|
+<p>Créez un tableau d’entier</p>
|
|
|
+<h4 id="opérateurs">Opérateurs</h4>
|
|
|
+<p>https://docs.oracle.com/javase/tutorial/java/nutsandbolts/opsummary.html</p>
|
|
|
+<p>Afficher le résultat des opérations les plus simples</p>
|
|
|
+<h4 id="structures-de-contrôles">Structures de contrôles</h4>
|
|
|
+<h5 id="contrôles">Contrôles</h5>
|
|
|
+<h6 id="if-else">if-else</h6>
|
|
|
+<h6 id="switch">switch</h6>
|
|
|
+<h5 id="boucles">Boucles</h5>
|
|
|
+<h6 id="for">for</h6>
|
|
|
+<h6 id="while-do-while">while / do-while</h6>
|
|
|
+<h5 id="branchements">Branchements</h5>
|
|
|
+<h6 id="break">break</h6>
|
|
|
+<h6 id="continue">continue</h6>
|
|
|
+<h4 id="découverte-du-débogueur-eclipse">Découverte du débogueur Eclipse</h4>
|
|
|
+<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="cb2"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb2-1" data-line-number="1"><span class="kw">package</span><span class="im"> com.example.java;</span></a>
|
|
|
+<a class="sourceLine" id="cb2-2" data-line-number="2"></a>
|
|
|
+<a class="sourceLine" id="cb2-3" data-line-number="3"><span class="kw">public</span> <span class="kw">class</span> Multiplication {</a>
|
|
|
+<a class="sourceLine" id="cb2-4" data-line-number="4"> <span class="dt">int</span> resultat ;</a>
|
|
|
+<a class="sourceLine" id="cb2-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="cb2-6" data-line-number="6"> resultat = a * b;</a>
|
|
|
+<a class="sourceLine" id="cb2-7" data-line-number="7"> }</a>
|
|
|
+<a class="sourceLine" id="cb2-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="cb3"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb3-1" data-line-number="1"><span class="kw">package</span><span class="im"> com.example.java ;</span></a>
|
|
|
+<a class="sourceLine" id="cb3-2" data-line-number="2"></a>
|
|
|
+<a class="sourceLine" id="cb3-3" data-line-number="3"><span class="kw">public</span> <span class="kw">class</span> Calculer {</a>
|
|
|
+<a class="sourceLine" id="cb3-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="cb3-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="cb3-6" data-line-number="6"> Multiplication premierCalcul = <span class="kw">new</span> <span class="fu">Multiplication</span>();</a>
|
|
|
+<a class="sourceLine" id="cb3-7" data-line-number="7"></a>
|
|
|
+<a class="sourceLine" id="cb3-8" data-line-number="8"> <span class="co">// Créer une variable nommée resultat</span></a>
|
|
|
+<a class="sourceLine" id="cb3-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="cb3-10" data-line-number="10"></a>
|
|
|
+<a class="sourceLine" id="cb3-11" data-line-number="11"> <span class="co">// Ecrire le résultat du calcul dans la sortie standard</span></a>
|
|
|
+<a class="sourceLine" id="cb3-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="cb3-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="cb3-14" data-line-number="14"> }</a>
|
|
|
+<a class="sourceLine" id="cb3-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="cb4"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb4-1" data-line-number="1">Multiplication premierCalcul = <span class="kw">new</span> <span class="fu">Multiplication</span>();</a></code></pre></div>
|
|
|
+<p>Ce mot clef permet de faire appel au <strong>constructeur</strong> de la classe. Si aucun <strong>constructeur</strong> n’est explicitement déclaré dans une classe, le compilateur Java crée un constructeur par défaut, c’est-à-dire sans aucun paramètre.</p>
|
|
|
+<p>La ligne ci-dessus stocke un <strong>pointeur</strong> vers l’instance créée dans la variable <code>premierCalcul</code>.</p>
|
|
|
+<p>Cette variable est déclaré avec un type (la classe) <code>Multiplication</code>.</p>
|
|
|
+<h5 id="appel-de-méthode">Appel de méthode</h5>
|
|
|
+<p>L’appel d’une méthode est similaire à l’appel d’une fonction dans un autre langage, à la différence près que la méthode est rattachée à un objet.</p>
|
|
|
+<p>La ligne suivante permet donc d’appeler la méthode <code>calculer</code> qui est rattachée à l’instance <strong>pointée</strong> par la variable <code>premierCalcul</code>.</p>
|
|
|
+<div class="sourceCode" id="cb5"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb5-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="cb6"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb6-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="cb6-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="cb6-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="cb6-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>
|
|
|
+<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="cb7"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb7-1" data-line-number="1"><span class="kw">package</span><span class="im"> com.example.java;</span></a>
|
|
|
+<a class="sourceLine" id="cb7-2" data-line-number="2"></a>
|
|
|
+<a class="sourceLine" id="cb7-3" data-line-number="3"><span class="kw">public</span> <span class="kw">class</span> Calcul {</a>
|
|
|
+<a class="sourceLine" id="cb7-4" data-line-number="4"> <span class="dt">int</span> resultat ;</a>
|
|
|
+<a class="sourceLine" id="cb7-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="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 <span class="kw">extends</span> Calcul {</a>
|
|
|
+<a class="sourceLine" id="cb8-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="cb8-5" data-line-number="5"> resultat = a * b;</a>
|
|
|
+<a class="sourceLine" id="cb8-6" data-line-number="6"> }</a>
|
|
|
+<a class="sourceLine" id="cb8-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="cb9"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb9-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="cb10"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb10-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="cb11"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb11-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="cb11-2" data-line-number="2"> <span class="dt">int</span> resultat ;</a>
|
|
|
+<a class="sourceLine" id="cb11-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="cb11-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="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="kw">class</span> Calculer {</a>
|
|
|
+<a class="sourceLine" id="cb12-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="cb12-3" data-line-number="3"> Calcul premierCalcul = <span class="kw">new</span> <span class="fu">Multiplication</span>();</a>
|
|
|
+<a class="sourceLine" id="cb12-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="cb12-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="cb12-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="cb12-7" data-line-number="7"></a>
|
|
|
+<a class="sourceLine" id="cb12-8" data-line-number="8"> <span class="co">//...</span></a>
|
|
|
+<a class="sourceLine" id="cb12-9" data-line-number="9"> }</a>
|
|
|
+<a class="sourceLine" id="cb12-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="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">static</span> <span class="dt">void</span> <span class="fu">main</span>(<span class="bu">String</span>[] args) {</a>
|
|
|
+<a class="sourceLine" id="cb13-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="cb13-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="cb13-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="cb14"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb14-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="cb14-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="cb14-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="cb15"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb15-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="cb15-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="cb15-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="applications">Applications</h2>
|
|
|
+<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="cb16"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb16-1" data-line-number="1"><span class="kw">public</span> <span class="kw">class</span> Personne {</a>
|
|
|
+<a class="sourceLine" id="cb16-2" data-line-number="2"> <span class="bu">String</span> nom;</a>
|
|
|
+<a class="sourceLine" id="cb16-3" data-line-number="3"> <span class="bu">String</span> prenom;</a>
|
|
|
+<a class="sourceLine" id="cb16-4" data-line-number="4"> <span class="bu">String</span> dateNaissance;</a>
|
|
|
+<a class="sourceLine" id="cb16-5" data-line-number="5"> <span class="bu">String</span> adresseMail;</a>
|
|
|
+<a class="sourceLine" id="cb16-6" data-line-number="6"> <span class="bu">String</span> telephone;</a>
|
|
|
+<a class="sourceLine" id="cb16-7" data-line-number="7"></a>
|
|
|
+<a class="sourceLine" id="cb16-8" data-line-number="8"> <span class="kw">public</span> <span class="dt">static</span> <span class="dt">void</span> <span class="fu">main</span>(<span class="bu">String</span>[] args) {</a>
|
|
|
+<a class="sourceLine" id="cb16-9" data-line-number="9"> Personne utilisateur = <span class="kw">new</span> <span class="fu">Personne</span>();</a>
|
|
|
+<a class="sourceLine" id="cb16-10" data-line-number="10"></a>
|
|
|
+<a class="sourceLine" id="cb16-11" data-line-number="11"> utilisateur.<span class="fu">nom</span> = <span class="st">"McEnroe"</span>;</a>
|
|
|
+<a class="sourceLine" id="cb16-12" data-line-number="12"> utilisateur.<span class="fu">prenom</span> = <span class="st">"John"</span>;</a>
|
|
|
+<a class="sourceLine" id="cb16-13" data-line-number="13"> utilisateur.<span class="fu">dateNaissance</span> = <span class="st">"10/10/1960"</span>;</a>
|
|
|
+<a class="sourceLine" id="cb16-14" data-line-number="14"> utilisateur.<span class="fu">adresseMail</span> = <span class="st">"johnmcenroe@usa.tennis.com"</span>;</a>
|
|
|
+<a class="sourceLine" id="cb16-15" data-line-number="15"> utilisateur.<span class="fu">telephone</span> = <span class="st">"+001 203 204 205"</span>;</a>
|
|
|
+<a class="sourceLine" id="cb16-16" data-line-number="16"></a>
|
|
|
+<a class="sourceLine" id="cb16-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="cb16-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="cb16-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="cb16-20" data-line-number="20"> }</a>
|
|
|
+<a class="sourceLine" id="cb16-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="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">class</span> Personne {</a>
|
|
|
+<a class="sourceLine" id="cb17-2" data-line-number="2"> <span class="bu">String</span> nom;</a>
|
|
|
+<a class="sourceLine" id="cb17-3" data-line-number="3"> <span class="bu">String</span> prenom;</a>
|
|
|
+<a class="sourceLine" id="cb17-4" data-line-number="4"> <span class="bu">String</span> dateNaissance;</a>
|
|
|
+<a class="sourceLine" id="cb17-5" data-line-number="5"> <span class="bu">String</span> adresseMail;</a>
|
|
|
+<a class="sourceLine" id="cb17-6" data-line-number="6"> <span class="bu">String</span> telephone;</a>
|
|
|
+<a class="sourceLine" id="cb17-7" data-line-number="7"></a>
|
|
|
+<a class="sourceLine" id="cb17-8" data-line-number="8"> <span class="kw">public</span> <span class="dt">static</span> <span class="dt">void</span> <span class="fu">main</span>(<span class="bu">String</span>[] args) {</a>
|
|
|
+<a class="sourceLine" id="cb17-9" data-line-number="9"> Personne utilisateur = <span class="kw">new</span> <span class="fu">Personne</span>();</a>
|
|
|
+<a class="sourceLine" id="cb17-10" data-line-number="10"></a>
|
|
|
+<a class="sourceLine" id="cb17-11" data-line-number="11"> utilisateur.<span class="fu">nom</span> = <span class="st">"McEnroe"</span>;</a>
|
|
|
+<a class="sourceLine" id="cb17-12" data-line-number="12"> utilisateur.<span class="fu">prenom</span> = <span class="st">"John"</span>;</a>
|
|
|
+<a class="sourceLine" id="cb17-13" data-line-number="13"> utilisateur.<span class="fu">dateNaissance</span> = <span class="st">"10/10/1960"</span>;</a>
|
|
|
+<a class="sourceLine" id="cb17-14" data-line-number="14"> utilisateur.<span class="fu">adresseMail</span> = <span class="st">"johnmcenroe@usa.tennis.com"</span>;</a>
|
|
|
+<a class="sourceLine" id="cb17-15" data-line-number="15"> utilisateur.<span class="fu">telephone</span> = <span class="st">"+001 203 204 205"</span>;</a>
|
|
|
+<a class="sourceLine" id="cb17-16" data-line-number="16"></a>
|
|
|
+<a class="sourceLine" id="cb17-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="cb17-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="cb17-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="cb17-20" data-line-number="20"> }</a>
|
|
|
+<a class="sourceLine" id="cb17-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="cb17-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="cb17-23" data-line-number="23"> }</a>
|
|
|
+<a class="sourceLine" id="cb17-24" data-line-number="24"></a>
|
|
|
+<a class="sourceLine" id="cb17-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="cb17-26" data-line-number="26"> <span class="kw">return</span> prenom+<span class="st">" "</span>+nom;</a>
|
|
|
+<a class="sourceLine" id="cb17-27" data-line-number="27"> }</a>
|
|
|
+<a class="sourceLine" id="cb17-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="cb18"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb18-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="cb18-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="cb19"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb19-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="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> nom+<span class="st">" "</span>+prenom+<span class="st">" "</span>+dateNaissance+<span class="st">" "</span></a>
|
|
|
+<a class="sourceLine" id="cb20-3" data-line-number="3"> +adresseMail+<span class="st">" "</span>+telephone;</a>
|
|
|
+<a class="sourceLine" id="cb20-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="cb21"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb21-1" data-line-number="1">Calcul calcul = <span class="kw">new</span> <span class="fu">Multiplication</span>();</a>
|
|
|
+<a class="sourceLine" id="cb21-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="cb21-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="cb23"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb23-1" data-line-number="1"></a>
|
|
|
+<a class="sourceLine" id="cb23-2" data-line-number="2"><span class="kw">public</span> <span class="kw">class</span> ExerciceChaine {</a>
|
|
|
+<a class="sourceLine" id="cb23-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="cb23-4" data-line-number="4"> <span class="bu">String</span> uneChaine = <span class="st">"Bonjour"</span> ;</a>
|
|
|
+<a class="sourceLine" id="cb23-5" data-line-number="5"> <span class="bu">String</span> autreChaine = <span class="st">"Bonjour"</span> ;</a>
|
|
|
+<a class="sourceLine" id="cb23-6" data-line-number="6"></a>
|
|
|
+<a class="sourceLine" id="cb23-7" data-line-number="7"> ExerciceChaine ec = <span class="kw">new</span> <span class="fu">ExerciceChaine</span>();</a>
|
|
|
+<a class="sourceLine" id="cb23-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="cb23-9" data-line-number="9"> ec.<span class="fu">testChaines</span>(uneChaine, autreChaine);</a>
|
|
|
+<a class="sourceLine" id="cb23-10" data-line-number="10"></a>
|
|
|
+<a class="sourceLine" id="cb23-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="cb23-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="cb23-13" data-line-number="13"> ec.<span class="fu">testChaines</span>(uneChaine, autreChaine);</a>
|
|
|
+<a class="sourceLine" id="cb23-14" data-line-number="14"></a>
|
|
|
+<a class="sourceLine" id="cb23-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="cb23-16" data-line-number="16"> autreChaine = <span class="st">"Bon"</span> + <span class="st">"jour"</span> ;</a>
|
|
|
+<a class="sourceLine" id="cb23-17" data-line-number="17"> ec.<span class="fu">testChaines</span>(uneChaine, autreChaine);</a>
|
|
|
+<a class="sourceLine" id="cb23-18" data-line-number="18"></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>(<span class="st">"-- Une concaténation avec des variables différentes"</span>);</a>
|
|
|
+<a class="sourceLine" id="cb23-20" data-line-number="20"> autreChaine = <span class="st">"Bon"</span> ;</a>
|
|
|
+<a class="sourceLine" id="cb23-21" data-line-number="21"> <span class="bu">String</span> troisiemeChaine = <span class="st">"jour"</span>;</a>
|
|
|
+<a class="sourceLine" id="cb23-22" data-line-number="22"> autreChaine = autreChaine + troisiemeChaine;</a>
|
|
|
+<a class="sourceLine" id="cb23-23" data-line-number="23"> ec.<span class="fu">testChaines</span>(uneChaine, autreChaine);</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="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="cb23-26" data-line-number="26"> <span class="kw">if</span>(a == b){</a>
|
|
|
+<a class="sourceLine" id="cb23-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="cb23-28" data-line-number="28"> }</a>
|
|
|
+<a class="sourceLine" id="cb23-29" data-line-number="29"> <span class="kw">else</span>{</a>
|
|
|
+<a class="sourceLine" id="cb23-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="cb23-31" data-line-number="31"> }</a>
|
|
|
+<a class="sourceLine" id="cb23-32" data-line-number="32"> }</a>
|
|
|
+<a class="sourceLine" id="cb23-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="cb24"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb24-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="cb24-2" data-line-number="2"> <span class="kw">if</span>(a.<span class="fu">equals</span>(b)){</a>
|
|
|
+<a class="sourceLine" id="cb24-3" data-line-number="3"> <span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(<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="cb24-4" data-line-number="4"> }</a>
|
|
|
+<a class="sourceLine" id="cb24-5" data-line-number="5"> <span class="kw">else</span>{</a>
|
|
|
+<a class="sourceLine" id="cb24-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="cb24-7" data-line-number="7"> }</a>
|
|
|
+<a class="sourceLine" id="cb24-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="cb25"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb25-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="cb25-2" data-line-number="2"> <span class="bu">String</span> chaine = <span class="st">"Quelques caractères"</span>;</a>
|
|
|
+<a class="sourceLine" id="cb25-3" data-line-number="3"></a>
|
|
|
+<a class="sourceLine" id="cb25-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="cb25-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="cb25-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="cb25-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="cb25-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="cb25-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="cb25-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="cb25-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="cb25-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="cb25-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="cb25-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="cb26"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb26-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="cb26-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="cb26-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>Essayez d’instancier cette classe à partir de la méthode <code>main(String[])</code> de <code>Exemple</code> et d’afficher cette instance avec un <code>System.out.println(String)</code>.</p>
|
|
|
+<p>Que constatez-vous ?</p>
|
|
|
+<p>Est-on limité par quelque chose ici ?</p>
|
|
|
+<h4 id="constructeur">Constructeur</h4>
|
|
|
+<p>Pour pouvoir créer cette classe, il existe un constructeur par défaut. Sauf qu’il ne permet pas de modifier les valeurs des attributs.</p>
|
|
|
+<p>Créer un nouveau constructeur sur le modèle suivant:</p>
|
|
|
+<div class="sourceCode" id="cb27"><pre class="sourceCode java"><code class="sourceCode java"><a class="sourceLine" id="cb27-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="cb27-2" data-line-number="2"> <span class="kw">this</span>.<span class="fu">nom</span> = nom;</a>
|
|
|
+<a class="sourceLine" id="cb27-3" data-line-number="3"> <span class="kw">this</span>.<span class="fu">identifiant</span> = identifiant;</a>
|
|
|
+<a class="sourceLine" id="cb27-4" data-line-number="4">}</a></code></pre></div>
|
|
|
+<p>Essayez d’utiliser ce constructeur et d’afficher l’instance depuis la méthode <code>main(String[])</code></p>
|
|
|
+<p>Créez ainsi plusieurs instances de <code>Fleur</code> et affichez-les.</p>
|
|
|
+</body>
|
|
|
+</html>
|
Laurent HUBERT
7 anni fa