scala操作符和關鍵字

2019-11-11 04:32:14

字體：大中小

來源：轉載

供稿：網友

http://blog.csdn.net/yhb315279058/article/details/50242247

一元操作符：

后置一元操作符：后置一元操作符就相當于普通的無參方法。

前置一元操作符：前置操作符被默認轉成對名為 unary_操作符 的方法調用，例如：-a和a.unary_-一樣

賦值操作符：定義形如：操作符= 的操作符例如：a 操作符= b等價于：a=a 操作符 b注意：<=,>=和!=不是賦值操作符以=開頭的操作符不是賦值操作符

在scala中，所有的操作符都是左操作符，除了：以冒號(:)結尾的操作符賦值操作符

apply和updata方法：調用f(arg1,arg2,...)事實上是調用f.apply(arg1,arg2,...)調用f(arg1,arg2,...)=value事實上是調用f.update(arg1,arg2,...,value)

unapply和unapplySeq方法也叫做提取器例如：var Fraction(a,b)=Fraction(2,3)如果Fraction是定義了unapply方法的，那么就有a=2，b=3的結果。至于返回什么由用戶自己定義。unappluSeq和unapply差不多，unappluSeq可以定義任意返回長度。

“++”操作符，用來連接兩個數組。

yield語法，和python中的差不多：yield語法會產生一個生成器，在scala中也可以當做一個Array的形式。

type關鍵字：type可以用來重命名類型，例如 Type MyString = String，在以下的就可以把MyString當做String來使用。

lazy關鍵字：使用lazy關鍵詞定義的變量會在第一次訪問的時候初始化。lazy val、val、def的不同：lazy val：在第一次調用的時候執行，執行后保存下來。val：在定義的時候執行。def：每次調用都會重新執行。在多步驟，多次迭代的代碼中，使用lazy能夠保存下更多的步驟，這樣就有更大的優化空間

implicit關鍵字：這是隱式轉化的關鍵字，是scala中的一大特色：

隱式轉換：例子：class RichFile(val file:File){def read = Source.fromFile(file.getPath()).mkString}object Context{implicit def file2RichFile(file:File)= new RichFile(file) //File -> RichFile}object Hello_Implicit_Conversions {def main(args: Array[String]) {import Context.file2RichFilePRintln(new File("E://WangJialin.txt").read) }}黃底部分用了隱式轉換

隱式參數：隱式參數的作用其中一個就是提供默認值，例如：object Context_Implicits{implicit val default:String = "Flink"}object Param{def print(content:String)(implicit language:String){println(language+":"+content)}}object Implicit_Parameters {def main(args: Array[String]) {Param.print("Spark")("Scala")import Context_Implicits._Param.print("Hadoop")}}

隱式類：代碼示例：object Context_Helper{ implicit class FileEnhancer(file : File){ def read = Source.fromFile(file.getPath).mkString }implicit class Op(x:Int){def addSAP(second: Int) = x + second}}object Implicits_Class {def main(args: Array[String]){import Context_Helper._println(1.addSAP(2))println(new File("E://WangJialin.txt").read) }}隱式類直接用來增強類的功能。

隱式對象：abstract class Template[T] {def add(x: T, y: T): T}abstract class SubTemplate[T] extends Template[T] {def unit: T}object Implicits_Object {def main(args: Array[String]) {implicit object StringAdd extends SubTemplate[String] {override def add(x: String, y: String) = x concat yoverride def unit: String = ""}implicit object IntAdd extends SubTemplate[Int] {override def add(x: Int, y: Int) = x + yoverride def unit: Int = 0}def sum[T](xs: List[T])(implicit m: SubTemplate[T]): T =if (xs.isEmpty) m.unitelse m.add(xs.head, sum(xs.tail))println(sum(List(1, 2, 3, 4, 5)))println(sum(List("Scala", "Spark", "Kafka")))}}這個的用途還不是特別了解

override關鍵字:轉自: http://my.oschina.net/aiguozhe/blog/39934

在Scala中，

1) 可以用override val 覆蓋父類或特質中不帶參數的def ，但反過來不行，比如

class Father{def name = "Archer"def score() = 1.0val id = 12}class Children extends Father{override val name = "Jack"override val score = 2.0override def id = 10 // error: error overriding value id in class Father of type Int; method id is not stable}

個人認為這條規則可以這么記憶，因為def表示一個函數，函數返回值都有一個確定的范圍，比如上面的name函數，它的返回值范圍是全體的字符串，由于val 表示一個常量，值的范圍已經卻確定，因此如果子類要覆蓋父類的同名成員，其值的范圍不能更寬泛，否則就破壞了里氏代換原則。顯然, def 所蘊含的范圍要比 val 廣（注：這段話是我瞎說，只是方便記憶）

2. 子類的def 可以 override 父類的def，比如

class Father{def name = "Archer"def say() = "go to bed"def moveTo(x: Int, y: Int) = println("move to ("+x+","+y);}class Children extends Father{override def name() = "Jack"override def say() = "I'm not tired"override moveTo(x: Int, y: Int) = super.moveTo(x,y)}

3. 子類的var要override 父類的def 成員，不過def 必須成對出現；但反過來不行

class Father{def credit = "abc"def credit_=(s: String) = (println("s"))}class Children extends Father{override var credit = "fff" // var can override a dual def}