函数的定义以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
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)
//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)
调用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) }
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