scala基本语法及注意点

时间:2021-12-24 02:20:12

scala有两种变量:

val和var,val相当于Java中的final变量,一旦被赋值就不能修改。var相当于java中的普通变量。
constant为定义常量的关键字

定义函数:
scala基本语法及注意点
如果函数没有返回值,那么返回类型为Unit类似Java的void。
如果最后的返回值类型是显而易见那么函数可以不写返回类型,否则就要写
如果函数体只有一条语句,可以不写大括号

函数文本语法:
scala基本语法及注意点

Nil关键字用来定义空类。

scala方法中的参数是val不能再函数中改变参数的值。

Singleton对象:
单例对象使用 object定义,普通对象使用class定义
当单例对象与某个类共享同一个名称时,他被称作是这个类的伴生对象:companion object。你必须在同一个源文件里定义类和它的伴生对象。类被称为是这个单例对象的伴生类:companion class。类和它的伴生对象可以互相访问其私有成员。object对象在第一次被调用的时候实例化。
object和class可以在内部再定义class。
new关键字不能使用在没有伴生类的伴生对象上,因为伴生对象是单例类,在第一使用的时候就会创建。
new关键字是用来产生类实例的,单例对象只有一个实例就不需要使用new关键字了。
例子:
//互相访问私有变量的例子:
class Myclass{
private var para = 0 //如果使用private[this]修饰,伴生对象就不能访问
def param = para
def param_=(newPara:Int){para=newPara}
}
object Myclass{
val myc = new Myclass
def objpara = myc.para
}

for循环枚举和条件过滤:
枚举:
for ( i <- 1 to 4 )
println ( i )
或:
for ( i <- 1 until 4 )
println ( i )
过滤:
for ( i <- 1 to 100 if i % 2 == 0 )
print ( i + "," )
还可以多个if:
for ( i <- 1 to 100
if i % 2 == 0 ;
if i % 3 == 0
)
print ( i + "," )
还可以,镶嵌枚举:
scala基本语法及注意点
使用大括号的好处是可以省略掉小括号里必须使用的分号。

scala没有提供break或continue语句来退出循环:
scala基本语法及注意点

for - yield语法
for{子句}yield{循环体}

=>这个符号用在scala中定义匿名函数。
例子1:
object Rational {
var increate = ( x :Int)=> x + 1
def main ( args : Array[ String ]){
println ( increate ( 2 ))
}
}
例子2:
val testList = List ( 1 , 2 , 3 , 4 , 5 )
testList . foreach (( x :Int) => println ( x ))
例子3:List的filter方法,用来过滤信息,留下要的:
testList . filter (( x :Int) => x > 3 )
例子4:
val b=(x:Int)=>(y:Int)=>x+y
b(1)(2)
例子5:
val b:(Int,Int)=>Int=(x,y)=>x+y
b(1,2)

占位符语法:
scala的函数中用“_”作为占位符,这个占位符可以用传入的参数代替。
例如我们写一个f函数:
val f = (_:Int) + (_:Int)
println ( f ( 2 , 3 ))
占位符还可以用来设置函数的别名:
val a=f _
这样a和函数f是等效的,f不用传入参数,直接加个占位符就可以了
除了上面的做法,还可以:
val f = (_:Int) + (_:Int)
val b = f ( 1 ,_:Int)
println ( b ( 10 ))


scala可以通过“*”来定义函数的可变参数:
object Rational {
def echo ( args : String *)=
for ( arg <- args ) println ( arg )
def main ( args : Array[ String ]){
echo ( "one" )
echo ( "one" , "two" )
}
}
使用了“*”的函数,不可以把数组当做变量直接传入,因为这样函数会把数组当做一个变量,需要变成如下形式:
object Rational {
def echo ( args : String *) =
for ( arg <- args ) println ( arg )
def main ( args : Array[ String ]){
val arr = Array ( "one" , "two" , "three" )
// echo(arr) 这是错误的
echo ( arr :_*)
}
}
使用“:_*”就是告诉解释器,将数组的中的元素当做一个个参数传入

尾递归函数:指的是递归函数的递归语句在函数的最后一行,这种递归函数的执行速度和使用循环代替递归的速度是一样的,不会有任何额外开销。

