scala基礎知識點有哪些

本篇內容介紹了“scala基礎知識點有哪些”的有關知識，在實際案例的操作過程中，不少人都會遇到這樣的困境，接下來就讓小編帶領大家學習一下如何處理這些情況吧！希望大家仔細閱讀，能夠學有所成！

第一章：基礎

1、聲明變量：val name1，name2: String=”hello” val不可變變量，var可變。
2、常用類型：Byte、Char、Short、Int、Long、Float、Double、Boolean。但是不像Java這里是是實實在在的類，具有方法。
3、+-*/等操作符其實是方法:a + b類似于a.+(b).Scala中可以將方法調用的.省略：如1.to(10) 類似于1 to 10。
4、沒有++操作符，因為Scala中大部分的算術類型都是不可變的如Int類型。
5、Scala.math中定義了很多方法，類似于靜態方法。引入包后可以直接調用如：sqrt(4)。
6、Scala中沒有static靜態關鍵字，不過存在一個單例對象定義：object a{}，該類中的方法可以直接通過類名調用，類似于靜態方法。通常一個類（class）應有一個伴生對象(object)。
7、不帶參數的Scala方法通常可以不使用括號如：”hello”.distinct。每行語句結束不需要；號，除非一行有多條語句。
8、Scala中可以重載操作符，如之前的+-*/等操作符都是重載的方法。另外還有個特例()操作符重載，通過在類中定義一個apply方法就可以重載如：”hello”(4)類似于Java中的”hello”.charAt(i)。

第二章：控制結構和函數

1、條件表達式：if(x>0) 1 else -1 或 if(x>0){ 1 }else{ -1}。此處1 else -1 是一個表達式，返回類型是兩個分支的公共類型。
2、Unit就是Java中的void，可以用()代替。
3、塊表達式：{}表示為塊，也是表達式，其返回類型是塊中最后一個表達式的值。
4、賦值：賦值語句的返回類型是Unit如：x=1的值是Unit，所以不能x=y=1這樣進行賦值，除非x是Unit類型。在使用x={}進行賦值時也要注意最后一個表達式是否為賦值語句。
5、輸入和輸出：輸入，直接調用readLine()或者readInt等。輸出，print、println、printf(“%s”,”hello”)
6、Scala有與Java和C++一樣的while和do循環形式。但for循環不一樣
7、for循環簡單語法：for(i <- 集合){}，注意<-符號代表去讓i變量遍歷右邊的集合。示例：for(i <- 1 to 10) 能取到10 for(i <- 1 util 10)不能取到10。
8、跳出循環：1、函數中可以使用return跳出函數 2、循環條件使用Boolean變量 3、使用Breaks對象中的break方法：

import scala.util.control.Breaks._
var sum = 0
breakable {
  for (i <- 0 to 10) {
   sum += i
   if (sum >= 10) break
 }
}

9、高級for循環之生成器：for(i <- 1 to 3; from=4-i; j<- from to 3 if(i!=j))print((10*i +j)+” “)//將打印 13 23 31 32 解釋：第一層循環i，每次循環i的時候第二層循環j。其中循環中變量from可以省，if語句用于篩選，注意if前面沒有分號。可以使用{}代替()來換行使用。
10、for循環與yield結合使用，則整個循環語句返回的結果是一個集合，當for循環中有兩個生成器時返回結果使用第一個生成器兼容的格式：for(i <- 1 to 10) yield i % 3 //結果：scala.collection.immutable.IndexedSeq[Int] = Vector(1, 2, 0, 1, 2, 0, 1, 2, 0, 1)
11、Scala與C++相同支持函數，函數定義格式為：def abs(x:Double)= if(x>=0) x else -x 。必須指定函數的參數類型，如果函數不是遞歸就不需要寫出返回類型。如果函數需要多個表達式才能實現可以使用代碼塊{}，塊中最后一個表達式就是返回值。Scala函數中不建議使用return返回，你可以使用但不推薦。遞歸函數：def fac(n:Int):Int =if(n<=0) 1else n*fac(n-1)
12、默認參數：就是在函數定義時將參數賦值如：def decorate(str:String,left:String=”[“,right: String =”]”)left+str+right。調用該函數的時候可以只用給出str的參數值就行，其他兩個參數會使用默認參數，也可以在提供參數時給出參數名賦值參數，可以不按照順序。
13、變長參數：def sum(args:Int*)={},需要接受的是seq的參數，sum（2 to 10）是錯誤的。可以通過追加：_*來解決不能接受的問題：sum(2 to 10:_*)
14、過程：沒有函數名后面等號的函數稱為過程，返回的是Unit.
15、懶加載：lazy val words=初始化表達式 ，該變量只有在使用時才會調用初始化
16、異常：異常與Java的異常類似，但是不強制函數向上傳遞異常。

