2、Scala基礎知識

時間 2019-12-11

標籤 scala 基礎知識欄目 Scala 简体版

原文原文鏈接

Scala基礎知識

誰適合閱讀本教程？java

本教程適合想從零開始學習 Scala 編程語言的開發人員,強烈建議你有必定的 JAVA 基礎，由於 Scala 從 JAVA 演化而來

學習任務

一、解釋器
二、基礎語法
三、函數
四、條件與循環

2.一、Scala解釋器

2.1.一、交互模式

顧名思義就是在命令行調用scala的基礎環境，咱們在第一篇演示的命令行輸出Hello,World!便是。固然Scala在交互模式下可以作不少的事情。在這裏咱們只作簡單的輸出演示。

CTRL+C退出交互模式spring

2.1.二、腳本模式

相似於咱們在命令行經過 java *.java執行同樣，咱們經過記事本建立一個文件HelloWorld.scala,存儲在指定目錄，我存儲在了/Users/sunliangliang/Desktop/temp這個目錄下，代碼以下編程

object HelloWorld {
   /* 這是個人第一個Scala項目，
    * 輸出"Hello，Scala！"
   */
   def main(args: Array[String]) {
      println("Hello, Scala!")
   }
}

在命令行執行 scala /Users/sunliangliang/Desktop/temp/HelloWorld.scala,看到以下輸出結果 springboot

2.二、基礎語法

2.2.一、基礎內容普及

區分大小寫：大小寫敏感，即Scala和scala在程序中含義不一樣
類名：首字母大寫，駝峯式
方法名：首字母小寫，駝峯
文件名：文件名要和對象/類名匹配
包名：全小寫
常量名：全大寫
行結尾: 行結尾的";"可省略
空格與縮進：運算符先後保留一個空格如：

def main(args: Array[String]): Unit = {
    print("Hello world")
  }

語法規範基本和java同樣，其餘可參考java相關規範。微信

2.2.二、變量與常量

一、常量的聲明:

val 常量名：數據類型 = 值 scala採用數據類型在後面的方式數據結構

val str : String = "Scala"

二、變量的聲明：

var 變量名 : 數據類型 = 值 ，以下圖編程語言

var number : Int = 2

如上面，注意運算符先後空格，行結尾分號可省略，數據類型Int和String都是大寫，這是不一樣於java的一些地方ide

2.2.三、數據類型

scala全部的數據類型都是對象，沒有java的原生基本類型

一、經常使用數據類型

Scala和java的數據類型基本一致函數

數據類型	描述
Byte	同java byte
Short	同java short
Int	同java int
Long	同java long
Float	同java float
Double	同java Double
Char	同java char
String	同java String
Boolean	同java boolean, true/false
Unit	無值，同java void,用於不返回結果的函數。Unit只有一個實例值,寫成()

二、其餘經常使用類型

數據類型	描述
Null	同java null
Nothing	全部類的最底端，全部其餘類型的子類型
Any	其餘類的超類，全部類的父類
AnyRef	其餘全部類的基類

以下圖爲Scala數據結構的結構圖
oop

2.2.四、關鍵字與標識符

一、關鍵字

Scala有39個關鍵字，有一部分和java重合

package, import, class, object, trait, extends, with, type, forSome
private, protected, abstract, sealed, final, implicit, lazy, override
try, catch, finally, throw
if, else, match, case, do, while, for, return, yield
def, val, var
this, super
new
true, false, null

以下圖所示是java和Scala的重合的地方

二、標識符

一、字母標識符

以字母或者下劃線開頭，以後能夠跟字母數字或者下劃線。不能使用$，儘管能夠編譯經過
Scala遵循java的駝峯式標識符，所以儘管下劃線是合法的，可是爲了同java保持一致，儘可能不要使用

二、操做標識符

由一個或多個操做字符組成，同java或其餘語言，如 + ++ ::: <?> :->等

2.三、方法與函數

函數和方法相似，這裏的方法和java中的基本一致，二者主要區別在於在Scala中函數是一個值，能夠賦值給一個val變量，而方法不能夠。

2.3.一、方法的定義與調用

方法的定義

def 方法名(參數列表): 返回類型 = {方法體},如：

def add(x:Int,y:Int): Int = {
    x+y
  }

在scala中方法體的最後一行做爲函數的返回值，不須要寫return

方法的調用

方法名(參數)，同java，以下圖

object Helloworld {

  def main(args: Array[String]): Unit = {
    val result = add(2,7)//調用函數
    println(result)
  }

  /**
    * 方法的定義與聲明
    * @param x
    * @param y
    * @return
    */
  def add(x:Int,y:Int): Int = {
    x + y
  }
}

2.3.二、函數的定義與調用

函數的定義

val multiply = (x:Int,y:Int) => x*y;//定義一個函數，乘法

函數的調用

println(multiply(2,5)) //函數的調用

方法和函數之間也能夠相互轉換，以下

方法轉函數

val plus = add _

