<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Olivier Lafleur on Medium]]></title>
        <description><![CDATA[Stories by Olivier Lafleur on Medium]]></description>
        <link>https://medium.com/@olivierlafleur?source=rss-4c349524b4c5------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*5TFXDXYTeHpDLLYub3_Hfg.jpeg</url>
            <title>Stories by Olivier Lafleur on Medium</title>
            <link>https://medium.com/@olivierlafleur?source=rss-4c349524b4c5------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 07:16:51 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@olivierlafleur/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Scala pour les développeurs Java]]></title>
            <link>https://medium.com/@olivierlafleur/scala-pour-les-d%C3%A9veloppeurs-java-8b1572be5029?source=rss-4c349524b4c5------2</link>
            <guid isPermaLink="false">https://medium.com/p/8b1572be5029</guid>
            <category><![CDATA[functional-programming]]></category>
            <category><![CDATA[scala]]></category>
            <category><![CDATA[java]]></category>
            <dc:creator><![CDATA[Olivier Lafleur]]></dc:creator>
            <pubDate>Wed, 11 Nov 2015 13:28:43 GMT</pubDate>
            <atom:updated>2024-04-30T02:20:31.408Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*iD3L5g8IC8ZaLqusZMuoRQ.png" /></figure><p>Ces jours-ci, j’explore plusieurs langages, et un que j’apprécie particulièrement est Scala. Fait intéressant : dépendant comment on l’utilise, il peut être très similaire ou très différent de Java. Dans cet article, je vous présenterai les similitudes afin de montrer comment un développeur Java pourrait vouloir transitionner (c’est une bonne première étape) vers ce langage.</p><h3>Fonctionnel ou pas?</h3><p>Tout d’abord, il est intéressant de noter que Scala a la réputation d’être un langage fonctionnel (comme<a href="https://www.haskell.org/">Haskell</a>, par exemple). Ce n’est pas faux de dire que le langage contient les outils qu’il faut pour faire de la programmation fonctionnelle, mais la “pureté” fonctionnelle n’est pas requise. En fait, il est tout à fait possible de rédiger du code qui serait relativement familier dans son intention à un développeur Java (mais de façon plus concise).</p><p>Scala est reconnu comme un langage multi-paradigme puisque l’on peut notamment faire de la programmation orientée-objet, de la programmation impérative ainsi que de la programmation fonctionnelle.</p><h3>Qui l’utilise?</h3><p>Lorsqu’on étudie un langage, il est toujours intéressant, puisque la programmation est foncièrement un acte social, de voir s’il y a une communauté et des entreprises qui l’utilisent. Parmi la liste des entreprises qui, à un moment ou un autre l’ont utilisé : Twitter, LinkedIn, The Guardian, FourSquare, etc.</p><p>Il est utilisé comme langage en production et parfois même en remplacement de d’autres langages (comme Ruby) <a href="https://www.quora.com/Why-did-twitter-move-away-from-Ruby-on-Rails/answer/Benjamin-Darfler">lorsque ceux-ci ne sont plus “suffisants”</a>. Il s’agit d’un langage qui existe maintenant depuis 12 ans et qui a acquis une certaine reconnaissance dans le milieu des développeurs.</p><h3>Intéropérabilité avec Java</h3><p>Un des éléments les plus intéressants, à mon avis, pour les gens qui réfléchissent à utiliser Scala, est que c’est un langage qui compile sur la JVM, comme Java, et que celui-ci est parfaitement intéropérable avec Java. Ainsi, on peut utiliser des classes Java en Scala et vice-versa de façon tout à fait naturelle. En fait, si on veut simplifier à l’extrême, pour ajouter Scala à un projet Java déjà existant, il suffit d’ajouter un JAR (ou une dépendance) à votre projet et vous êtes bons pour commencer.</p><p>Supposons qu’on a une classe Animal qui est un objet en Java, il suffit de faire un import de la dite classe en Scala pour l’utiliser:</p><pre><strong>import</strong> com.olivierlafleur.share.<strong>Animal</strong>;<br>//...<br><strong>val</strong> animal = <strong>new</strong> <strong>Animal</strong></pre><h3>Syntaxe</h3><p>Scala est un langage fortement typé, tout comme Java, avec une inférence de type qui permet de souvent omettre les noms des types sans perdre le filet de sécurité qu’un typage fort permet.</p><h4>Variables</h4><p>Ainsi, lorsque l’on déclare une variable, là où en Java nous mettrions le type du côté gauche de l’égalité, le type est automatiquement inféré. Ce que l’on doit mettre est soit val ou var, dépendant si la variable est mutable ou non. Cela nous permet donc d’enforcer l’immutabilité, si c’est ce que nous cherchons.</p><p>Par exemple, cette déclaration en Java :</p><pre><strong>Dragon</strong> dragon = <strong>new</strong> <strong>Dragon</strong>();</pre><p>est remplacée par celle-ci en Scala :</p><pre><strong>var</strong> dragon:<strong>Dragon</strong> = <strong>new</strong> <strong>Dragon</strong><br>//ou même ceci grâce à l&#39;inférence de type<br><strong>var</strong> dragon = <strong>new</strong> <strong>Dragon</strong></pre><p>Lorsque l’on veut déclarer un objet comme étant immutable (ce qui est en général une propriété souhaitable en programmation fonctionnelle), en Java nous devons utiliser l’opérateur final alors qu’en Scala il suffit simplement d’écrire ceci :</p><pre><strong>val</strong> dragon = <strong>new</strong> <strong>Dragon</strong></pre><p>Comme vous le remarquez sans doute, les points virgules ne sont pas nécessaires à la fin des instructions. Il suffit simplement de mettre chaque ligne de code sur sa propre ligne. De plus, on voit aussi que les parenthèses ne sont pas nécessaires à l’appel d’une fonction (ou d’un constructeur dans ce cas) s’il n’y a pas de paramètre.</p><h4>Fonctions</h4><p>Pour déclarer une fonction, il suffit d’utiliser le mot clé def pour ce faire :</p><pre>//:String n&#39;est pas nécessaire puisque inféré<br><strong>def</strong> <strong>mange</strong>(repas: <strong>String</strong>):<strong>String</strong> = &quot;Votre dragon a mangé un &quot; + repas</pre><p>là où nous aurions écrit ceci en Java :</p><pre>public <strong>String</strong> mange(<strong>String</strong> repas) {<br>  <strong>return</strong> &quot;Votre dragon a mangé un &quot; + repas;<br>}</pre><p>Cet exemple nous fait voir qu’en Scala, le return n’est jamais obligatoire puisque le résultat de la dernière ligne est retourné (et donc le type de retour peut aussi être inféré).</p><h4>Classes</h4><p>Un des endroits ou Scala brille le plus, à mon avis, c’est dans la définition des classes. En Java, nous avons à notre disposition des classes (class) et des interfaces (interface).</p><p>En Scala, il y a trois types principaux : class, object et trait.</p><p>De façon simpliste, trait est comparable aux interfaces en Java et class est comparable à une classe, mais sans les éléments qui seraient static en Java. L’élément object, quant à lui, contient ceux-ci.</p><p>Tout comme les interfaces en Java 8, les traits peuvent avoir des fonctions qui ont une implémentation. Par exemple :</p><pre><strong>trait</strong> <strong>PeutManger</strong> {<br>  <strong>def</strong> <strong>mange</strong>():<strong>Unit</strong></pre><pre>  <strong>def</strong> <strong>digerer</strong>() = &quot;Miam, c&#39;était délicieux&quot;<br>}</pre><p>En Java, cela aurait l’air de ceci :</p><pre>public interface <strong>PeutManger</strong> {<br>    void mange();</pre><pre>    default void digerer() {<br>        <strong>System</strong>.out.println(&quot;Miam, c&#39;était délicieux&quot;);<br>    }<br>}</pre><p>Maintenant, créons-nous, dans les deux cas, un objet ordinaire (POJO) avec des <em>getter/setter</em>, l’implémentation d’une “interface” et une fonction statique qui agit comme un <em>Builder</em>.</p><p>En Java :</p><pre>public <strong>class</strong> <strong>Dragon</strong> <strong>implements</strong> <strong>PeutManger</strong> {<br>    <strong>private</strong> <strong>String</strong> nom;<br>    <strong>private</strong> int age;</pre><pre>    public <strong>Dragon</strong>(<strong>String</strong> nom, int age) {<br>        <strong>this</strong>.nom = nom;<br>        <strong>this</strong>.age = age;<br>    }</pre><pre>    public <strong>String</strong> getNom() {<br>        <strong>return</strong> nom;<br>    }</pre><pre>    public void setNom(<strong>String</strong> nom) {<br>        <strong>this</strong>.nom = nom;<br>    }</pre><pre>    public int getAge() {<br>        <strong>return</strong> age;<br>    }</pre><pre>    public void setAge(int age) {<br>        <strong>this</strong>.age = age;<br>    }</pre><pre>    @Override<br>    public void mange() {<br>        <strong>System</strong>.out.println(&quot;Votre dragon &quot; + nom + &quot; a mangé&quot;);<br>    }</pre><pre>    public static <strong>Dragon</strong> construireDragon() {<br>        <strong>return</strong> <strong>new</strong> <strong>Dragon</strong>(&quot;Ami&quot;, 42);<br>    }<br>}</pre><p>devient en Scala :</p><pre><strong>class</strong> <strong>Dragon</strong>(_nom: String, _age: Int) <strong>extends</strong> <strong>PeutManger</strong> {<br>  <strong>def</strong> <strong>nom</strong> = _nom<br>  <strong>def</strong> <strong>age</strong> = _age</pre><pre>  <strong>def</strong> <strong>age_=</strong> (value:<strong>Int</strong>) = age = value<br>  <strong>def</strong> <strong>nom_=</strong> (value:<strong>String</strong>) = nom = value</pre><pre>  <strong>override</strong> <strong>def</strong> <strong>mange</strong>() = println(&quot;Votre dragon &quot; + _nom + &quot; a mangé&quot;)<br>}</pre><pre><strong>object</strong> <strong>Dragon</strong> {<br>  <strong>def</strong> <strong>construireDragon</strong>() = <strong>new</strong> <strong>Dragon</strong>(&quot;Ami&quot;, 42)<br>}</pre><p>En terme de bénéfice additionnel, en plus d’être (à mon goût) plus élégant comme code, le “setter” en Scala permet de faire directement une assignation grâce à la syntaxe dragon.age = 15, par exemple, mais en passant par le biais d’une fonction.</p><h3>Conclusion</h3><p>Dans cet article, nous avons abordé la base de Scala d’un point de vue des similitudes du langage à Java. Cela nous permet de faire une première approche du langage qui permette de nous familiariser avec la structure de ce langage. Dans le prochain article, nous commencerons à explorer les éléments particuliers de Scala qui nous permettent d’utiliser de nouveaux outils dans la résolution de nos problèmes informatiques.</p><p>(<a href="https://olivierlafleur.com/2015/11/11/scala-java.html">Publication originale sur mon blog</a>)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8b1572be5029" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>