第三章：數組

1、定義定長數組：類似Java和C++中的數組。定義：val nums=new Array[Int](10),會初始化為0，取值：nums(0)、賦值：nums(0)=12
2、定義變長數組：類似于Java/C++中的list。需要引入ArrayBuffer，定義：val b=ArrayBuffer[Int]()。取值:b(1)、尾部追加：b+=1、b+=(1,2,3,5)、b++=Array(1,2,3)、插入：b.insert(index,(邊長參數))、移除：b.remove(index,可省參數：刪除多少個)
3、遍歷：for(i<- 0 until (a.length,2))，以每兩個元素進行遍歷。或者直接for(elem<-a)
4、數組轉換：for(elem<-a)yield 2*elem 返回與a同樣類型的集合
5、常用算法：求和：a.sum、最大/最小：a.max/min、排序：a.sorted/sortwith、打印：a.mkString(” and “) mkString(“<”,”,”,”>”)
6、多維數組：val matrix=Array.ofDim[Int](3,4) 訪問：matrix(row)(column)=12。可以創建不同維度的數組：val triangle=new Array[Array[Int]](10)

第四章：字典和元組

1、定義不可變的映射：val socers=Map(“alice”->10,”bob”->3)或者val socers=Map((“alice”,10),(“bob”,11))，定義好后就不能改變了
2、定義可變的映射：使用包mutable下面的Map：val socers=Map(“alice”->10,”bob”->3)，或者使用HashMap
3、映射操作：獲取映射中的值scores(bob),改操作如果不存在建會報錯，一般使用socers.getOrElse(“bob”,0)存在就返回，不存在返回None。增改操作：scores(bob)=10,socres +=(“alice”->1,”bob”->30)。刪除操作：socres-=”alice”。
4、對于不可變的Map可以通過重新賦值進行增改：val so=scores+(“bob”->1) 刪：val so=scores-“bob”。
5、遍歷映射：同時處理鍵和值 for((k,v)<-映射)處理k和v，遍歷鍵：for(k<-scores.keySet),遍歷值：for(v<-scores.values)。
6、已排序映射：SortedMap。按插入順序訪問所有鍵：LinkedHashMap。
7、元組：類似于Python中元組.如：(1,3.14，”bob”),可以通過_1/_2/_3來進行訪問其組元。字符串中存在一個partition的來處理字符串生成元組。可以使用zip來合成元組。

第五章：類

1、簡單類和無參方法：字段和方法默認是public的，字段必須初始化，類不用聲明為public的，一個文件中可以包含多個類并且公有可見。方法調用時沒有參數時可以不帶(),一般對取值不帶().

class Hello{
    private val value: Int=2
    def increment(){value+=1}
    def current=value
}

2、get和Set方法：scala中對每個字段都帶有默認的get和set方法：value 和 value_=；當然你也可以像上面小結1一樣自己定義相關的方法。
3、對于私有字段，如果本類中調用了相同類的對象可以直接使用。另外對于private[this] var value=0//該字段只能本對象使用，也稱對象私有。
4、如果要使用Java中類似的Bean屬性類，只需要將字段標注為@BeanProperty將會字段生成。

5、輔助構造器：類似于Java/C++中的構造器，但是有兩點不同：1)所有輔助構造器的名字都為this,2)每一個輔助構造器都必須以一個先前定義的其他輔助或主構造器的調用開始。
6、主構造器是與類定義交織在一起定義的，如果沒有參數則是默認的主構造器。如果帶參數則在類名后的()中定義，如果使用表5.1中定義的參數，將在類中為字段，如果不包含val和var，沒有方法使用的情況下改參數只用于語句訪問，如果方法使用了就是對象私有字段。在new對象時會先調用主構造器，然后執行定義中的所有語句，最后執行new。

