Je veux que vous utilisiez Scala comme meilleur Java pour le moment

introduction

Cela fait environ deux ans que j'ai commencé à utiliser Scala. J'adore Scala, donc je le recommande aux ingénieurs autour de moi, mais il semble qu'il y ait un sentiment répulsif tel que "Langage fonctionnel? Cela semble difficile et Java n'est pas bon?" Bien sûr, il est difficile d'utiliser toutes les fonctionnalités de Scala, mais si vous voulez juste connaître les qualités de Scala, vous n'avez pas besoin de comprendre «fonctionnel» depuis le début. Voici quelques-unes des fonctionnalités de Scala que je trouve intéressantes pour les ingénieurs Java.

Exploitez les ressources Java

Scala a un gestionnaire de paquets appelé sbt qui peut également être utilisé avec n'importe quelle bibliothèque distribuée par Maven. Vous pouvez également faire coexister Scala et Java dans le code source de votre projet. En d'autres termes, vous n'avez pas à remplacer le code source en une seule fois et vous pouvez dire: "Essayons uniquement les nouvelles fonctionnalités que nous allons créer avec Scala."

case class

Créez une classe «Coin» (pièce) avec «prix» (montant) et «unité» (unité). Pour des pièces de 100 yens, utilisez-le comme new Coin (100.0," Yen "). Si vous utilisez la classe de cas, vous pouvez écrire comme suit.

Coin.scala

case class Coin(price: Double, unit: String)

Le code équivalent en Java est le suivant. (Pour être exact, il remplace hashCode, toString, copy, etc., mais ce sera trop long, donc je vais l'omettre.)

JavaCoin.java

public class JavaCoin {

    public final double price;
    public final String unit;

    public JavaCoin(double price, String unit) {
        this.price = price;
        this.unit = unit;
    }

    @Override
    public boolean equals(Object obj) {
        if (obj instanceof JavaCoin) {
            JavaCoin another = (JavaCoin) obj;
            return this.price == another.price && this.unit.equals(another.unit);
        }
        return false;
    }

}

C'est extrêmement court. Je pense que la brièveté est justice.

La plupart des éléments sont des expressions

Les éléments qui composent un programme sont des ** expressions ** et des ** instructions **. Par définition, celui qui renvoie la valeur est une expression et tout le reste est une déclaration. En Java, ʻif, for, switch`, etc. sont des instructions, mais dans Scala, ce sont toutes des expressions. Un exemple concret sera expliqué plus loin.

switch est puissant

Ajoutez la méthode suivante à la classe Coin. Une méthode qui aligne ʻunitavecDollar`.

Coin.scala

  def toDollar: Coin =
    this match {
      case Coin(_, "Dollar") => this
      case Coin(_price, "Cent") => Coin(_price * 0.01, "Dollar")
      case Coin(_price, "Yen") => Coin(_price * 0.088, "Dollar")
    }

match est switch dans Scala. Comme mentionné ci-dessus, avec case class, vous pouvez faire correspondre les propriétés et les lier à des variables. (En fait, vous devriez utiliser le polymorphisme, mais je ne l'utiliserai pas cette fois car ce sera compliqué) De plus, je n'ai pas écrit return, mais dans Scala le résultat de l'expression est la valeur de retour sans rien écrire. Dans Scala, match est une expression, donc c'est une valeur de retour.

Remplacement de l'opérateur

Ajoutez la méthode suivante à la classe Coin. Une méthode qui ajoute deux Coins.

Coin.scala

  def +(another: Coin): Coin =
    if (this.unit == another.unit)
      Coin(this.price + another.price, this.unit)
    else
      this.toDollar + another.toDollar

Si ʻunitest la même, elle est ajoutée telle quelle, et si elle est différente, elle est ajoutée en ligne avec" Dollar "`. Il peut être utilisé comme opérateur comme suit.

  println(
    Coin(1, "Dollar")
      + Coin(10, "Cent")
      + Coin(25, "Cent")
      + Coin(100, "Yen")
      + Coin(500, "Yen")
  )
  // Coin(54.15,Dollar)

N'a pas d'état (ne réaffecte pas)

Comme vous l'avez peut-être remarqué en lisant jusqu'ici, Scala ne ** réaffecte pas **. C'est la même chose que la déclaration Java «finale». Vous pourriez demander: "Pourquoi n'utilisez-vous pas final en Java?", Mais il est important de noter que la plupart des spécifications de langage, bibliothèques standard et bibliothèques tierces de Scala suivent cette règle. Ne pas réaffecter peut être reformulé comme n'ayant aucun état. S'il n'y a pas d'état, la valeur de retour de la fonction sera déterminée uniquement par l'argument, ce qui simplifie la réflexion. Il existe de nombreux avantages, tels que le fait de ne pas avoir à regarder la valeur de chaque variable dans le débogueur ou à écrire un scénario de test qui suppose l'état. C'est une explication détournée, mais vous devriez être en mesure de réaliser la force de cette règle en l'utilisant. (En fait, cet élément met un pied dans le concept de type fonctionnel, mais je l'ai expliqué parce que je pense que c'est le plus important.)

en conclusion

Cela fait longtemps, mais merci d'avoir lu. Il y a encore beaucoup d'endroits que je voudrais vous présenter, mais comme il n'y a pas de fin, je vais terminer ici. De plus en plus d'entreprises adoptent Scala ces jours-ci, et j'espère que cet article vous aidera.

Code source complet

Coin.scala

case class Coin(price: Double, unit: String) {

  def toDollar: Coin =
    this match {
      case Coin(_, "Dollar") => this
      case Coin(_price, "Cent") => Coin(_price * 0.01, "Dollar")
      case Coin(_price, "Yen") => Coin(_price * 0.088, "Dollar")
    }

  def +(another: Coin): Coin =
    if (this.unit == another.unit)
      Coin(this.price + another.price, this.unit)
    else
      this.toDollar + another.toDollar

}

object Coin extends App {

  println(
    Coin(1, "Dollar")
      + Coin(10, "Cent")
      + Coin(25, "Cent")
      + Coin(100, "Yen")
      + Coin(500, "Yen")
  )
  // Coin(54.15,Dollar)

}