Comme le dit le titre. Je voulais faire Scala, alors je l'ai résumé. Prévu pour être mis à jour à chaque fois pendant l'apprentissage. Au fait, mon expérience est C # 4 ans et Java 1 an.

Règles de dénomination

Cela ressemble bien à Java. Affaire de chameau

Règles détaillées

Pas besoin d'un point-virgule de fin --Les commentaires sont les mêmes // et / * * /

variable

L'inférence de type fonctionne avec les déclarations! (À partir de 10 pour Java)

val hoge = 1 //immuable (immuable, variable avec final)
var hoge = 1 //mutable (variable)

Avec spécification de type,

val i:Int = 1
val str:String = "Hi!"

Pour incorporer une variable dans une chaîne, préfixez le littéral avec s et préfixez la variable avec $.

val firstName = j
val familyName = ichikawa
val str = s"my name is $firstName - $familyName"

Vous pouvez également incorporer du code dans le littéral

val str = s"My weight　is ${weight + 3}"

if déclaration

L'écriture est la même Peut être écrit comme une expression qui renvoie une valeur

val age = 30
val result =
  if (age >= 30) "over 30"
    else "under 30"
println(result)// over 30

opérateur

C'est fondamentalement la même chose, mais il semble qu'il n'y ait pas d'opérateur ternaire. Puisque vous pouvez renvoyer la valeur avec if, vous pouvez la remplacer

val result = if (age >= 30) "over 30" else "under 30"

switch Il semble dire match

val team = "Alors"
val result = team match {
  case "B" | "mouette" => "Bッテ" //ou condition
  case other => s"undefined: ${other}" // default
}
println(result)
// undefined:Alors

boucle

while est le même, mais différent de for Il semble que la condition s'appelle un générateur

for (i <- 0 to 3) println(i) //La condition peut être comprise entre 0 et 4 et peut être égale ou supérieure à 0 et inférieure à 4.
// 0
// 1
// 2
// 3

for (i <- 0 to 3 if i != 2) println(i) //Conditionnel
// 0
// 1
// 3

var result = for (i <- 0 to 3) yield i //Obtenir des résultats
for (i <- result) println(i)

for (i <- 0 to 3; j <- 0 to 3) println(s"$i, $j") //pour nidification

Méthode

Avec java,

public void sayHello() {
  System.out.println("hello");
}
    
public String sayHelloStr() {
  return "hello";
}
    
public String getHelloMessage(String firstName, String familyName) {
  return "Hello " + firstName + " " + familyName;
}

Mais,

def sayHello: Unit = {
  println("hello")
}
    
def getHelloStr: String = {
  "Hello" //retour facultatif
}
    
def getHelloMessage(firstName: String, familyName: String): String = {
  s"Hello $firstName $familyName"
  // firstName: String = "taro"Vous pouvez définir la valeur par défaut comme ceci. C#Est le même que
}

classe

class Human(val name: String) { //Devenir un constructeur avec la définition des paramètres
  def sayHello() = println("hello") //Définition de méthode de type Lambda
}

//Instanciation
val human = new Human（"j-ichikawa"）
val name = human.name;
human.sayHello()

L'héritage est

class PerfectHuman(name: String) extends Human(name) {
  override def sayHello() = println("perfect hello")
}

paquet

La déclaration est la même

package aaa.bbb.ccc

L'appel est

import aaa.bbb.ccc.ddd //Individuel
import aaa.bbb.ccc.ddd.{ddd, eee} //Plusieurs
import aaa.bbb.ccc.ddd._ //collecte

Modificateur d'accès

public, protected, private La manière d'attacher et de voir les membres de la classe attachée est la même Si rien n'est attaché, il sera public par défaut (private est la valeur par défaut en C #, n'est-ce pas? final La fonction associée à une classe ou à un membre est la même que Java. Déclarer avec val pour rendre la variable immuable

object Cela semble être un mot-clé, pas un type Ajouter un objet à la classe avec le même nom

//C'est comme un objet compagnon
object Human {
  def sayHello() = println("hello") //Peut être appelé sans instanciation comme une méthode de classe
  def apply(name: String) = new Human(name) //Devenez la définition de la méthode d'usine
}

//Ceci est une classe compagnon
class Human (val name: String) {
  def sayHello() = println("hello")
}

//Comment utiliser les objets compagnons
Human.sayHello()
val taro = Human("taro") //Générer une instance de taro

println semble être une méthode d'un objet appelé Predef

Un nouveau concept. ..

Classe abstraite

Ouais, pas de résistance

abstract class Animal {
  def cry()
}

class Cat extends Animal {
  def cry() = println("Nyaaaa")
}

Interface

Cela semble être un trait

trait Runnable {
  def run() = println("Dadada. .. ..")
}

class Player extends Runnable //Même syntaxe que l'héritage d'implémentation C#Pareil que
class SuperPlayer extends Player with Runnable //En cas d'héritage, implémenter avec avec

Mise à jour. .. ..

Comment écrire Scala du point de vue de Java