object work5 {
  def main(args: Array[String]): Unit = {
    val a=new test(1)
  }

}
class test(val a:Int=0,b:Int=1){

  println(b)
  def this(ta:Int){
    this(ta,2)
    println("1")
  }
}
//輸出：2、1

7、嵌套類：可以在任可語法中使用嵌套類，Scala中每個實例對象都有它自己的嵌套類，也就是說兩個實例的嵌套類是不同的兩個類。解決這個問題可以通過伴生對象和類型投影

第六章：對象

1、單例對象：Scala中沒有靜態方法和靜態字段，你可以用object這個語法來達到同樣目的，object定義的就是單例對象。可以有屬性和方法，可以通過名字直接使用功能。基本上具有類的所有屬性甚至可以擴展其他類，但是主構造器不能帶參數。
2、伴生對象：可以通過定義與類同名的伴生對象來實現像Java和C++中類即有靜態方法和實例方法的類。伴生對象和該類可以相互訪問私有特性，但是必須在同一個文件中。
3、object可以擴展類和特質，然后繼承了該類或多個特質的特性。
4、對象的apply方法，通過在對象定義apply方法可以直接使用類名()來定義對象而不要使用new，只需要將apply方法來實現對象的new和返回該對象。
5、在Scala中程序必須從object對象的main方法開始。

第七章：包和引入

1、包和Java中的包類似，只是Scala中定義包的方式更多，可以使用{}，可以文件頂部標記。
2、Scala中包的作用域更加前后一致，子包可以直接使用父包中的內容。
3、Scala中引入了包對象，包對象中可以定義方法，屬性。
4、Scala中一樣有包可見性，不同于Java中不帶修飾詞就是包可見，通過使用private[packageName] def description="aaa"+name.實現包可見性。
5、引入類似于Java中的引入，引入全部寫法是 _不是*如：import java.awt._ 。更加靈活的是可以在任何地方都可以聲明引入。
6、引入過程中可以改變類的名字，通過類似元組的方式：import java.util.(HashMap=>JavaHashMap).
7、類似于Java一樣默認引入了java.lang.*包一樣，Scala默認引入了java.lang.、scala.、Predef._。三個包。

第八章：繼承

1、Scala繼承方式與java一樣使用extends關鍵詞，而且也一樣只能繼承單個類。一樣可以通過對類定義是使用final修飾來防止繼承，不同的是Scala還可以使用final修飾方法和屬性來防止重寫該方法和屬性。
2、在Scala中一個非抽象方法重寫時必須使用override修飾符如：override def toString=getClass.geName+super.toString+”peace”。調用父類中的方法通過使用super關鍵詞。
3、測試某個對象屬于哪個類使用isInstanceOf方法，當對象是該類或者子類的對象時返回True.

4、Scala中也有protected修飾符，與java中的一樣
5、子類的輔助構造器不能調用父類的構造器只能通過子類的主構造器進行調用形式如下：

class  Employee(name:String,age:Int,val salary:Double) extends Person(name,age)//通過子類的主構造器進行調用

6、重寫字段

7、Scala也可以和java一樣定義匿名子類。和java一樣也有抽象類通過關鍵字abstract定義。重寫抽象類的方法時不需要override。抽象類中還可以擁有抽象屬性，抽象屬性就是沒有初始化的屬性。
8、對象構造是順序：父類構造器-子類構造器
9、Scala中基本類型和until類型都繼承與Anyval類，其他類都是AnyRef的子類，而Any類是整個繼承層級的根節點類似于java中的object類

第九章文件和正則表達式

1、讀取文件：val source=Source.formFile("fileUrl","UTF-8"),生成Source對象。
讀取文件：
val file=new File(filename)
val in=new FileInputStream(file)
in.read(bytes)

寫入文本文件：

val out=new PrintWriter("numbers.txt")
for(i<- 1 to 100) out.println(i)

