继承

定义一个抽象类，需要使用关键字abstract

定义一个抽象类得抽象方法，不需要关键字，只要把方法体空着

抽象类中定义得字段，没有给初始值得就是抽象字段，但必须声明类型。

abstract class Car{ //是抽象类，不能直接被实例化
val carBrand:String //字段没有初始值，就是一个抽象得字段
  def info() //抽象方法，不需要使用abstract关键字
  def greeting()=println("welcome to my car!")
}

 abstract class person{
    var name:String
    val age:Int
    def show:Int
  }

class BMWcar extends Car{
    override val carBrand = "BMW" //重写超类字段，需要使用override关键字，否则编译会出错
    def info():Unit = println("This is a %s car.It is on sale",carBrand) //重写超类得抽象方法时，不需要使用override关键字，不过如果加上override编译也不错报错
    override def greeting():Unit =println("Welcome to my BMW car!") //重写超类的非抽象方法，必须使用override关键字
}
class BYDCar extends Car { 
    override val carBrand = "BYD" //重写超类字段，需要使用override关键字，否则编译会报错
    def info():Unit = printf("This is a %s car. It is cheap.", carBrand)} //重写超类的抽象方法时，不需要使用override关键字，不过，如果加上override编译也不错报错
    override def greeting():Unit = println("Welcome to my BYD car!") //重写超类的非抽象方法，必须使用override关键字
}

函数

//定义无输入值的函数
def hi = "hi" 
def hi:String = "hi"

def multiplier(x:Int, y:Int):Int = {x*y}

def safeTrim(s:String):String = {
    if (s == null) return null
    s.trim()
} //来判断输入值是否是非null

过程

没有返回值的函数，以一个语句结尾的函数也是一个过程。如果一个函数，没用显式的返回类型，而且最后是一个语句，scala编译器就会推导出这个函数的返回类型为Unit，表示没用值，对于超过一行的过程，可以显示指定类型Unit。

def log(d:Double) = println(f"Got value $d%.2f") //隐式的返回类型

def log(d:Double) : Unit = println(f"Got value $d%.2f") //显式的返回类型

def log(d:Double) {println(f"Got value $d%.2f")} //这种写法已经废弃了，会报警告

用空括号定义函数

定义和调用一个无输入的函数。

def hi():String = "hi"
hi()
hi

反之，在定义时没用加（）。scala就不允许在调用时增加（）。

使用函数表达式调用函数

def formatEuro(amt:Double) = f"$amt%.2f"
formatEuro(3.4645)
formatEuro {val rate = 1.32;0.235+0.7123+rate*5.32}

递归函数

调用自身的函数，可能要检查某类参数或外部条件来避免调用陷入无限循环

def power(x:Int, n:Int):Long = {
    if (n>=1) x * power(x,n-1)
    else 1
}

//添加尾递归优化
@annotation.tailrec
def power(x:Int, n:Int):Long = {
    if (n>=1) x * power(x,n-1)
    else 1
} //报错
//因为递归调用不是函数的最后一个语句
@annotation.tailrec
def power(x:Int, n:Int):Long = {
    if (n < 1) 1
    else x * power(x,n-1)
} 
/*
现在递归调用的确是函数的最后一项，不过实际上，我们是得到递归调用的结果，然后乘法，所以乘法才是最后一个语句。
*/
@annotation.tailrec
def power(x:Int, n:Int, t:Int = 1):Int = {
    if (n < 1) t
    else power(x,n-1,x*t)
} 

嵌套函数

def max(a:Int, b:Int, c:Int) = {
    def max(x:Int, y:Int) = if (x>y) x else y
    max(a,max(b,c))
}
//max(Int,Int)嵌套函数在外部函数中使用了两次，局部（嵌套）函数优先于外部函数

用命名参数调用函数

按名调用参数

def greet(prefix:String,name:String) = s"$prefix $name"
val greeting1 = greet("Ms","Brown")

有默认值得参数

def greet(prefix:String="",name:String) = s"$prefix $name"  //指定了prefix
val greeting1 = greet(name = "Brown")

Vararg参数

定义输入参个数可变得函数。要标志一个参数匹配一个或多个输入实参，在函数定义中需要改参数类型后面增加一个星号（*）

def sum(items:Int*):Int = {
    var total = 0
    for (i <- items) total += i
    total
}
sum(10,20,30)
sum()

参数组

每个参数组用小括号分隔

def max(x:Int)(y:Int) = if (x>y) x else y
val larger = max(20)(39)

类型参数

def identity(s:String):String = s
def identity(i:Int):Int = i
//如果对想要使用得每一个类型都重新定义函数，就太费劲了。
def identity(a:Any):Any = a
val s:String = identity("Hello") //报错
//使用类型参数定义
def identity[A](a:A):A = a
val s:String = identity[String]("Hello")
val d:Double = identity[Double](2.717)
//类型推导
val s:String = identity("Hello")
val d:Double = identity(2.717)
//
val s = identity("Hello")
val d = identity(2.717)

方法和操作符

方法是类中定义的一个函数，这个类的所有实例都会有这个方法。

val s = "vacation.jpg"
val isJPEG = s.endWith(".jpg")
//s是String的一个实例，String类有一个endWith方法。可以用类名调用也可以用实例名

val d = 65.642
d.round
d.floor
d.compare(18.0)//小于、等于、大于d的值，返回1，0，-1
d.+(2.721)
//操作符
d compare 18.0
d + 2.721

生成API文档的代码

//为函数增加Scaladoc首部
/**
 *
 *
 */
def safeTrim(s:String):String = {
    if (s == null) return null
    s.trim()
}