Die grundlegende Syntax von Scala

Notiz

Kurz gesagt, für Scala-Kommentare handelt es sich nur um einen Satz, der genau dem Java-Kommentar entspricht.
Grundlegende Syntax

（1）单行注释：//
（2）多行注释：/* */
（3）文档注释：/**
              *
              */

Codebeispiel:

package com.doitedu.demo01
object TestNotes {
 def main(args: Array[String]): Unit = {
 //（1）单行注释：//
 println("涛哥")
 
 //（2）多行注释：/* */
 /*
 println("涛哥")
 println("行哥")
 */
 
 //（3）文档注释：
 /**
 *
 */
 /**
 * println("乃哥")
 * println("雨哥")
 * println("行哥")
 */
   } 
} 

Variablen und Konstanten (Wichtige Punkte)

// 回顾：Java 变量和常量语法
// 变量类型 变量名称 = 初始值 
int a = 10
// final 常量类型 常量名称 = 初始值 
final int b = 20
scala定义变量常量的基本语法
Scala
// var 变量名 [: 变量类型] = 初始值 
var i:Int = 10   variable ：可变的
// val 常量名 [: 常量类型] = 初始值 
val j:Int = 20   value ：值

var variable  可变的   代表声明变量

val  value  值    代表声明常量

Hinweis:
• Die meisten unserer val-Operationen im Programmierprozess dienen dazu, Werte abzurufen oder ein erstelltes Objekt abzurufen und dann die Eigenschaften im Objekt zu manipulieren und diese Objektvariable selten zu ändern. • val ist bei Verwendung threadsicher.
Effizienter
• Verwenden Sie zuerst val, aber verwenden Sie var, wenn die Variable später geändert werden muss

package com.doitedu.demo02
object TestVar {
 def main(args: Array[String]): Unit = {
 //（1）声明变量时，类型可以省略，编译器自动推导，即类型推导
     var age = 18
     age = 30
 //（2）类型确定后，就不能修改，说明 Scala 是强数据类型语言。
// age = "zhangsan" // 错误
 //（3）变量声明时，必须要有初始值
// var name //错误
//（4）在声明/定义一个变量时，可以使用 var 或者 val 来修饰，var 修饰的变量可改变，val 修饰的变量不可改。
 var num1 = 10 // 可变
 val num2 = 20 // 不可变
 num1 = 30 // 正确
 //num2 = 100 //错误，因为 num2 是 val 修饰的
     } 
}


object demo03{
 def main(args: Array[String]): Unit = {
 // p1 是 var 修饰的，p1 的属性可以变，而且 p1 本身也可以变
 var p1 = new Person()
 p1.name = "zhangsan"
 p1 = null
 // p2 是 val 修饰的，那么 p2 本身就不可变（即 p2 的内存地址不能变），
但是，p2 的属性是可以变，因为属性并没有用 val 修饰。
 val p2 = new Person()
 p2.name="jinlian"
// p2 = null // 错误的，因为 p2 是 val 修饰的
 } 
}
class Person{
 var name : String = "jinlian"
} 

Praxis:
Duoyi hat jetzt ein kleines Klassenzimmer zum Verkauf von Kursen (eine kleine E-Commerce-Plattform) gestartet:
Brauchen wir für den Verkauf einige Attributfelder:
Geschäftsname: Duoyi Bildungskursname
: Java Basics, MySQL, Hadoop ... .. Dozenten : Yuan Ge , Tao Ge
, Xing Ge, Wieder kauft neuer Benutzer zum ersten Mal, Student empfiehlt Kauf Aktivitätstyp: 6,18 10,24 11,11 Aktivitätsrabattintensität: 10 % Rabatt 50 % Rabatt 12 % Rabatt Benutzername des Käufers: zhangsan, lisi Telefonnummer des Benutzers: 18860875775, 18860875776 Aktuelle Position des Benutzers: ETL-Ingenieur, Big-Data-Entwicklungsingenieur, Data-Warehouse-Ingenieur Benutzer-E-Mail: E-Mail- Bestellnummer: 111122223333 Bestellmenge: 398 Code:

package com.doitedu

object demo01{