神奇的下劃線將方法轉化爲了函數，注意==上面的代碼須要寫在方法體外，做爲全局的變量==

2.3.三、主函數

同java的main函數，scala中main函數一樣做爲函數的入口。在scala中，main函數必須定義在object中（Java中，main函數必須是class中的static方法），有兩種方式，第一種參考上面Helloworld代碼，另外一種以下

object FastScalaApp extends App {
  override def main(args: Array[String]): Unit = {
    print("FastScalaApp started!!!")
  }
}

這種相似於springboot中的入口類

2.四、條件與循環

2.4.一、條件

一、條件：if->else，以下圖

/**
    * 條件語句
    * @param x
    */
  def condition(x:Int): Unit ={

    if (x>10){
      print("x 比 10 大")
    } else if (x == 10){
      print("x 和 10 相等")
    }else{
      print("x 比 10 小")
    }
  }

此處，else if 和 else也可省略。
一個if語句能夠跟着一個可選的else if ... else

注意事項

一、if後面能夠有0或者多個else語句，可是整個語句的最後，即前面條件都匹配不到纔會執行

二、if後能夠有0或者多個else if語句，else if語句在if 和 else語句之間

三、一個else if 匹配成功後續的else if 和 else就都不會執行。

二、嵌套if

if(x > 5){
      if (x<10){
        print("x 在5 和10 之間")
      }
    }

2.4.二、循環

scala的循環類型和java同樣，包含如下三類

循環類型	描述
while循環	同java
do ... while循環
for循環

循環控制語句

控制	描述
break	結束循環並執行循環下語句

while循環

/**
    * while循環
    */
  def whileLoop(): Unit ={
    var num = 10
    while (num>0){
      println(num)
      num = num-1
    }
  }

輸出結果以下:

do ... while 循環

/**
    * do while循環
    */
  def doWhileLoop(): Unit ={
    var num = 10;
    do {
      println(num)
      num=num-1
    }while(num>0)
  }

for 循環

Scala的for循環特性被稱之爲for推導式或for表達式
for循環最簡單的語法是

for(var x <- Range){
    ...
}

Range能夠是數字範圍，表示i到j的值。 <-運算符稱之爲生成器，它從一個範圍中獲取值

一、關鍵字to: i to j(包含j)

/**
    * for循環
    */
  def forLoop(): Unit ={
    for (x <- 1 to 10){
      println(" x = "+x)

    }
  }

以下圖，x的值輸出了10

二、關鍵字until: i until j(不包含)

def untilForLoop(): Unit ={
    var y = 10;
    for (y<- 1 until 10){
      println("y = " +y)
    }
  }

以下圖，y的值不包含10

三、for循環多表達式

即嵌套for循環

def for01(): Unit ={

    for (i<- 1 to 8 ; j<- 6 to 10){
      if (i==j){
        println(s"i=$i, j=$j")
      }
    }
  }

四、for循環與yield關鍵字

for循環中的yield關鍵字會將當前元素記錄下來保存到集合中，結束循環後返回該集合。scala的for循環有返回值，返回值爲被循環對象。

/**
    * yeild 會將處理後的結果返回給list
    */
  def forWithYield(): Unit ={
    val list = for (i<- 1 to 10) yield i*2

    for(i<- list){
      println(i)
    }
  }

yield後能夠跟表達式

一、yield關鍵字，在每次for循環會生成一個緩衝變量，循環結束以後，將buffer中的變量合併返回一個集合
二、合併返回的集合和循環中的數據類型一致。

五、for循環守衛

這種語法是scala和java的區別，循環守衛，又稱循環保護,本質上就是條件判斷。條件判斷爲TRUE時則進入循環體，不然跳出，相似java的continue關鍵字

def for02(): Unit ={

    for (i<- 1 to 10 if i%2==0){
      println("符合條件的i = "+i)
    }

  }

上面的代碼其實等價於

def for03(): Unit ={

    for(i<- 1  to 10){
      if (i%2==0){
        println("符合條件的i = "+i)
      }
    }
  }

這就是scala的神奇之處，這樣會削減代碼量，後面還有不少相似的方式。

這裏咱們能夠改造以前嵌套for循環的例子，以下

def for001(): Unit ={

    for (i<- 1 to 8 ; j<- 6 to 10 if i==j){
      println("i和j的交集爲：i=j="+i)
    }
  }

六、for循環與容器

/**
    * for循環與list
    */
  def forLoopWithList(): Unit ={
    val list = List(1,2,3,4)
    for (i<- list){
      print("i = "+i)
    }
  }

注意事項：
scala的for循環表達式和java仍是有很大區別的，可是基本原理是同樣的。

課後做業

一、打印輸出1~100之內的3的倍數的整數的個數以及這些和

def result(): Unit ={
    var sum = 0;
    var totalNum = 0;
    for (i<- 1 to 100 if i%3==0){
      totalNum+=1
      sum+=i
    }
    println(s"100之內3的倍數的數有 sum=$sum, totalNum = $totalNum")
  }