scala有两种变量：
val和var，val相当于Java中的final变量，一旦被赋值就不能修改。var相当于java中的普通变量。
constant为定义常量的关键字
定义函数：
函数文本语法：
scala方法中的参数是val不能再函数中改变参数的值。
Singleton对象：
for循环枚举和条件过滤：
scala没有提供break或continue语句来退出循环：
for - yield语法
=>这个符号用在scala中定义匿名函数。
scala可以通过“*”来定义函数的可变参数：
scala类中不带参数的方法和属性可以互相重写。
import关键字，
定义函数：
如果函数没有返回值，那么返回类型为Unit类似Java的void。
如果最后的返回值类型是显而易见那么函数可以不写返回类型，否则就要写
如果函数体只有一条语句，可以不写大括号
函数文本语法：
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
}
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没有提供break或continue语句来退出循环：
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)
占位符语法：
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
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");
在scala中chatter.Member和myFace.Member是两个不同的类
所以以下语句会报错
var mym = new chatter.Member("yang");
mym = new myFace.Member("face")
scala三引号的作用和python三引号的作用相同
String Interpolation （String 插值器）
1.s插值器：
例1：
val name = "James"println(s"Hello, $name") // Hello, James
例2：
println(s"1 + 1 = ${1 + 1}")
2.f插值器：
val height = 1.9dval name = "James"println(f"$name%s is $height%2.2f meters tall") // James is 1.90 meters tall
3.raw插值器：
scala> raw"a\nb"res1: String = a\nb
scala> s"a\nb"res0: String =ab
":"结尾的方法是右结合的：
首先我们要知道，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
"Hadoop" >>: "Spark" >>:Log
分号推断的规则
分割语句的精确规则非常有效却出人意料的简单。那就是，除非以下情况的一种成立，否则行尾被认为是一个分号：
1．疑问行由一个不能合法作为语句结尾的字结束，如句点或中缀操作符。
2．下一行开始于不能作为语句开始的字。
3．行结束于括号(...)或方框[...]内部，因为这些符号不可能容纳多个语句。
分割语句的精确规则非常有效却出人意料的简单。那就是，除非以下情况的一种成立，否则行尾被认为是一个分号：
1．疑问行由一个不能合法作为语句结尾的字结束，如句点或中缀操作符。
2．下一行开始于不能作为语句开始的字。
3．行结束于括号(...)或方框[...]内部，因为这些符号不可能容纳多个语句。