2、讀取行函數：val lineIterator=source.getLines 返回所有行的迭代，轉換成字符串：val contents=source.mkString。
3、序列化：Scala通過使用extends繼承serializable特質來實現序列化

4、正則表達式：構造正則對象Regex直接使用r方法：val regx=”[0-9]+”.r。返回所有匹配的迭代器：val matchiterator=regx.findAllIn(“帶匹配字符串”)。首個匹配項：findFirstIn，匹配字符串的開始部分：findPrefixOf。

第十章特質：接口

1、特質定義：使用關鍵字trait定義特質，其中的方法為抽象方法需要實現，不需要限定符abstract，重寫時也不需要給出override關鍵字。

trait Logger{
def log(msg:String)
}
2、特質繼承：繼承使用和類繼承一樣的關鍵字extends，特質可以繼承多個，使用with關鍵字連接就行。
3、特質中可以有具體實現的方法，java中的接口在Scala中可以當做特質來使用，也可以在new對象時繼承特質：val acct=new Peolpe with Logger。
4、特質中的字段可以是具體的也可以是抽象的。如果你給出了初始值那么字段就是具體的，實現該特質的類不是繼承了該字段，而是類似于類定義時定義了字段。抽象字段必須在實現類中寫出該字段。
5、類構造器的調用順序：

6、特質還可以繼承類，該特質被實現時實現類自動繼承特質的超類，假如我們的類已經擴展了另一個類，就必須該類是特質超類的超類。
7、Scala中的特質最后被翻譯成jvm中的接口

第十一章操作符

1、標示符：Scala中可以使用Unicode字符組成標示符，還可以使用所有的AscII字符，但是建議使用類似于java標示符的方式。
2、中置操作符：a 標識符b。如 1-2，1 to 10 其實都是方法調用。中置操作符可以用來重寫操作符，重寫操作符只需要在類中定義該操作符的方法。
3、一元操作符：a 標識符，等同于a.標識符()。一元操作符比較特殊的四個操作符：+、-、！、~可以作為前置操作符。賦值操作符：a+=b。
4、scala當中大部分操作符都是左結合的，除了以冒號(:)結尾的操作符合賦值操作符。如用于構造列表的::操作符就是右結合的：

val a=List(1,2,3,4)
val b=-1::0::a//實際上是按照這樣的順序-1::(2::a)。實際上右結合就是調用第二個參數的方法：a.::(0).::(-1)

5、類似于apply方法的update方法：表達形式：obj(arg1,arg2,..)=value，對應于調用obj.update(arg1,arg2,…,value)方法。apply方法常用于伴生對象中用來構造對象而不顯示的使用new，而update方法常被用于數組和映射中改值使用。
6、apply方法的反向操作方法unapply，常用在對象中用于生成對象，但他的輸入是一個對象然后通過這個對象構造對象：val author="wang he ping" val Name(first,last)=author.這里就是掉用了Name.unapply(author)來構造對象。一般unapply方法返回的是Option類型。

第十二章函數—函數即對象

1、Scala中函數是頭等公民，就和數字一樣可以作為變量一樣作為參數和賦值給其他變量。如：val fun=ceil _就是將ceil函數賦值給了fun函數，函數后的_意味著確實是將這個函數賦值給了fun變量，而不是忘記了輸入參數。該處fun的類型為(Double)=>Double 。接收并返回Double的函數。你可以調用像函數一樣調用：fun(3.14),還可以將該函數傳遞給函數如：Array(3.14,1.42,2.0).map(fun).
2、匿名函數：(x:Double)=>3*x當然也可以將該匿名函數作為函數的輸入參數或者賦值給其他變量：val triple=(x:Double)=>3*x。
3、帶函數參數的函數：定義如下:

def valueAtOneQuater(f:(Double)=>Double )=f(0.25)

調用方式為：valueAtOneQuater(ceil_)或valueAtOneQuater(sqrt)。只要傳入的函數參數是(Double)=>Double 類型。而valueAtOneQuater函數的類型為((Double)=>Double )=>Double
4、返回函數的函數：定義如下：

