Scala基础编程指南

基础知识

函数定义

函数的定义以def开始。然后是函数名，跟着是括号里带有冒号分隔的参数列表如（id : Int）,最后是返回类型等号。函数的每个参数都必须带有前缀冒号的类型标注，因为scala编译器无法推断函数的参数类型。

//标准函数
def addA(id : Int):Unit={
    var line = id
}
def addA(x : Int) = x +100

//匿名函数
val add = (x : Int) => x +200

//递归函数
def fac(n:Int):Int = if (n <= 0) 1 else n * fac(n - 1)

//函数的默认参数
def combine(content:String, left: String = "[", right: String = "]") = left + content +right
println(combine("I love Scala"))         ---->[I love Scala]
println(combine("I love Scala","<",">")) ----><I love Scala>

//函数的可变参数
def connected(args: Int*) = {
    var result =0
    for(arg <- args) result += arg
    result
}

流程控制

三元表达符

val file = if(!args.isEmpty) args(0) else "scala.txt"

for循环

for (i <- 1 to 10) {
    println()
}

//遍历数组
for(arg <- args)｛｝

do while循环

var line = ""
do {
    line = readLine()
    println("Read: " + line)
} while (line != "")

异常处理

异常处理跟java类似，但是异常捕获是根据case匹配。

try {
    val half = if (n % 2 == 0) n /2 else throw 
    new RuntimeException("N must be event")
//  Use the file 
    }catch {
    case e : Exception => println("The exception is :" + e.getMessage())
    }finally{
//  close(file)
    }

元组

元组的index是从1开始的。

    val tuple =(1,2,3.14,"Rocky","Spark")

    //tuple里取第三个值
    val third = tuple._3

    //tuple里取值参数名对应的值
    val (first,second,thirda,fourth,fifth) = tuple

    //tuple里取前两个值，参数名为f1,s2
    val (f1, s2, _, _, _) = tuple

数组

数组的index是还是从0开始的。

    //创建数组
    val array = Array(1,2,3,4,5)
    val a = new Array[String](10)
    val s = Array("Hello", "World")
    s(0)

    //可变长数组
    val b = ArrayBuffer[Int]()
    b += 1                    //增加 1的元素到数组
    b += (1, 2, 3, 5)
    b ++= Array(8, 13, 21)
    b.trimEnd(5)              //删除后5位
    b.insert(2, 6)            //index,elem
    b.insert(2, 7, 8, 9)
    b.remove(2)               //删除第2位
    b.remove(2, 3)            //index,elem个数
    b.toArray                 //转换array

    //带条件的Array处理
    val c = Array(2, 3, 5, 7, 11)
    for (elem <- c if elem % 2 == 0) yield 2 * elem
    c.filter(_ % 2 == 0).map(2 * _)

    //sum,max,sort等Array处理
    var sum = Array(1, 4, 2, 3).sum            //10
    ArrayBuffer("Mary", "little", "lamb").max  //输出最长数组
    var s = Array(1, 4, 2, 3)
    val c = s.sorted                           //(1,2,3,4)
    scala.util.Sorting.quickSort(s)
    s                                          //(1,2,3,4)

    //多维数组
    val matrix = Array.ofDim[Double](3, 4) 
    matrix(2)(1) = 42

Map

    val ages = Map("Rocky" -> 27, "Spark" -> 5) 
    for((k,_) <- ages){ //_ 占位符
        println("Key is " + k)
    }

    //遍历并改变所有值
    val map = Map("book"->10,"gun"->18,"ipad"->1000)  
    for((k,v) <- map) yield (k,v * 0.9)

    //取Hadoop值没有返回0
    val hadoopScore = scores.getOrElse("Hadoop", 0)

    //Map的增删
    map += ("R" -> 9)
    map -= "book"

    //排序-只能对不可变数组排序
    scala.collection.immutable.SortedMap（immutable map）

Zip

    //symbols合并counts
    val symbols = Array("[", "-", "]")
    val counts = Array(2,5,2)
    val pairs = symbols.zip(counts)
    //Array[(String, Int)] = Array(([,2), (-,5), (],2))
    for ((x,y) <- pairs) print(x*y)

类的定义

对象

class Person {

    //通过scala内置的get/set方法调用
    var age = 0

    //通过get/set方法调用
    private var name = "none"

    //对象私有字段，仅限于对象内直接调用
    private [this] var id= 1

    //懒加载-调用才会去加载
    lazy val file = Source.fromFile("E://Scala.txt")

    //get方法
    def getAge = age

}

伴生对象

没有伴生类的Object叫做单例对象

class University{
    val id = University.newStudenNo
    private var number =0
    def aClass(number:Int){this.number += number}
}

//University类的伴生对象，主要放一些静态对象
object University{
    private var studentNo = 0
    def newStudenNo = {
        studentNo += 1
        studentNo
    }
}

构造函数

//Class（）主构造器会自动创建name和age对象
class Teacher (val name : String, val age : Int){

//私有构造器
class Teacher private (val name : String, val age : Int){
    println("This is the primary constructor!!!")
    var gender : String = _
    println(gender)

    //辅助构造器
    def this(name : String, age : Int, gender : String){
        this(name, age)
        this.gender = gender
    }
}

内部类

在scala里内部类是以对象的形式存在的

class Outer(val name : String){outer=>
    class Inner(val name : String){
        def foo(b:Inner) = println
        ("Outer: " + outer.name + " Inner: " + b.name)
    ｝
｝
    val outer1 = new Outer("Spark")
    val outer2 = new Outer("Hadoop")
    val inner1 = new outer1.Inner("Scala")
    val inner2 = new outer2.Inner("Java")
    inner1.foo(inner1)
    inner2.foo(inner2)

Apply方法

调用Class和Object的apply方法

class ApplyTest{
    def apply() = println("I am into Spark so much!!!")

    def haveATry{
        println("Have a try on apply!")
    }
}
object ApplyTest{
    def apply() = {
        println("I am into Scala so much!!!")
        new ApplyTest
    }
}

//调用类的apply方法
val clas = new ApplyTest
clas()

//调用object的apply方法
val obj = ApplyTest()

继承

Scala中类的继承一定要继承父类的主构造器

class Person(namg : String, age : Int){
    println("The primary constructor of Person")
}

class Worker(name : String, age : Int, val salary : Long) extends Person(name, age){
    println("This is the subClass of Person, Primary constructor of Worker")
}

方法重写

  override val school = "Spark"

  override def toString = "I am a Worker!" + super.sleep

抽象类

abstract class SuperTeacher(val name : String){}

class TeacherForMaths(name : String) extends SuperTeacher(name){}

接口

注意接口是extends去继承的，且可以有抽象方法，还可以继承至类。多重继承不会多重构造类。

class A{}

trait interface extend class A{
    def function(msg : String)
}

//多重继承       构造顺序---->>
class B extends interface with interface2 with ...{
    override def function(msg : String)
}

AOP

trait Action{
    def doAction
}

trait TBeforeAfter extends Action{
    abstract override def doAction{
        println{"Initialization"}
        super.doAction
        println("Destroyed")
    }
}

class Work extends Action{
    override def doAction = println("Working...")
}

val test = new Work with TBeforeAfter
test.doAction                           //Initialization
                                        //Working...
                                        //Destroyed