scala类中不带参数的方法和属性可以互相重写。

scala中的 trait定义特质类,这个关键字的作用类似于java中的interface,但是在scala中,特质类中除了抽象方法以外,还能有非抽象的方法,这就和java中的interface不同了。类可以通过extends或with关键字来实现特质,如果使用extends就只能继承一个,使用with就能继承多个。

import关键字
scala的import和java的import存在以下区别,在scala中:
1.可以出现在任何地方。
2.可以指的是(单例类或者正统的)对象或包。
3.可以重命名或者隐藏一些被引用的成员。
用例:
//将Rational这个类引入
import cha06.scala.Rational
//将静态方法Element.elem引入
import Element. elem
//将obejctElement的所有方法引入
import Element._
除了上诉方法外,import除了可以出现在编译单元的起始位置之外,还可以出现在任何地方。
例如:
private class LineElement( s : String ) extends Element{
//将Rational这个类引入
import cha06.scala.Rational
val rational = new Rational( 2 , 5 )
//....
}
重命名和隐藏:
//只能访问ArrayBuffer 的concat和newBuilder两个方法,其他方法被隐藏
import scala.collection.mutable.ArrayBuffer.{ concat , newBuilder }
//只能访问ArrayBuffer 的concat和newBuilder两个方法,其他方法被隐藏,并且给concat加了个别名conc,你可以通过conc访问concat
import scala.collection.mutable.ArrayBuffer.{ concat =>conc, newBuilder }
//可以访问除了newBuilder 外的所有成员
import scala.collection.mutable.ArrayBuffer.{ newBuilder =>_,_}

类中的apply方法:
这个方法在scala中比较特殊,类中定义了apply的方法后,调用这个方法不需要显示的写apply。直接写"实例名(参数列表)"的形式就好。
例如:
tuple(1)事实上是调用了tuple.apply(1)
List(1,2,3,4)事实上是调用了List(1,2,3,4)

在类的 主构造器中加入参数的时候,如果没有写val或者var,那么主构造器中的参数默认为private,在类实例化之后不能被外部访问,如果加了val或者var表示参数可以被外部访问,等同于private[this] val。

嵌套类:
import scala.collection.mutable.ArrayBuffer
class Network{
class Member(val name:String){
val contacts = new ArrayBuffer[Member]
}
private val members = new ArrayBuffer[Member]

def join(name:String) = {
val m = new Member(name)
members += m
m
}
}

val chatter = new Nework
val myFace = new Network
注意:
在scala中chatter.Member和myFace.Member是两个不同的类
所以以下语句会报错
var mym = new chatter.Member("yang");
mym = new myFace.Member("face")

scala三引号的作用和python三引号的作用相同

String Interpolation (String 插值器)
1.s插值器:
例1:
  1. val name = "James"
  2. println(s"Hello, $name") // Hello, James
例2:
  1. println(s"1 + 1 = ${1 + 1}")
2.f插值器:
  1. val height = 1.9d
  2. val name = "James"
  3. println(f"$name%s is $height%2.2f meters tall") // James is 1.90 meters tall
3.raw插值器:
  1. scala> raw"a\nb"
  2. res1: String = a\nb
  1. scala> s"a\nb"
  2. res0: String =
  3. a
  4. b


":"结尾的方法是右结合的:
首先我们要知道,scala的语法中"(1).to(10)"是可以写成"1 to 10"的。在通常情况写,这种表达式的写法是从左到右结合的,除了用":"结尾的方法外。用":"结尾的方法属于从右到左结合的。例如:List的"::"方法,在List中"::"的定义如下:
def ::[ B>: A] (x: B): List[ B]
但是我们使用的时候可以这样:
val newList= "a" :: "b" :: List()
自定义例子:
object Log { def >>:(data: String):Log. type= { println(data); Log } }
"Hadoop" >>: "Spark" >>:Log


分号推断的规则
分割语句的精确规则非常有效却出人意料的简单。那就是,除非以下情况的一种成立,否则行尾被认为是一个分号:
1.疑问行由一个不能合法作为语句结尾的字结束,如句点或中缀操作符。
2.下一行开始于不能作为语句开始的字。
3.行结束于括号(...)或方框[...]内部,因为这些符号不可能容纳多个语句。