def mulBy(factor:Double)=(x:Double)=>factor*x

mulBy將返回一個函數：(Double)=>Double，而mulBy自己的類型為(Double)=> (Double)=>Double。
5、參數推斷，當你將一個匿名函數傳遞給函數或方法時，Scala會盡可能推斷類型信息如：valueAtOneQuater((x)=>3*x)函數會推斷出x的類型為Double。當只有一個參數時你還可以直接valueAtOneQuater(x=>3*x)。甚至如果參數在右側只出現了一次你可以用_替換掉x：valueAtOneQuater(3*_)。這些簡寫方式只有在參數已知情況下才有效，一般只推薦在函數參數中使用。
6、一些有用的高階函數:map(fun)對集合中的元素都應用fun函數，filter方法輸出集合中滿足特定條件的集合。等
7、閉包：閉包確保Scala中可以訪問非局部變量，比如上面的mulBy中的factor即是這樣一個變量，通過賦值不同的值不同的調用會不一樣。
8、柯里化：將原本接收兩個參數的方法或函數，轉變為只接收一個參數并返回另外一個函數（以第二個參數為輸入參數）的過程。如下：

def mul(x:Int,y:Int)=x*y
//柯里化
def mul(x:Int)=(y:Int)=>x*y
//柯里化調用
mul(x)(y)
//Scala支持更加簡單的方式
def mul(x:Int)(y:Int)=>x*y

第十三章集合

1、集合都繼承于iterable，與java不同映射也屬于同一層繼承關系。indexedSeq是數組的超類型。
2、Scala中有可變和不可變的集合，不可變的集合不可以改變但是可以通過操作生成新的不可變集合。
3、不可變序列：vector類似于數組但底層機構是樹，不是線性的不過也支持快速的隨機訪問， Range表示的是一個整數序列，Range對象只存儲起始值，結束值和增值。可變序列與java中的大體類似
4、列表：在Scala中列表要么是空的要么是一個head元素加上一個tail元素而tail元素又是一個鏈表，我的思路是：嵌套鏈表，以head開始tail嵌套。存在鏈表操作符::用于將兩個鏈表合成新的鏈表如：9::List(4,2) 結果是List(9,4,2)，head為9.在遍歷時可以用迭代器進行遍歷也可以直接通過遞歸。
5、可變列表與不可變列表類似，只是可以通過elem和next對頭部和尾部進行修改。如 var cur=list cur.elem=0,cur.next=list2
6、用于添加或去除元素的操作符總結如下：

7、將函數應用于集合：集合中有一個map方法接收一元函數為參數然后對集合中所有元素進行處理。還存在接收二元函數為輸入參數的方法如：reduceLeft，foldLeft等。
8、拉鏈操作：zip 用于將兩個集合進行結合成一個集合，而且新生成的集合長度與兩個集合中短的相同。zipwthIndex用于將集合和索引進行結合。
9、流式一個尾部被懶計算的不可變列表，只有當需要時才會計算。流操作符是#:。流的性質當你不用時流只計算了頭元素，其他元素采用懶計算，只有用到時才計算。如下：

//采用#:生成流
def numsFrom(n:BigInt):Stream[BigInt]=n#::numsFrom(n+1);
def main(args: Array[String]): Unit = {
  val squares=numsFrom(1).map(x=>x*x)//懶計算
  println(squares)//這里只輸出Stream(1,?)
  print(squares.take(5).force)//這里強制計算輸出：Stream(1, 4, 9, 16, 25)
}

10、Scala中的集合可以與java中的集合進行互操作，同樣也有線程安裝的集合但不建議使用。
11、并行集合，Scala中提供了方便對大型集合方便的并行操作來加快速度，感覺有點類似于MapReduce。通過par方法產出當前集合的一個并行實現。如： for(i<-(0 until 100).par)print(i+" ")將不會按大小正常輸出，由于底層用了多個線程進行并發計算。但是對于求和等操作會將多個線程的結果進行疊加： print(((0 until 101).toList).par.sum)將輸出5050

第十四章模式匹配和樣例類

