Wie schreibe ich Scala aus der Perspektive von Java

Wie der Titel schon sagt. Ich wollte Scala machen, also habe ich es zusammengefasst. Geplant, jedes Mal während des Lernens aktualisiert zu werden. Mein Hintergrund ist übrigens C # 4 Jahre und Java 1 Jahr.

Namensregeln

Es sieht gut aus wie Java. Kamelkoffer

Detaillierte Regeln

• Kein abschließendes Semikolon erforderlich
• Kommentare sind die gleichen // und / * * /

Variable

Typinferenz funktioniert mit Deklarationen! (Ab 10 für Java)

val hoge = 1 //unveränderlich (unveränderlich, variabel mit final)
var hoge = 1 //veränderlich (variabel)

Mit Typenspezifikation,

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

Um eine Variable in eine Zeichenfolge einzubetten, stellen Sie dem Literal s und der Variablen $ voran

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

Sie können Code auch in das Literal einbetten

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

if-Anweisung

Schreiben ist das gleiche Kann als Ausdruck geschrieben werden, der einen Wert zurückgibt

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

Operator

Es ist im Grunde das gleiche, aber es scheint, dass es keinen ternären Operator gibt. Da Sie den Wert mit if zurückgeben können, können Sie ihn ersetzen

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

switch Es scheint Match zu sagen

val team = "Damit"
val result = team match {
  case "B." | "Möwe" => "B.ッテ" //oder Zustand
  case other => s"undefined: ${other}" // default
}
println(result)
// undefined:Damit

Schleife

während ist das gleiche, aber anders als für Es scheint, dass die Bedingung als Generator bezeichnet wird

for (i <- 0 to 3) println(i) //Die Bedingung kann 0 bis 4 sein und kann 0 oder mehr und weniger als 4 sein.
// 0
// 1
// 2
// 3

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

var result = for (i <- 0 to 3) yield i //Ergebnisse bekommen
for (i <- result) println(i)

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

Methode

Mit Java,

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

Aber,

def sayHello: Unit = {
  println("hello")
}
    
def getHelloStr: String = {
  "Hello" //Rückgabe Optional
}
    
def getHelloMessage(firstName: String, familyName: String): String = {
  s"Hello $firstName $familyName"
  // firstName: String = "taro"Sie können den Standardwert wie folgt festlegen. C.#Ist das gleiche wie
}

Klasse

class Human(val name: String) { //Werden Sie Konstruktor mit Parameterdefinition
  def sayHello() = println("hello") //Lambda-ähnliche Methodendefinition
}

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

Vererbung ist

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

Paket

Erklärung ist das gleiche

package aaa.bbb.ccc

Der Anruf ist

import aaa.bbb.ccc.ddd //Individuell
import aaa.bbb.ccc.ddd.{ddd, eee} //Mehrere
import aaa.bbb.ccc.ddd._ //sammeln

Zugriffsmodifikator

öffentlich, geschützt, privat Die Art und Weise, wie Sie die Mitglieder der angehängten Klasse anhängen und sehen, ist dieselbe Wenn nichts angehängt ist, ist es standardmäßig öffentlich (privat ist die Standardeinstellung in C #, nicht wahr? final Die Funktion beim Anhängen an eine Klasse oder ein Mitglied ist dieselbe wie bei Java. Deklarieren Sie mit val, um die Variable unveränderlich zu machen

object Es scheint ein Schlüsselwort zu sein, kein Typ Fügen Sie der gleichnamigen Klasse ein Objekt hinzu

//Es ist wie ein Begleitobjekt
object Human {
  def sayHello() = println("hello") //Kann ohne Instanziierung wie eine Klassenmethode aufgerufen werden
  def apply(name: String) = new Human(name) //Werden Sie zur Definition der Fabrikmethode
}

//Dies ist eine Begleiterklasse
class Human (val name: String) {
  def sayHello() = println("hello")
}

//Verwendung von Begleitobjekten
Human.sayHello()
val taro = Human("taro") //Taro-Instanz generieren

println scheint eine Methode eines Objekts namens Predef zu sein

Ein neues Konzept. ..

Abstrakte Klasse

Ja, kein Widerstand

abstract class Animal {
  def cry()
}

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

Schnittstelle

Es scheint ein Merkmal zu sein

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

class Player extends Runnable //Gleiche Syntax wie Implementierungsvererbung C.#Gleich wie
class SuperPlayer extends Player with Runnable //Wenn geerbt, implementieren Sie mit mit

Aktualisierung. .. ..