前言
什么是Scala？
是一种多范式的编程语言，其设计的初衷是要集成面向对象编程和函数式编程的各种特性 。Scala 运行于Java平台（ Java虚拟机 ），并兼容现有的Java程序
为什么要学习Scala
- 优雅
- 静态编译，和Jruby，Groovy比速度会快很多
- Scala语言能力强，一行代码能抵上多行Java代码，开发速度快
- 能快速融合到Hadoop生态圈
基础语法
数据结构
- Byte
- Char
- Short
- Int
- Long
- Float
- Double
- Unit
流程控制
- 条件表达式
- 循环语句
- yield关键字
函数式编程
函数定义
- 函数可以声明在任意的位置，方法只能声明在类中
- 函数名称和方法名称相同，默认情况下会调用函数.如果没有函数，会调用方法
- this.method，是指向的方法
object Scala01_Fun {
def main(args: Array[String]): Unit = {
// TODO 函数 & 方法
// 函数可以声明在任意的位置，方法只能声明在类中
def test(): Unit = {
println("funtion")
}
// 函数名称和方法名称相同，默认情况下会调用函数.如果没有函数，会调用方法
test()
// 函数的本质就是Java中的方法
// Scala源码中，方法就是函数，编译后字节码中，函数就是方法
// 函数编译成方法时，增加了修饰符，private static final
}
def test(): Unit = {
println("method")
}
}
函数至简原则
object Scala06_Fun_NightMare {
def main(args: Array[String]): Unit = {
// TODO 函数式编程 - 噩梦版
// 函数式编程的匿名函数与至简原则
def test(f: (Int, Int) => Int): Unit = {
val i: Int = f(10, 20)
println(i)
}
def sum(x: Int, y: Int): Int = {
x + y
}
def diff(x: Int, y: Int): Int = {
x - y
}
// val i: Int = sum(10, 20)
// println(i)
test(sum)
test(diff)
test((x, y) => x - y)
test(_ + _)
def fun(f:(String) => Unit): Unit = {
f("zhagnsan")
}
fun(
(name: String) => println(name)
)
fun(println(_))
fun(println)
}
}
函数作为参数
def main(args: Array[String]): Unit = {
// TODO 函数作为参数
def fun(i : Int): Int = {
i * 2
}
def fun2(f: Int => Int) = {
f(10)
}
println(fun2(fun))
}
函数作为值
object Scala05_Fun_NightMare {
def main(args: Array[String]): Unit = {
// TODO 函数式编程 - 噩梦版
def test(): Unit = {
}
def test1(age :Int): String = {
age.toString
}
// 将函数对象test赋值给f
// 函数回写的类型称之为函数类型
// val f = test _
// val f: Function0[Unit] = test _
// println(f)
val f:Function1[Int, String] = test1 _
println(f)
println(f(2))
// TODO 函数参数的个数没有限制
// 函数对象的参数最多只有22个
}
}
匿名函数
def main(args: Array[String]): Unit = {
// TODO 函数式编程 - 噩梦版
// 函数式编程的匿名函数与至简原则
def cal(x:Int, f:(Int,Int)=>Int, y:Int){
println(f(x, y))
}
cal(10, _ - _, 30)
cal(10, _ * _, 30)
cal(10, _ + _, 30)
cal(10, _ / _, 30)
}
嵌套函数
// 嵌套函数
def outer() = {
def inner() = {
println("hello")
}
inner _
}
outer()()
控制抽象
闭包
- 闭包的使用是改变函数的声明完成的
object Scala08_Fun_NightMare {
def main(args: Array[String]): Unit = {
// TODO 函数式编程 - 噩梦版
// TODO 闭包
def outer(x: Int)={
def inner(y: Int)= {
x + y
}
inner _
}
println(outer(10)(9))
() => { println("hello world") }
}
}
- 总结
- 内部函数使用了外部的数据，改交数据的生命周期
- 将函数作为对象使用，改变函数本身的生命周期
- 所有匿名函数都有闭包
- 内部函数返回到外部使用也会有闭包
函数柯里化
// TODO 函数柯里化
// def test(a: Int, b: Int): Unit = {
// for (i <- 1 to a) {
// println(i)
// }
// for (i <- 1 to b) {
// println(i)
// }
// }
// 函数参数之前可能没有任何关系，那么如果在传值的时候同时传递，其实就有耦合性，而且增加调用的难度
// 所谓的柯里化，就是为了将函数简化，将无关的参数进行分离，可以设定多个参数列表
// test(10, 5)
def test(a: Int)(b: Int): Unit = {
for (i <- 1 to a) {
println(i)
}
for (i <- 1 to b) {
println(i)
}
}
val intToUnit: Int => Unit = test(10)
intToUnit(5)
递归函数
惰性函数
面向对象编程
- 抽象
- 封装
- 继承
- 多态
- Object单例对象
- 特质
- Super关键字
集合
- Java更关注数据结构，Scala更关心集合本身的功能
- Scala中的绝大多数结合对象都是通apply方法构建出来
- Seq
- Set
- Map
- 数组
- Tuple元组
模式匹配
- match
- 匹配类型
- 匹配元组
- 匹配对象
- 偏函数
异常
- Scala异常没有分类，没有throws关键字
- 与Java像是又不尽相同
隐式转换
- 关键字：implicit
- 隐式转换作用域
泛型
- 协变
- 逆变