1、Scala中的switch通過 ch match{ case 條件 => 語句}，每個case后不需要break，存在與default想類似的全匹配：_ 。另外可以加條件進行判斷來進行處理以匹配更多。如：case _ if(Character.isDigit(ch))=> 語句。
2、模式中的變量：在case關鍵字后面可以跟著一個變量名，那么匹配的表達式會賦值給那個變量，其實全部匹配就是一個變量只是變量名為。同樣你也可以在守衛中使用變量。如case i if character.isDigit(i)=>語句。
3、Scala中你也可以對表達式的類型進行匹配，如：但是不能匹配特定的泛型，如特定的Map類型

obj match {
    case x:Int=>x //其中x為變量，只能匹配整數并將obj賦值給x
    case s:String=>Integer.parseInt(s)//與x類似，只是此處為字符串
    case _:BigInt=>Int.Maxvalue//變量名為_，只能匹配obj為BigInt的類型
    case _ =>0//全部匹配
}

4、匹配數組、列表和元組：匹配時可以通過數組的個數，列表的頭尾，元組的組成等進行匹配。
5、樣例類是一種特殊的類，經常被用于模式匹配，樣例類的創建方式很簡單如下：

abstract class Amout
case class Dollar(value:Double) extends Amount//繼承于Amount
case object Nothind extends Amout//單例也可以樣例類

其中構造器中的每一個參數都為val（除非顯示定義為var），在伴生對象中提供apply方法用于構造新對象，提供unapply方法讓模式匹配可以工作。并且將生成toSting，equals，hashcode，copy等方法。這些都是在定義該樣例類時自動生成的。
在模式匹配時可以將類型為Amount的對象和樣例類進行匹配，然后參數會直接綁定然后直接用樣例類中的變量如下：

amout math{
    case Dollar(v)=>"$"+v
    case Nothing =>" "
}

6、Option類型：Scala中Option[T]類型是用來處理java中null值類型的，Option有兩個子類型一個為None，一個位Some[T]。比如map的get方法在java中可能返回為null而導致出現NullPointerException異常，而Scala中返回的是一個Option[T]類型當值不存在時為None，存在時返回Some(T)通過get方法可以獲得map中的值。
7、偏函數：被包在花括號沒的一組case是一個偏函數，一個并非對所有輸入都有定義的函數，偏函數是PartialFunction[A,B]的一個實例，其中A為輸入,B為返回類型。該類有兩個方法，apply方法用于模式匹配，一個isDefinedAt從輸入中匹配到則返回True。如下：

val f:PartialFunction[Chart,Int]={case '+' => 1;case '-' => -1}
f('+')//調用f.apply('+'),返回1
f.isDefinedAt('-')//返回true
f('0')//拋出MatchError

第十五章注解

1、Scala中注解和Java類似，可以為類，方法，字段，變量，和參數添加注解，同時也可以使用java中定義好的注解。Scala中還可以為主構造器，表達式，泛型參數添加注解。注解定義：注解類需要擴展Annotation特質。
2、針對java特性的注解：比如用@volatile來將字段標記為易失的，沒有用volatile關鍵字，還有如:@transient，@strictfp等注解。以及特殊的接口：@cloneable，@remote等。

第十六章泛型類型

1、Scala中也存在泛型的概率，與java不同Scala的泛型用方括號來定義如：

class pair[T,S](val first: T, val second: S)//泛型類
//調用：可以指定類型，也可以不指定
val p=new Pair[Any,Any](42,"peace")
val p1=new Pair(42,"peace")//推斷類型為Pair[Int,String]
//泛型方法：
def getMiddle[T](a: Array[T])=a(a.length/2)

2、泛型類型限定：類似于java中的T extends comparable 。Scala中用 T<:Comparable[T] 表示。與java不同Scala中存在下界通過R >:T指定。
3、特殊的泛型:試圖界定需要存在隱式轉換如：class Pair(T<%Comparable[T])<%關系意味著T可以被隱式轉換為Comparable[T]。上下文界定需要存在隱式值如：class Pair[T : Ordering]，需要存在Ordering[T]的轉換。
4、類型約束：T=:=U測試T是否等于U，T<:

第十七章高級類型