  /**
   * 店铺名称：多易教育
   * 课程名称：java基础,mysql,hadoop.....
   * 讲课老师：源哥,涛哥,星哥,行哥
   * 课程的价格：199,299,399,99
   * 红包类型: 首次购买红包,老学员红包
   * 红包金额：9.9  18.8
   * 活动名称：老用户再次购买,新用户首次购买,学员推荐购买
   * 活动类型：6.18     10.24  11.11
   * 活动折扣力度：9折   5折   8.8折
   * 购买用户用户名：姜海涛，江一
   * 用户手机号：18860875775，1886087，5776
   * 用户现在的职位：etl工程师，大数据开发工程师，数仓工程师
   * 用户的邮箱：email
   * 订单号：111122223333
   * 订单金额：119.4
   */
  def main(args: Array[String]): Unit = {
    //店铺名称：多易教育
    val shopName = "多易教育"
    //课程名称：java基础,mysql,hadoop.....
    val subjectName = "java基础"
    //讲课老师：源哥,涛哥,星哥,行哥
    val tName = "涛哥"
    //课程的价格：199,299,399,99
    val subjectPrice = 199.00
    //红包类型: 首次购买红包,老学员红包
    val bonusType = "new"
    //红包金额
    val bonus = 9.9
    //活动名称
    val activeName = "老用户再次购买"
    //活动类型：6.18     10.24  11.11
    val activeType = "程序员节"
    //活动折扣力度
    val activeDiscount = 0.6
    //购买用户用户名
    val userName = "haiTao Jiang"
    //用户手机号
    val tel = "13372090488"
    //用户邮箱
    val email = "[email protected]"
    //订单号
    val orderId = "111122223333"
    //订单金额
    val orderAmount = 119.4
  }

}

Namenskonventionen für Bezeichner

Die Zeichenfolge, die Scala zur Benennung verschiedener Variablen, Methoden, Funktionen usw. verwendet, wird als Bezeichner bezeichnet. Das heißt: Jeder
Ort, an dem man ihn benennen kann, wird als Identifikator bezeichnet.
Benennungsregeln:
Die Bezeichnerdeklaration in Scala ist grundsätzlich dieselbe wie in Java, die Details werden sich jedoch ändern. Zusammenfassend gibt es drei Punkte:

1. Beginnen Sie mit einem Buchstaben oder Unterstrich, gefolgt von Buchstaben, Zahlen und Unterstrich. Unter normalen Umständen: Buchstaben und Unterstriche Kommen gelegentlich mit einer Zahl
2. Beginnen Sie mit einem Operator und enthalten Sie nur Operatoren (+ - / # ! usw.)
3. Jede in Backticks eingeschlossene Zeichenfolge ...., sogar Scala-Schlüsselwörter (39)

• Paket, Import, Klasse, Objekt, Merkmal, erweitert, mit, Typ, für
• privat, geschützt, abstrakt, versiegelt, endgültig, implizit, faul, überschreiben
• versuchen, fangen, schließlich werfen
• if, else, match, case , do, while, for, return, yield
• def, val, var
• this, super
• new
• true, false, null

Übung:
Anforderungen: Judge hello, Hello12, 1hello, hb, xh, h_4, ab, Int, , + -/#!, + -/#!1, if, , ifdiese Namen sind legal.

object Test01 {
 def main(args: Array[String]): Unit = {
 // （1）以字母或者下划线开头，后接字母、数字、下划线
 var hello: String = "" // ok
 var Hello12: String = "" // ok
 var 1hello: String = "" // error 数字不能开头
 var h-b: String = "" // error 不能用-
 var x h: String = "" // error 不能有空格
 var h_4: String = "" // ok
 var _ab: String = "" // ok
 var Int: String = "" // ok 因为在 Scala 中 Int 是预定义的字符,不是关键字，但不推荐
 var _: String = "hello" // ok 单独一个下划线不可以作为标识符，因为_被认为是一个方法println(_)
 //（2）以操作符开头，且只包含操作符（+ - * / # !等）
 var +*-/#! : String = "" // ok
 var +*-/#!1 : String = "" // error 以操作符开头，必须都是操作符
 //（3）用反引号`....`包括的任意字符串，即使是 Scala 关键字（39 个）也可以
 var if : String = "" // error 不能用关键字
 var `if` : String = "" // ok 用反引号`....`包括的任意字符串,包括关键字
 } 
}

String-Ausgabe

Grundlegende Syntax:

1. Zeichenfolge, verkettet durch +-Zeichen
2. printf-Verwendung: Zeichenfolge, Wert in % übergeben.
3. String-Vorlage (Interpolationsstring): Variablenwert durch $ abrufen

Codetest:

package com.doitedu.demo04
object TestString{
 def main(args: Array[String]): Unit = {
 var name: String = "jinlian"
 var age: Int = 18
 
 //（1）字符串，通过+号连接
 println(name + " " + age)
 
 //可以用$来引用变量，大括号{}可以写也可以不写，如果不写，中间要用空格隔开
//最前面小写的s就是固定写法，写了他相当于就是一个模板字符串，咱们可以用$去引用变量了
println(s"${name}今年${age}岁了")
 
 //（2）printf 用法字符串，通过%传值。 他是不换行的，如果需要换行，那么要用\r\n来写在末尾换行
 printf("name=%s age=%d\r\n",name,age)
 
 val price = 119.99
printf("这个商品的价格是%.2f",price)

 //（3）字符串，通过$引用
//多行字符串，在 Scala中，利用三个双引号包围多行字符串就可以实现。
//输入的内容，带有空格、\t 之类，导致每一行的开始位置不能整洁对齐。
//应用 scala 的 stripMargin 方法，在 scala 中 stripMargin 默认
是“|”作为连接符，//在多行换行的行头前面加一个“|”符号即可。
val sql =
  """
    |select
    |name,
    |count(1) as cnt
    |from
    |table_a
    |where name = "zhangSan"
    |and age = 18
    |group by name;
    |""".stripMargin
println(sql )
//如果需要对变量进行运算，那么可以加${}
val sql01 =
  """
    |select
    |name,
    |count(1) as cnt
    |from
    |table_a
    |where name = "$name"
    |and age = ${age+2}
    |group by name;
    |""".stripMargin
 println(sql01 )
 val s2 = s"name=$name"
 println(s2)
 } 
}

printf中格式化输出的模板
 %d 十进制数字
 %s 字符串
 %c 字符
 %e 指数浮点数
 %f 浮点数
 %i 整数（十进制）
 %o 八进制
 %u 无符号十进制
 %x 十六进制

Datentyp (Hervorhebung)

Java-Basistypen: char, byte, short, int, long, float, double, boolean
Java-Referenztyp: (Objekttyp)
Java-Basistyp-Wrapper-Klassen: Character, Byte, Short, Integer, Long, Float, Double,
Boolean Java hat Basistypen und Basistypen sind keine echten Objekte. Auch wenn die Basistyp-Wrapper-Klassen später generiert werden, gibt es immer noch Basisdatentypen, sodass die Java-Sprache nicht wirklich objektorientiert ist.
• Der größte Unterschied zwischen den Datentypen in Scala und den Datentypen in Java besteht darin, dass die Datentypen in Scala alle Objekte sind, das heißt, es gibt keinen nativen Datentyp in Scala! • Die Datentypen in Scala sind in zwei Typen unterteilt : AnyVal (Werttyp) und
AnyRef (Referenztyp), beide Objekte gehören zu Any und beide sind Objekte.
val age: Int = 23
age ist eine Variable vom Werttyp Int, und eine Variable vom Werttyp gehört auch zu einem Objekt. Daher ist die Altersvariable ein Objekt und verfügt über viele Methoden
. Hinweis: Primitive Typen und Referenztypen haben in Java keinen gemeinsamen Vorfahren.

1. Any: Die übergeordnete Klasse aller Typen, ähnlich wie Object in Java
2. AnyVal: Numerischer Typ (einfacher Typ) ==-" entspricht dem Basisdatentyp in Java
3. AnyRef: Referenzdatentyp
4. Null: Unterklasse des Referenztyps, ähnlich wie null in Java == „Schreiben Sie eine Klasse, die den Wert von null in dieser Null einkapselt
5. Einheit: Entspricht void in Java und zeigt an, dass die Methode keinen Rückgabewert hat. Ihr Wert lautet: () == „Da für dieses Objekt die toString-Methode neu geschrieben wird
6. Nichts: Die Unterklasse des Typs wird hauptsächlich verwendet, wenn eine Funktion keinen eindeutigen Rückgabewert hat. Sie wird normalerweise verwendet, wenn eine Ausnahme vorliegt, die darauf hinweist, dass hier ein Fehler vorliegt

Detaillierte Datentyptabelle:

Einheitentyp, Nulltyp und Nichtstyp

Art der Daten	beschreiben
Einheit	Gibt keinen Wert an, was in anderen Sprachen „void“ entspricht. Wird als Ergebnistyp für Methoden verwendet, die keine Ergebnisse zurückgeben. Die Einheit hat nur einen Instanzwert, geschrieben als ().
Null	null , der Null-Typ hat nur einen Instanzwert null
Nichts	Der Nothing-Typ befindet sich am Ende der Klassenhierarchie von Scala; er ist ein Untertyp jedes anderen Typs. Wenn eine Funktion sicher ist, dass es keinen normalen Rückgabewert gibt, können wir Nothing verwenden, um den Rückgabetyp anzugeben. Dies hat den Vorteil, dass wir den zurückgegebenen Wert (Ausnahme) anderen Funktionen oder Variablen zuweisen können (Kompatibilität).

Typkonvertierung

Wenn ein Scala-Programm eine Zuweisung oder Operation ausführt, wird der Typ mit geringerer Genauigkeit automatisch in den numerischen Typ mit höherer Genauigkeit konvertiert, was einer
automatischen Typkonvertierung (implizite Konvertierung) entspricht. Die Datentypen sind nach Genauigkeit (Kapazität) sortiert:

veranschaulichen:

1. Prinzip der automatischen Förderung: Wenn es mehrere Arten von Datenmischoperationen gibt, konvertiert das System zunächst alle Daten automatisch mit hoher Präzision in den Datentyp und führt dann Berechnungen durch.
2. Bei der Zuweisung eines numerischen Typs mit hoher Genauigkeit zu einem numerischen Typ mit niedriger Genauigkeit wird ein Fehler gemeldet, andernfalls wird eine automatische Typkonvertierung durchgeführt. toInt toDouble
3. Es gibt keine automatische Konvertierung zwischen (byte, short) und char.
4. Byte, Short und Char können berechnet werden und werden während der Berechnung zunächst in den Typ int konvertiert.

Testfall:

object Test {
 def main(args: Array[String]): Unit = {
 //（1）自动提升原则：有多种类型的数据混合运算时，系统首先自动将所有数据转换成精度大的那种数值类型，然后再进行计算。
 var n = 1 + 2.0
 println(n) // n 就是 Double
 //（2）把精度大的数值类型赋值给精度小的数值类型时，就会报错，反之就会进行自动类型转换。
 var n2 : Double= 1.0
 //var n3 : Int = n2 //错误，原因不能把高精度的数据直接赋值和低精度。
 //（3）（byte，short）和 char 之间不会相互自动转换。
 var n4 : Byte = 1
 //var c1 : Char = n4 //错误
 var n5:Int = n4
 //（4）byte，short，char 他们三者可以计算，在计算时首先转换为 int类型。
 var n6 : Byte = 1
 var c2 : Char = 1
 // var n : Short = n6 + c2 //当 n6 + c2 结果类型就是 int
 // var n7 : Short = 10 + 90 //错误
 } 
}

Operator

arithmetischer Operator

Testcode:

object Test {
  def main(args: Array[String]) {
    var a = 10;
    var b = 20;
    var c = 25;
    var d = 25;
    println("a + b = " + (a + b) );
    println("a - b = " + (a - b) );
    println("a * b = " + (a * b) );
    println("b / a = " + (b / a) );
    println("b % a = " + (b % a) );
    println("c % a = " + (c % a) );
  }
}

relationaler Operator

Codetest:

def main(args: Array[String]) {
  var a = 10;
  var b = 20;
  println("a == b = " + (a == b) );
  println("a != b = " + (a != b) );
  println("a > b = " + (a > b) );
  println("a < b = " + (a < b) );
  println("b >= a = " + (b >= a) );
  println("b <= a = " + (b <= a) );
}

Logische Operatoren

Codetest:

val a = true
val b = false

println("a && b = " + (a && b))//false

println("a || b = " + (a || b))//true

println("!(a && b) = " + !(a && b))//true

Aufgabenverwalter

Hinweis: In Scala gibt es kein ++ – ersetzen Sie += -=

Codetest:

object Test {
 def main(args: Array[String]): Unit = {
 var r1 = 10
 r1 += 1 // 没有++
 r1 -= 2 // 没有--
 }
}

bitweiser Operator

Testcode:

object TestPosition {
 def main(args: Array[String]): Unit = {
 // 测试：1000 << 1 =>10000
 var n1 :Int =8
 n1 = n1 << 1
 println(n1)  //16 
 } 
} 

Priorität

Prozesssteuerung

Die Flusskontrolle in Scala ist grundsätzlich dieselbe wie in Java

Bereichsdatenschleife (To)

Grundgrammatik

for(i <- 1 to 10){
  println(i)
}

（1）i 表示循环的变量，<- 规定 to 
（2）i 将会从 1-3 循环，前后闭合

Anforderung: Ausgabe von 5 Sätzen „Hallo Welt“

object TestFor {
 def main(args: Array[String]): Unit = {
 for(i <- 1 to 5){
 println("hello  world"+i)
 }
 } 
}

Bereichsdatenschleife (bis)

Grundlegende Syntax:

for(i <- 1 until 5) {
    println(i)
}

（1）这种方式和前面的区别在于 i 是从 1 到 5-1 即[0,5)
（2）即使前闭合后开的范围
练习：
需求：用until输出 5 句 "hello  world"
Scala
object TestFor {
 def main(args: Array[String]): Unit = {
 for(i <- 1 until 5+1){
 println("hello  world"+i)
 }
 } 
}

Schleifenschutz

Grundgrammatik

for(i <- 1 to 3 if i != 2) {
     println(i)
}

// 循环守卫，即循环保护式（也称条件判断式，守卫）。保护式为 true 则进入循环体内部，为 false 则跳过，类似于 continue。 
// 代码等价：

for (i <- 1 to 3){
    if (i != 2) {
        print(i + " ")
    } 
}    

// 需求：输出 1 到 5 中，不等于 3 的值
object TestFor {
 def main(args: Array[String]): Unit = {
 for (i <- 1 to 5 if i != 3) {
 println(i + "doit")
 }
 } 
} 

Zyklusschrittgröße
Grundlegende Syntax:
Beschreibung: Mittels Schrittgröße

    for (i <- 1 to 10 by 2) {
     println("i=" + i)
    }

// 需求：输出 1 到 10 以内的所有奇数
for (i <- 1 to 10 by 2) {
println("i=" + i)
}

结果：
i=1
i=3
i=5
i=7
i=9

Variablen importieren:

Grundlegende Syntax:

for(i <- 1 to 3; j = 4 - i) {
 println("i=" + i + " j=" + j)
}

Erläuterung:
(1) Wenn eine for-Ableitung mehrere Ausdrücke enthält, fügen Sie ; hinzu, um die Logik zu trennen.
(2) Es gibt eine ungeschriebene Vereinbarung in der for-Ableitung: Verwenden Sie Klammern, wenn die for-Ableitung nur einen einzelnen Ausdruck enthält, wenn sie mehrere enthält Ausdrücke, im Allgemeinen ein Ausdruck pro Zeile, und geschweifte Klammern werden anstelle von Klammern verwendet, wie im folgenden
Beispiel gezeigt:

for {
 i <- 1 to 3
 j = 4 - i
} {
 println("i=" + i + " j=" + j)
} 
// 等价得代码：
Scala
for (i <- 1 to 3) {
 var j = 4 - i
 println("i=" + i + " j=" + j)
}

Schleifenrückgabewert

Grundlegende Syntax:

val res = for(i <- 1 to 10) yield i
println(res)
// 说明：将遍历过程中处理的结果返回到一个新 Vector 集合中，使用 yield 关键字。

// 练习：需求：将原数据中所有值乘以 2，并把数据返回到一个新的集合中。
object TestFor {
 def main(args: Array[String]): Unit = {
     var res = for(i <-1 to 10) yield {
         i * 2
     }
     println(res)
 } 
}

输出结果：
Vector(2, 4, 6, 8, 10, 12, 14, 16, 18, 20)

Drucken Sie in umgekehrter Reihenfolge

Hinweis: Wenn Sie einen Datensatz in umgekehrter Reihenfolge drucken möchten, können Sie die Funktion „Umkehren“ verwenden.
Anforderung: Drucken Sie 10 zu 1 in umgekehrter Reihenfolge

for(i <- 1 to 10 reverse){
 println(i)
}

Schleifenunterbrechung

Grundlegende Erklärung:
Die integrierte Kontrollstruktur von Scala entfernt speziell Unterbrechungen und passt sich weiterhin besser an die funktionale Programmierung an. Es wird empfohlen, anstelle eines Schlüsselworts den funktionalen Stil zu verwenden, um die Funktionen von Unterbrechung und Fortsetzung zu lösen. Scala verwendet die zerbrechliche Kontrollstruktur, um Unterbrechungs- und Fortsetzungsfunktionen zu implementieren.

Methode 1: Verlassen Sie die Schleife auf ungewöhnliche Weise

object Demo_while {
  def main(args: Array[String]): Unit = {
    try {
      for (emel <- 1 to 10) {
        println(emel)
        if (emel == 5) {
          throw new RuntimeException
        }
      }
    } catch {
      case e: Exception =>
    }
    println("hello")
  }
}

Methode 2: Verwenden Sie die mit Scala gelieferte Funktion, um die Schleife zu verlassen

import scala.util.control.Breaks

object Demo_while {
  def main(args: Array[String]): Unit = {
    Breaks.breakable(
      for (emel <- 1 to 10) {
        println(emel)
        if (emel == 5) {
          Breaks.break()
        }
      }
    )
    println("正常结束循环")
  }
}

Pausen weglassen

object Demo_while {
  def main(args: Array[String]): Unit = {
    breakable(
      for (emel <- 1 to 10) {
        println(emel)
        if (emel == 5) {
          break()
        }
      }
    )
    println("正常结束循环")
  }
}