Scala语言笔记 - 第一篇
最近研究了下scala语言，这个语言最强大的就是它强大的函数式编程（Function Programming）能力，记录下最近学习的一些新的和技巧。注意：本系列博客不会从头讲解该语言的语法，而是通过一些例子讲解该语言的一些技巧，如果需要从头学习scala，建议使用该教程快速入门。
1 基本类型和循环的使用
看如下代码：
def main(args: Array[String]): Unit = {
//声明类型，不写类型的话，scala会根据具体的值进行类型推断，如果不写类型，则必须进行初始化
var sum:Int = 0
/*
* var: 可以进行重新赋值，但是需要注意的是：scala是静态语言，因此不能赋值为其他类型的
* val: 不可变类型，类似于Java的final
*/
var str = "hello world"
//str = 1 //这样是不可以的，str已经是String类型，不可以再被赋值为Int
//普通的函数调用
val res = func(str)
//包含5
for (num <- 1 to 5) {
print("num:" + num + " ")
}
println("")
//不包含5，这个<-不好打，不知道怎么想的o(*￣︶￣*)o
for (num <- 1 until 5) {
print("num:" + num + " ")
}
println("Result" + res)
}
/**
* Scala的函数定义，类型在后面，冒号后面的是返回值，{}的为函数体
* 如果函数体只有一两行，那么可以不写大括号
* @param str
* @return
*/
def func(str: String): String = {
println("This is your str:" + str)
//类似于Ruby，最后一行默认为返回值
"my String"
}
2 String相关
scala和Java类型，String类型是可以变类型，因此，构建String的时候，最好使用StringBuilder来进行拼接。
//因为string是不可变的，因此，可使用StringBuilder来处理该情况
def strTest(): Unit = {
var str = "hello world"
var str1:String = " this is scala"
println("str + str1:" + (str + str1))
//使用StringBuilder进行字符串的拼接
var sb = new StringBuilder
//在scala中，++=其实是一个函数，这里是在进行函数调用
sb ++= "hello"
sb ++= "world"
// += 是char
sb += 'd'
println("sb:" + sb.toString)
/*
* mkString是一个很好用的方法，三个参数分别为：head middle footer，因此这段代码最终生成的结果为:
* /**
* this is a comment
* another line
*/
* 一段标准的多行注释
*/
str = "
this is a comment
another line"
var res = str.split("(
)|
|
").mkString("/**", "
* ", "
*/")
println(res)
}
3 模式匹配相关
scala中最大的一个特点就是其强大的模式匹配功能，我们看下面的一段代码：
//模式匹配
def matchTest(): Unit ={
println(matchTestInternal(1))
println(matchTestInternal("hello"))
println(matchTestInternal(2L))
}
//匹配到任何一个，就直接返回，不会再去匹配其他的，和switch不一样
//Any表示可以匹配任意类型
def matchTestInternal(x: Any) : Any = {
x match {
case 1 => "one"
case str:String => "String"
case integer:Int => "Integer"
//other. similiar to default，在scala中_的用途非常多
case _ => "Other"
}
}
4 class相关
scala中的class可以定义在任何地方，没有Java文件名和类名必须保持一致的限制，且，在scala中，构造方法也和Java有很大的区别。
//scala定义class的方式有些不同，定义带参数的类时，参数是写在类里面的
def classTest(): Unit ={
//在scala中，构造方法的参数是直接放在类名后面
class HelloClass(val _name:String, val _age:Int){
private var name = _name
private var age = _age
def getAge(): Int ={
return age
}
//覆写非抽象方法，必须要有override
override def toString: String = {
"name:" + name + " age:" + age
}
}
//定义子类的时候，如果要覆盖父类中的变量，那么也需要写上override
class HelloChildClass(override val _name:String, override val _age:Int) extends HelloClass(_name, _age)
{
private var name = _name
private var age = _age
override def toString: String = {
"Child class's toString[" + "name:" + name + " age:" + age + "]"
}
}
//对刚才定义好的类进行调用
val name = "name"
val age = 10
var child = new HelloChildClass(name, age)
child.getAge()
println(child.toString)
var child2:HelloClass = new HelloChildClass(name, age)
child2.getAge()
println(child2.toString)
}
5 函数调用相关
因为scala对于函数式编程的天然支持，所以该语言中会出现大量的函数传值，并且还支持很多简略的写法，比如调用简单函数时可以不写()，比如支持函数的柯里化(Currying)
def funcTest(): Unit = {
//函数可以作为参数进行传递，但是方法不行，并且函数必须要有参数列表
//定义一个函数
var x = 10
var y = 20
//传入函数
funcWithFunc(myBody)
//调用mybody2，把二元参数调用转换为一元参数调用，这种做法叫做函数的柯里化（Currying），是一个数学里面的概念
myBody2(1)(2)
//定义一个短小精悍的func
var f1 = (x:Int, y:Int) => x * y
//直接传给function
funcWithFunc(f1)
//函数传名调用和传值调用，传值调用：直接计算函数的值，然后传给另外一个函数，传名调用：在函数内部进行调用
acceptTime(time())
println("-----------------------")
acceptTime2(time())
println("-----------call aVerySumpleFunc---------------")
//这里调用的时候，可以不用写()，自动进行调用
println(aVerySimpleFunc.length)
println("----------------------------------------------")
println("-------------call funcWithFuncPara------------")
//表示调用funcWithFuncPara函数，这个函数接受一个返回Int类型的函数作为参数，参数函数不需要传入任何参数，
//因此，在scala中，可以采用大括号的方式快速创建一个没有任何参数的函数
funcWithFuncPara {
println("This is func para!")
100
}
println("----------------------------------------------")
}
//该函数的参数为一个只返回Int类型的函数，调用这种函数的时候，可以采用大括号进行非常精简的调用
def funcWithFuncPara(f : => Int) : Unit = {
println("This is a function with a simple function parameter")
f
}
//一个非常简单的function，当调用这种func的时候，可以不用写()
def aVerySimpleFunc() = "String"
def myBody(x:Int, y:Int) : Int = {
var sum = x + y
println("x + y = " + sum)
sum
}
//注意，也可以采用这种写法，两个连着的括号表示两个参数的传递，也可以使用myBody那种传统的写法
def myBody2(x:Int)(y:Int) : Int={
println("--------------------myBody2---------------------------")
println(s"x=$x y=$y")
println("--------------------end---------------------------")
0
}
//可以接受函数作为参数的函数
def funcWithFunc(body : (Int, Int) => Int): Int =
{
body(10,20)
}
def time() : Long ={
println("Now, Get the nano time.")
System.nanoTime()
}
// => 表示是一个传名调用，其实本质上就是接受一个函数为参数
def acceptTime(body : => Long): Unit = {
println("acceptTime() enter...")
println("Now, will call the body")
//这里的body表示直接进行调用的意思
println("body get time:" + body)
}
// 表示是一个普通调用，传值调用
def acceptTime2(body : Long) : Unit = {
println("acceptTime2() enter...")
println("Now, will call the body")
println("body get time:" + body)
}