1、取得類型通過對象.type進行取得，可以獲得運行過程中對象的實際類型。每個類的實例獲得的類型是不一樣的，但是每個實例的類型是該類自己的子類。每個對象的類型都指向自己實際對象，且只有唯一實例。

scala> class Peace
defined class Peace
scala> val p1=new Peace
p1: Peace = Peace@183ec003
scala> val type1 : p1.type=p1//將p1的類型復制給type1，必須注明類型為p1.type
type1: p1.type = Peace@183ec003
scala> import scala.reflect.runtime.universe.typeOf
import scala.reflect.runtime.universe.typeOf
scala> typeOf[p1.type]
res3: reflect.runtime.universe.Type = p1.type
scala> type1.toString
res4: String = Peace@183ec003
scala> p1.toString
res5: String = Peace@183ec003
//從上可知類型和引用指向同一個對象

2、單例類型：單例類型是單例對象的類型：如object Title ;Title.type就是單例類型，可以作為函數的參數等。。
3、類型別名：可以使用type關鍵字創建一個復雜類型的簡單別名，例如：

class Book{
    import scala.collection.mutable._
    type Index=HashMap[String,(Int,Int)]
    //這樣就可以用Book.Index來代替HashMap[String,(Int,Int)]類型。
}

4、結構類型：是指一組關于抽象方法、字段和類型的規格說明。例如

def appendLines(target: {def append(str:Sring)：Any}),lines:Iterable[String]){}
//其中target就是結構類型參數，傳入的target必選滿足具備append方法即可。

5、復合類型：T with R with X…但是需要T，R，X具有交集。中置類型：是帶有連個類型參數的類型，如Map[String,Int]可以寫成 String Map Int。存在類型：就是類似于java中南的通配符？。Scala類型如下圖：

6、依賴注入，抽象類型，家族多態，高等類型這里不再累述。
7、type和class的區別：每個對象都有自己不同的type。每個對象都有自己的class，同一類的對象的class相同。

第十八章Actor

1、Scala中有特質Actor類似于java中的并發編程接口Runnable，當我們要實現不同的actor的只需要實現Actor特質 如下：

import scala.actors.Actor
class HiActor extends Actor{
    def act(){
    while(true){
    receive{
         case "Hi" =>println("Hello")   
     }
    }
}
}
//啟動actor
val actor1=new HiActor
actor1.start()

其中act方法類似于java中的run方法。不同于java中的并發，Actor是針對消息進行活動的。其中的receive就是用于接收消息的。
2、發送消息：actor是一個處理異步消息的對象，你可以向某個actor發送消息，actor可以對該消息進行處理也可以向下傳遞給其他actor。發送消息的方式很簡單如:常用樣例類（case class className(參數)）作為消息對象。

//actor對象 ! 發送的消息
actor1 ! "Hi"//消息接收者actor，發送的內容為"Hi"。發送的內容可以為任意對象

第十九章隱式轉換和隱式參數

1、隱式轉換函數就是以implicit關鍵字聲明的帶有單個參數的函數，能將輸入的參數類型轉換為另一種類型如：implicit def int2Fraction(n:Int)=Fraction(n,1)將整數轉換為分數。這樣就在引入該隱式轉換函數后就能夠直接進行如下運算將：val result=3*Fraction(4,5)//將自動調用隱式轉換將3變為分數。
2、引入隱式轉換：1、位于源或目標類型的伴生對象中的隱式函數。2、位于當前作用域可以單個標識符指代的；隱式函數。
3、隱式轉換自動調用的規則：1、當表達式的類型和預期類型不同時。2、當對象訪問一個不存在的成員時。3、當對象調用某個方法，傳入的參數類型不對時。
4、隱式參數：函數或方法可以帶有一個標記為implicit的列表，在調用函數時可以顯示給出參數，如果不給出隱式參數就必須在作用域里有帶有implicit定義的隱式值用于自動傳入這些參數。
5、利用隱式參數進行隱式轉換：主要用于隱式參數來對泛型進行隱式轉換。
6、上下文界定、類型證明不在累述。

“scala基礎知識點有哪些”的內容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業相關的知識可以關注億速云網站，小編將為大家輸出更多高質量的實用文章！