Scala——函数式编程

5 函数式编程
- 5.1 函数基础
- 5.2 函数高级
- - 5.2.1 匿名函数
  - 5.2.2 高阶函数
  - 5.2.3 高阶函数练习
  - 5.2.4 函数柯里化&闭包
  - 5.2.4 递归
  - 5.2.5 控制抽象
  - 5.2.6 惰性加载
6 面向对象
- 6.1 Scala包
- - 6.1.1 包的命名
  - 6.1.2 包说明（包语句）
  - 6.1.3 包对象
  - 6.1.4 包导入
- 6.2 类和对象
- - 6.2.1 定义类
  - 6.2.2 属性
- 6.3 封装
- 6.4 继承和多态
- 6.5 抽象类
- 6.6 单例对象（伴生对象）
- 6.7 特质（Trait）
- 6.8 扩展

5 函数式编程

面向对象程序

解决问题，分解对象，行为，属性，然后通过对象的关系以及行为的调用来解决问题。

Scala 语言是一个完全面向对象编程语言。万物皆对象
对象的本质：对数据和行为的一个封装

函数式编程

解决问题时，将问题分解成一个一个的步骤，将每个步骤进行封装（函数），通过调用这些封装好的步骤，解决问题。

Scala 语言是一个完全函数式编程语言。万物皆函数。
函数的本质：函数可以当做一个值进行传递

5.1 函数基础

函数基本语法

package com.yu.chapter05object TestFunction {def main(args: Array[String]): Unit = {def f(arg: String): Unit = {println(arg)}f("Hello world")}
}

函数和方法的区别

（1）为完成某一功能的程序语句的集合，称为函数。
（2）类中的函数称之方法。
（3）函数没有重载和重写的概念；方法可以进行重载和重写

package com.yu.chapter05object FunctionAndMethod {def main(args: Array[String]): Unit = {//定义函数，不可重载和重写def sayHi(name: String): Unit = {println("hi " + name)}//调用函数:上面的sayHi可见就会优先调用上面的函数，若不可见会调用下面的sayHi方法sayHi("Alice")//hi Alice//指定调用对象方法FunctionAndMethod.sayHi("Bob")//Hi,Bob//获取方法返回值val result = FunctionAndMethod.sayHello("Marry")print(result)//Hi, Marry//Marry}//定义方法，可以重载和重写def sayHi(name: String): Unit = {println("Hi," + name)}def sayHello(name: String): String = {println("Hi, " + name)return name}
}

函数定义

（1）函数 1：无参，无返回值
（2）函数 2：无参，有返回值
（3）函数 3：有参，无返回值
（4）函数 4：有参，有返回值
（5）函数 5：多参，无返回值
（6）函数 6：多参，有返回值

package com.yu.chapter05object FunctionDeclare {def main(args: Array[String]): Unit = {//函数1：无参，无返回值def test1(): Unit = {println("1.无参，无返回值")}test1()println(test1())//1.无参，无返回值//1.无参，无返回值//()     打印的返回值，Unit对应()//函数2：无参，有返回值def test2(): Int = {println("2.无参，有返回值")return 1}println(test2())//2.无参，有返回值//1//函数3：有参，无返回值def test3(s:String): Unit = {println(s)}test3("hello") //hello//函数4：有参，有返回值def test4(s:String): String = {return s + "有返回值"}println(test4("hello")) //hello有返回值//函数5：多参，无返回值def test5(name:String, age:Int): Unit = {println(s"$name, $age")}test5("Alice", 8) //Alice, 8}
}

函数参数

（1）可变参数
（2）如果参数列表中存在多个参数，那么可变参数一般放置在最后
（3）参数默认值，一般将有默认值的参数放置在参数列表的后面
（4）带名参数

package com.yu.chapter05object FunctionParameter {def main(args: Array[String]): Unit = {//(1)可变参数def test(s: String*) : Unit = {println(s)}//这里的String*类似一个集合类型 可以同时传入多个test("Hello", "scala") //ArraySeq(Hello, scala)test()                 //List()//(2)如果参数列表中存在多个参数，那么可变参数一般放置在最后def test2(name:String, s:String*): Unit = {println(name + "," +s)}test2("rain")                   //rain,List()test2("rain", "snow", "cloud")  //rain,ArraySeq(snow, cloud)//(3)参数默认值def test3(name:String, age:Int=30): Unit = {println(s"$name, $age")}test3("rain", 9)  //rain, 9  指定的test3("rain")   //可省略  //rain, 30 默认的//(4)带名参数def test4(name:String, age:Int): Unit = {println(s"$name, $age")}test4(age=10, name="snow") //snow, 10 不用按顺序，可以指定}
}

函数至简原则

（1）return 可以省略，Scala 会使用函数体的最后一行代码作为返回值
（2）如果函数体只有一行代码，可以省略花括号
（3）返回值类型如果能够推断出来，那么可以省略（:和返回值类型一起省略）
（4）如果有 return，则不能省略返回值类型，必须指定
（5）如果函数明确声明 unit，那么即使函数体中使用 return 关键字也不起作用
（6）Scala 如果期望是无返回值类型，可以省略等号
（7）如果函数无参，但是声明了参数列表，那么调用时，小括号，可加可不加
（8）如果函数没有参数列表，那么小括号可以省略，调用时小括号必须省略
（9）如果不关心名称，只关心逻辑处理，那么函数名（def）可以省略

package com.yu.chapter05object Function_SImplify {def main(args: Array[String]): Unit = {//    （1）return 可以省略，Scala 会使用函数体的最后一行代码作为返回值def f1(s: String): String = {s + "bow"}println(f1("rain")) //rainbow//    （2）如果函数体只有一行代码，可以省略花括号def f2(s: String): String = s + "bow"println(f2("rain")) //rainbow//    （3）返回值类型如果能够推断出来，那么可以省略（:和返回值类型一起省略）def f3(s: String) = sprintln(f3("rain")) //rain//    （4）如果有 return，则不能省略返回值类型，必须指定def f4(s: String): String = {return s}println(f4("rainbow")) //rainbow//    （5）如果函数明确声明 unit，那么即使函数体中使用 return 关键字也不起作用def f5(): Unit = {return "rainbow"}println(f5()) //()//    （6）Scala 如果期望是无返回值类型，可以省略等号def f6() {"rainbow"}println(f6()) //()//    （7）如果函数无参，但是声明了参数列表，那么调用时，小括号，可加可不加def f7(): Unit = {println("rain")}f7 //rain//    （8）如果函数没有参数列表，那么小括号可以省略，调用时小括号必须省略def f8: Unit = {println("rainbow")}f8 //rainbow//    （9）如果不关心名称，只关心逻辑处理，那么函数名（def）可以省略//匿名函数def f9(name:String): Unit = {println(name)}(name: String) => {println(name)}}
}

5.2 函数高级

5.2.1 匿名函数

（1）说明
没有名字的函数就是匿名函数。
(x:Int) => {函数体}
（2）传递匿名函数至简原则：
a. 参数的类型可以省略，会根据形参进行自动的推导
b. 类型省略之后，发现只有一个参数，则圆括号可以省略；其他情况：没有参数和参数超过 1 的永远不能省略圆括号。
c. 匿名函数如果只有一行，则大括号也可以省略
d. 如果参数只出现一次，则参数省略且后面参数可以用_代替

package com.yu.chapter05object test_lambda {def main(args: Array[String]): Unit = {val fun = (name: String) => {println(name)}fun("rain") //raindef f(func: String => Unit): Unit = {func("rainbow")}f(fun)   //rainbow//参数的类型可以省略，会根据形参进行自动的推导f((name) =>{println(name)})//类型省略之后，发现只有一个参数，则圆括号可以省略；其他情况：没有参数和参数超过 1 的永远不能省略圆括号f(name => {println(name)})//匿名函数如果只有一行，则大括号也可以省略f(name => println(name))//如果参数只出现一次，则参数省略且后面参数可以用_代替f( println(_) )//如果可以推断出，当前传入的println是一个函数体，而不是调用语句，可以直接省略下划线f( println )//示例：定义一个二元运算函数def dualFunction(fun: (Int, Int) => Int): Int = {fun(1, 2)}val add = (a: Int, b: Int) => a + bval minus = (a: Int, b: Int) => a-bprintln(dualFunction(add))   //3println(dualFunction(minus)) //-1//简化println(dualFunction((a, b) => a + b))  println(dualFunction((_ - _)))println(dualFunction((a, b) => b - a))println(dualFunction(-_ + _))}
}

5.2.2 高阶函数

（1）函数可以作为值进行传递
（2）函数可以作为参数进行传递
（3）函数可以作为函数返回值返回

package com.yu.chapter05object Function_HighOrder {def main(args: Array[String]): Unit = {def f(n: Int): Int = {println("调用")n + 1}def fun(): Int = {println("调用")1}fun()funval result: Int = f(123)  //123println(result)      //124println("=========================")//1. 函数作为值进行传递//在被调用函数 foo 后面加上 _，相当于把函数 foo 当成一个整体，传递给变量 f1val f2 = f _//如果明确变量类型，那么不使用下划线也可以将函数作为整体传递给变量val f1: Int => Int = f   //传递的是整个函数println(f1)  //com.yu.chapter05.Function_HighOrder$$$Lambda$3/1690716179@483bf400println(f1(12))  //f2同//调用//13val f3_1 = fun   //不是完整的传递函数val f3:() => Int = fun  //需要明确指定是函数形式,不能省略val f4 = fun _println(f3_1)println(f3)println(f4)//调用//1//com.yu.chapter05.Function_HighOrder$$$Lambda$5/128526626@2cfb4a64// com.yu.chapter05.Function_HighOrder$$$Lambda$6/1911728085@5474c6c//2. 函数作为参数传递//定义二元运算函数def dualEval(op: (Int, Int) => Int, a: Int, b: Int): Int = {op(a, b)}def add(a:Int, b:Int): Int = {a + b}println(dualEval(add, 12, 13))   //25println(dualEval((a, b) => a+b, 12, 13)) //25println(dualEval(_ + _, 12, 13))         //25//3. 函数作为函数返回值返回def f5(): Int => Unit = {def f6(a: Int): Unit = {println("f6调用" + a)}f6   //这里返回的是f6函数，需要指定f5是Int=>Unit(指定函数类型)，或者返回f6 _}//直接返回函数println(f5())   //com.yu.chapter05.Function_HighOrder$$$Lambda$10/1207769059@7cdbc5d3//因为f7可以作为函数继续调用val f7 = f5()println(f7)      //f6调用25println(f7(25))  //()println(f5()(25))//f6调用25//()}
}

5.2.3 高阶函数练习

（1）定义一个匿名函数，并将它作为值赋给变量 fun。函数有三个参数，类型分别为 Int，String，Char，返回值类型为 Boolean。
要求调用函数 fun(0, “”, ‘0’)得到返回值为 false，其它情况均返回 true。

package com.yu.chapter05object Function_practise {def main(args: Array[String]): Unit = {val fun = (i: Int, j: String, k: Char) => {if (i == 0 && j == "" && k == '0') false else true}println(fun(0, "", '0'))    //falseprintln(fun(1, "12", '1'))  //trueprintln(fun(4, "", '0'))    //true}
}

（2）定义一个函数 func，它接收一个 Int 类型的参数，返回一个函数（记作 f1）。它返回的函数 f1，接收一个 String 类型的参数，同样返回一个函数（记作 f2）。函数 f2 接收一个 Char 类型的参数，返回一个 Boolean 的值。
要求调用函数 func(0) (“”) (‘0’)得到返回值为 false，其它情况均返回 true。

package com.yu.chapter05object Function_practise2 {def main(args: Array[String]): Unit = {def func(s: Int) : String => (Char => Boolean) = {def f1(m: String): Char => Boolean = {def f2(l: Char): Boolean = {if (s == 0 && m == "" && l == '0') false else true}f2}f1}println(func(0)("")('0'))    //falseprintln(func(1)("")('0'))    //true//简写为匿名函数//函数名，类型转换，变量类型都可以省略def func1(s: Int) : String => (Char => Boolean) = {m => l => { if (s == 0 && m == "" && l == '0') false else true }}println(func1(0)("")('0'))    //false//柯里化def func2(i: Int)(j: String)(k: Char): Boolean = {if (i == 0 && j == "" && k == '0') false else true}println(func2(0)("")('0'))  //false}
}

Map模拟实现

package com.yu.chapter05object HighOrder_Collection {def main(args: Array[String]): Unit = {val arr: Array[Int] = Array(12, 24, 22, 1)//对数组进行处理，将操作抽象出来，处理完毕返回新的数组def arrayOperation(array: Array[Int], op: Int => Int): Array[Int] = {//遍历数组进行操作for (elem <-array) yield op(elem)}//定义一个加1操作def addOne(elem: Int) : Int ={elem + 1}//调用函数val newArray: Array[Int] = arrayOperation(arr, addOne)println(newArray.mkString(","))    //13,25,23,2//传入匿名函数val newArray2: Array[Int] = arrayOperation(arr, _ * 2)val newArray3: Array[Int] = arrayOperation(arr, (x: Int) => {x * x})println(newArray2.mkString(","))    //24,48,44,2println(newArray3.mkString(","))    //144,576,484,1}
}

5.2.4 函数柯里化&闭包

闭包：如果一个函数，访问到了它的外部（局部）变量的值，那么这个函数和他所处的环境，称为闭包。
函数柯里化：把一个参数列表的多个参数，变成多个参数列表。

package com.yu.chapter05object Function_ClosoureAndCurrying {def main(args: Array[String]): Unit = {def f1() = {var a: Int = 10def add(b: Int) = {a + b}add _}//在调用时，f1函数执行完毕后，局部变量a应该随着栈空间释放掉val f = f1()// 但是在此处，变量 a 其实并没有释放，而是包含在了 f2 函数的内部，形成了闭合的效果println(f(3))    //13println(f1()(2)) //12def f2(a: Int): Int => Int = {def add1(b: Int): Int = {a + b}add1}println(f2(2)(5))    //7//缩写匿名函数def f3(a: Int): Int => Int = {//(b: Int) => a + b//b => a + ba + _}println(f3(8)(2))    //10//柯里化:分层调用def f4(a: Int)(b: Int): Int = {a + b}println(f4(8)(3))    //11}
}

5.2.4 递归

一个函数/方法在函数/方法体内又调用了本身，我们称之为递归调用。
递归实现简单，但栈资源占用大，深度较大，容易造成栈溢出。

package com.yu.chapter05import scala.annotation.tailrecobject Recursion {def main(args: Array[String]): Unit = {println(test(5))    //120println(tailRec(5)) //120}//递归计算阶乘//必须声明函数返回值类型，必须指定结束条件def test(i: Int): Int = {if (i == 0){return 1} else {return test(i-1) * i}}//尾递归：不耗费大量的栈空间def tailRec(n: Int): Int = {@tailrec //保证下面是正确的尾递归//直接覆盖，不会重复压栈def loop(n: Int, curRes: Int): Int = {if (n == 0) return curResloop(n-1, curRes * n)}loop(n, 1)  //curRes初值为1}
}

5.2.5 控制抽象

（1）值调用：把计算后的值传递过去
（2）名调用：把代码传递过去

package com.yu.chapter05object ControlAbstract {def main(args: Array[String]): Unit = {//1. 传值参数def f0(a: Int): Unit ={println("a:" + a)}def f1(): Int = {println("f1调用")12}f0(f1())//f1调用//a:12//2. 传名参数：传递的不再是具体的值，而是代码块// =>Int 表示一代码块，返回值是Intdef f2(a: =>Int): Unit = {println("a:" + a)println("a:" + a)}f2(23)//a:23//a:23f2(f1())   //f1被调用几次是由f2中a被使用几次决定的，相当于把f2中的a替换为f1()//f1调用//a:12//f1调用//a:12f2({println("一个代码块")12})//一个代码块//a:12//一个代码块//a:12}
}

自定义一个 While 循环：

package com.yu.chapter05object My_While {def main(args: Array[String]): Unit = {//1. 常规循环var n = 10while (n >= 1){println(n)n -= 1}//2. 用闭包实现一个函数，将代码块作为参数传入，递归调用def my_While(condition: =>Boolean ) : (=>Unit) => Unit= {//内层函数需要递归调用，参数就是循环体def doLoop(op: =>Unit): Unit = {if (condition){opmy_While(condition)(op)}}doLoop _}//调用n = 10my_While(n >= 1){println(n)n -= 1}//3. 匿名函数实现def my_While2(condition: =>Boolean ) : (=>Unit) => Unit= {//内层函数需要递归调用，参数就是循环体op => {if (condition){opmy_While2(condition)(op)}}}n = 10my_While2(n >= 1){println(n)n -= 1}//4. 柯里化实现def my_While3(condition: =>Boolean )(op: =>Unit) : Unit= {//内层函数需要递归调用，参数就是循环体if (condition){opmy_While3(condition)(op)}}n = 10my_While3(n >= 1) {println(n)n -= 1}}
}

5.2.6 惰性加载

当函数返回值被声明为 lazy 时，函数的执行将被推迟，**直到我们首次对此取值，该函数才会执行。**这种函数我们称之为惰性函数。

package com.yu.chapter05object Function_Lazy {def main(args: Array[String]): Unit = {lazy val result: Int = sum(12, 13)println("1. 函数调用")println("2. result = " + result)println("4. result = " + result)def sum(a: Int, b: Int): Int = {println("3. sum调用")a + b}}
}

6 面向对象

Scala 的面向对象思想和 Java 的面向对象思想和概念是一致的。

6.1 Scala包

（1）基本语法

package 包名

（2）Scala包的三大作用
a. 区分相同名字的类
b. 当类很多时，可以很好的管理类
c. 控制访问范围

6.1.1 包的命名

命名规则

只能包含数字、字母、下划线、小圆点.，但不能用数字开头，也不要使用关键字。
demo.class.execl. //错误，不能使用classdemo.12a. //错误，数字开头

命名规范

一般是小写字母+小圆点
com.公司名.项目名.业务模块名

6.1.2 包说明（包语句）

Scala 有两种包的管理风格，一种方式和 Java 的包管理风格相同，每个源文件一个包（包名和源文件所在路径不要求必须一致），包名用“.”进行分隔以表示包的层级关系，如com.atguigu.scala。另一种风格，通过嵌套的风格表示层级关系，如下

第二种风格有以下特点：
（1）一个源文件中可以声明多个 package
（2）子包中的类可以直接访问父包中的内容，而无需导包
是否能访问与物理位置无关，需要看实际导入的包，在哪个包下。

//嵌套风格定义包
package com{import com.yu.chapter06.Inner  //父包访问子包需要导包object Outer {var out: String = "out"def main(args: Array[String]): Unit = {println(Inner.in)}}package yu{package chapter06{object Inner {val in: String = "inner"def main(args: Array[String]): Unit = {println(Outer.out)  //out   //子包访问父包无需导包Outer.out = "outer"println(Outer.out)  //outer}}}}
}

6.1.3 包对象

在 Scala 中可以为每个包定义一个同名的包对象，定义在包对象中的成员，作为其对应包下所有 class 和 object 的共享变量，可以被直接访问。

（1）若使用 Java 的包管理风格，则包对象一般定义在其对应包下的 package.scala文件中，包对象名与包名保持一致。

（2）如采用嵌套方式管理包，则包对象可与包定义在同一文件中，但是要保证包对象与包声明在同一作用域中。

6.1.4 包导入

1）和 Java 一样，可以在顶部使用 import 导入，在这个文件中的所有类都可以使用。
2）局部导入：什么时候使用，什么时候导入。在其作用范围内都可以使用
3）通配符导入：import java.util._
4）给类起名：import java.util.{ArrayList=>JL}
5）导入相同包的多个类：import java.util.{HashSet, ArrayList}
6）屏蔽类：import java.util.{ArrayList =>,}

6.2 类和对象

类：可以看成一个模板
对象：表示具体的事物

6.2.1 定义类

基本语法：

[修饰符] class 类名{
类体
}

a. Scala 语法中，类并不声明为 public，所有这些类都具有公有可见性（即默认就是public）
b. 一个 Scala 源文件可以包含多个类

6.2.2 属性

属性是类的一个组成部分。

package com.yu.chapter06import scala.beans.BeanPropertyobject class1 {def main(args: Array[String]): Unit = {//创建一个对象val student = new Student()//student.name //不可访问私有属性println(student.age)  //0println(student.sex)  //nullstudent.sex = "male"  //进行赋值println(student.sex)  //male}
}
//定义一个类
class Student {//定义属性//默认属性是共有的public，不用加关键字，私有的可加privateprivate var name: String = "alice"//@BeanProperty// Bean 属性（@BeanPropetry），可以自动生成规范的 setXxx/getXxx方法//_表示给属性一个默认值var age: Int = _  //Int 对应初值为0var sex: String = _  //_表示为空
}

6.3 封装

封装就是把抽象出的数据和对数据的操作封装在一起，数据被保护在内部，程序的其它部分只有通过被授权的操作（成员方法），才能对数据进行操作。

访问权限

（1）Scala 中属性和方法的默认访问权限为 public，但 Scala 中无 public 关键字。
（2）private 为私有权限，只在类的内部和伴生对象中可用。
（3）protected 为受保护权限，Scala 中受保护权限比 Java 中更严格，同类、子类可以访问，同包无法访问。
（4）private[包名]增加包访问权限，包名下的其他类也可以使用。

方法和创建对象

package com.yu.chapter06object test_ClassForAccess {}//定义一个父类
class Person{private var idCard: String = "123456"  //私有属性，只在类的内部和半生对象中可用protected var name = "alice"    //受保护属性，只有同类、子类可以访问，同包无法访问var sex = "male"private[chapter06] var age: Int = 18 //包名下的其他类可以使用def printInfo(): Unit = {println(s"Person: $idCard $name $sex $age")}
}

创建对象：
（1）val 修饰对象，不能改变对象的引用（即：内存地址），可以改变对象属性的值。
（2）var 修饰对象，可以修改对象的引用和修改对象的属性值
（3）自动推导变量类型不能多态，所以多态需要显示声明

package com.yu.chapter06object test_Access {def main(args: Array[String]): Unit = {//创建对象val person: Person = new Person()
//    person.idCard //无法访问
//    person.name  //无法访问，只有同类、子类可访问，同包无法访问println(person.age)     //18println(person.sex)     //maleperson.printInfo()      //Person: 123456 alice male 18//person = new Person //不可以更改引用val worker: Worker = new Worker()worker.printInfo()     //Worker: bob male 25}
}//定义一个子类
class Worker extends Person{override def printInfo(): Unit ={//    println(idCard)  //不可访问name = "bob"age = 25sex = "male"println(s"Worker: $name $sex $age")}
}

构造器

Scala 类的构造器包括：主构造器和辅助构造器

（1）辅助构造器，函数的名称 this，可以有多个，编译器通过参数的个数及类型来区分。
（2）辅助构造方法不能直接构建对象，必须直接或者间接调用主构造方法。
（3）构造器调用其他另外的构造器，要求被调用构造器必须提前声明。

package com.yu.chapter06object test_Constructor {def main(args: Array[String]): Unit = {val student1: Student1 = new Student1  //这里括号也可以省略//1. 主构造方法被调用student1.Student1()//一般方法被调用val student2 = new Student1("alice")   //调用辅助构造方法1//1. 主构造方法被调用//2. 辅助构造方法1被调用//name: alice age:0val student3 = new Student1("alice", 18)   //调用辅助构造方法2//辅助构造方法2调用了辅助构造方法1，辅助构造方法1调用了主构造方法//1. 主构造方法被调用//2. 辅助构造方法1被调用//name: alice age:0//3. 辅助构造方法2被调用//name: alice age:18}
}//定义一个类
//如果主构造器无参数，小括号可省略
class Student1() {//定义属性var name: String = _var age: Int = _println("1. 主构造方法被调用")//声明辅助构造方法def this(name: String) {this()   //直接调用主构造器println("2. 辅助构造方法1被调用")this.name = nameprintln(s"name: $name age:$age")}def this(name:String, age:Int) {this(name)  //调用辅助构造器，相当于间接调用主构造器println("3. 辅助构造方法2被调用")this.age = ageprintln(s"name: $name age:$age")}def Student1(): Unit = {println("一般方法被调用")}
}

Scala 类的主构造器函数的形参包括三种类型：未用任何修饰、var 修饰、val 修饰
（1）未用任何修饰符修饰，这个参数就是一个局部变量
（2）var 修饰参数，作为类的成员属性使用，可以修改
（3）val 修饰参数，作为类只读属性使用，不能修改

package com.yu.chapter06object test_ConstructorParams {def main(args: Array[String]): Unit = {val student2 = new Student2student2.name = "alice"student2.age = 17println(s"student2: name = ${student2.name}, age = ${student2.age}")//student2: name = alice, age = 17val student3 = new Student3("bob", 20)println(s"student3: name = ${student3.name}, age = ${student3.age}")val student4 = new Student4("marry", 21, "yu")println(s"student4: name = ${student4.name}, age = ${student4.age}")//student4: name = marry, age = 21student4.printInfo()//student4: name = marry, age = 21, school = yu}
}//定义类
//无参构造器：需要在下面构建辅助构造器进行赋值传参，或者在上面指定，但不能在创建对象时就指定参数
class Student2() {//定义属性var name: String = _var age: Int = _
}//上面定义等价于：直接传参
class Student3(var name: String, var age: Int)  //可以不加{}
//若不加修饰，参数为局部变量，外部调用不到class Student4(var name: String, var age: Int){var school: String = _def this(name: String, age: Int, school: String){this(name, age)this.school = school}def printInfo(): Unit ={println(s"student4: name = ${name}, age = ${age}, school = ${school}")}
}

6.4 继承和多态

继承

class 子类名 extends 父类名 { 类体 }
（1）子类继承父类的属性和方法
（2）scala是单继承
（3）继承的调用顺序：父类构造器->子类构造器

package com.yu.chapter06object test_inherit {def main(args: Array[String]): Unit = {val student1 = new Student7("marry", 18)//1. 主构造器被调用//3. 子类的主构造器调用//子类的主构造器被调用前，必须先调用父类的主构造器val student2 = new Student7("marry", 18, "123")//1. 主构造器被调用//3. 子类的主构造器调用//4. 子类的辅助构造器调用//最后调用子类的辅助构造器val teacher = new Teacherteacher.printInfo()//teacherdef personInfo(person: Person1): Unit = {person.printInfo()}val person = new Person1personInfo(student1)    //动态绑定，运行时绑定personInfo(teacher)personInfo(person)//1. 主构造器被调用//Person4: name = marry, age = 18, stdNo = null//teacher//Person4: name = null, age = 0}
}
class Person1(){var name: String = _var age: Int = _println("1. 主构造器被调用")def this(name: String, age: Int){this()println("2. 辅助构造器被调用")this.name = namethis.age = age}def printInfo(): Unit ={println(s"Person4: name = ${name}, age = ${age}")}
}
//定义子类
//如果前面父类有参数，在这里子类父类必须有相同的参数
//如果这里集成的是父类的辅助构造器Person1(name, age),那么上面调用顺序是：
// 父类主构造器 -> 父类辅助构造器 -> 子类主构造器 -> 子类辅助构造器
class Student7(name: String, age: Int) extends Person1 {var stdNo: String = _println("3. 子类的主构造器调用")def this(name:String, age: Int, stdNo: String){this(name, age)  //先调用自己的主构造方法println("4. 子类的辅助构造器调用")this.stdNo = stdNo}override def printInfo(): Unit = {println(s"Person4: name = ${name}, age = ${age}, stdNo = ${stdNo}")}
}class Teacher extends Person1 {override def printInfo(): Unit = {println(s"teacher")}
}

多态

Scala 中属性和方法都是动态绑定，而 Java 中只有方法为动态绑定，属性是静态绑定的。

package com.yu.chapter06object Dynamic_Bind {def main(args: Array[String]): Unit = {val student: Person2 = new Student8println(student.name)student.hello()//student      //java中属性是静态的，仍然会输出 person//Hello student}}
class Person2 {val name: String = "person"def hello() : Unit = {println("Hello person")}
}class Student8 extends Person2{override val name: String = "student"override def hello() : Unit = {println("Hello student")}
}

6.5 抽象类

抽象属性和抽象方法

抽象属性和方法必须也只能定义在抽象类中，抽象类中不一定非要有抽象类和抽象方法。

A. 基本语法：
（1）定义抽象类：abstract class Person{} //通过 abstract 关键字标记抽象类
（2）定义抽象属性：val|var name:String //一个属性没有初始化，就是抽象属性
（3）定义抽象方法：def hello():String //只声明而没有实现的方法，就是抽象方法

B. 继承和重写：
（1）如果父类为抽象类，那么子类需要将抽象的属性和方法实现，否则子类也需声明为抽象类
（2）重写非抽象方法需要用 override 修饰，重写抽象方法则可以不加 override。
（3）子类中调用父类的方法使用 super 关键字
（4）子类对抽象属性进行实现，父类抽象属性可以用 var 修饰；
子类对非抽象属性重写，父类非抽象属性只支持 val 类型，而不支持 var。
因为 var 修饰的为可变变量，子类继承之后就可以直接使用，没有必要重写

package com.yu.chapter06object Abstract_class {def main(args: Array[String]): Unit = {val student = new Student9println(student.name)student.eat() student.sleep()//student//person eat   //super了父类的方法，所有会调用//student eat//student sleep}
}
//定义抽象类
abstract class Person3 {//非抽象属性val name: String = "person"//抽象属性var age: Int//非抽象方法def eat(): Unit = {println("person eat")}//抽象方法def sleep() : Unit
}
//定义具体实现子类
class Student9 extends Person3 {//实现抽象属性和抽象方法var age: Int = 18override def sleep(): Unit = { //override可以省略println("student sleep")}//重写非抽象属性和方法//var类型的不可以重写，会报错，因为可变变量没有必要重写override val name: String = "student"override def eat(): Unit = {super.eat() //子类调用父类的方法使用superprintln("student eat")}
}

匿名子类

和 Java 一样，可以通过包含带有定义或重写的代码块的方式创建一个匿名的子类。

package com.yu.chapter06object AnnoymousClass {def main(args: Array[String]): Unit = {//不用定义抽象类的子类，直接重写val person: Person10 = new Person10 {override var name: String = "alice"override def eat(): Unit = println("person eat")}println(person.name)person.eat()//alice//person eat}
}
abstract class Person10 {var name: Stringdef eat(): Unit
}

6.6 单例对象（伴生对象）

Scala语言是完全面向对象的语言，所以并没有静态的操作（即在Scala中没有静态的概念）。但是为了能够和Java语言交互（因为Java中有静态概念），就产生了一种特殊的对象来模拟类对象，该对象为单例对象。若单例对象名与类名一致，则称该单例对象这个类的伴生对象，这个类的所有“静态”内容都可以放置在它的伴生对象中声明。

（1）单例对象采用 object 关键字声明
（2）单例对象对应的类称之为伴生类，伴生对象的名称应该和伴生类名一致。
（3）单例对象中的属性和方法都可以通过伴生对象名（类名）直接调用访问。

package com.yu.chapter06object test_Object {def main(args: Array[String]): Unit = {//val student = new Student11("alice", 12)  //类的参数被私有化这里就无法调用了//student.printInfo()val student1 = Student11.newStudent("alice", 10)student1.printInfo()//student: name = alice, age = 10, school = yuval student2 = Student11.apply("alice", 10)student2.printInfo()//student: name = alice, age = 10, school = yu//apply可以省略  直接使用单例对象的名称就可以调用到apply方法val student3 = Student11("alice", 10)student3.printInfo()//student: name = alice, age = 10, school = yu}
}
//定义类：伴生类
class Student11 private(val name: String, val age: Int){def printInfo(): Unit ={//可以直接访问单例对象的属性和方法println(s"student: name = $name, age = $age, school = ${Student11.school}")}
}
//伴生对象：将静态内容放在伴生对象中
object Student11{var school: String = "yu"//定义一个类的对象实例的创建方法//通过伴生对象访问伴生类的私有属性 从而进行调用def newStudent(name: String, age: Int): Student11 = new Student11(name, age)def apply(name: String, age: Int): Student11 = new Student11(name, age)
}

单例设计模式：
（1）通过伴生对象的 apply 方法，实现不使用 new 方法创建对象。
（2）如果想让主构造器变成私有的，可以在()之前加上 private。
（3）apply 方法可以重载。

package com.yu.chapter06object test_SingelLeton {def main(args: Array[String]): Unit = {val student1 = Student12.getInstance()student1.printInfo()val student2 = Student12.getInstance()student2.printInfo()println(student1)println(student2)//student: name = alice, age = 18, school = yu//student: name = alice, age = 18, school = yu//com.yu.chapter06.Student12@1c53fd30//com.yu.chapter06.Student12@1c53fd30//地址相同，全局只有一份}
}class Student12 private(val name: String, val age: Int){def printInfo(): Unit ={println(s"student: name = $name, age = $age, school = ${Student11.school}")}
}
//直接给定
//object Student12 {//  private val student: Student12 = new Student12("alice", 18)
//  def getInstance(): Student12 = student
//}//后面创建
object Student12 {private var student: Student12 = _def getInstance(): Student12 = {if (student == null){//如果没有对象实例就创建一个student = new Student12("alice", 19)}student
}
}

6.7 特质（Trait）

多个类具有相同的特质（特征）时，就可以将这个特质（特征）独立出来，采用关键字 trait 声明。

Scala 中的 trait 中即可以有抽象属性和方法，也可以有具体的属性和方法，一个类可以混入（mixin）多个特质。这种感觉类似于 Java 中的抽象类。

基本用法

（1）语法
没有父类：class 类名 extends 特质 1 with 特质 2 with 特质 3 …
有父类：class 类名 extends 父类 with 特质 1 with 特质 2 with 特质 3…

（2）说明
a. 类和特质的关系：使用继承的关系。
b. 当一个类去继承特质时，第一个连接词是 extends，后面是 with。
c. 如果一个类在同时继承特质和父类时，应当把父类写在 extends 后。

package com.yu.chapter06object test_Trait {def main(args: Array[String]): Unit = {val student = new Student13student.sayHello()student.study()student.dating()student.play() //没有被重写//hello from alice//hello from student alice//student alice is studying//student alice is dating//young people is playing}
}class Person4 {val name: String = "person"var age: Int = 18def sayHello() : Unit = {println("hello from " + name)}
}
//定义一个特质
trait Young {//声明抽象和非抽象属性var age: Intval name: String = "young"def play(): Unit = {println("young people is playing")}def dating(): Unit
}
class Student13 extends Person4 with Young{//Person Young中都有name，产生了冲突 需要重写override val name: String = "alice"//实现抽象方法override def dating(): Unit = {println(s"student $name is dating")}def study(): Unit = {println(s"student $name is studying")}//重写父类方法override def sayHello(): Unit = {super.sayHello()println(s"hello from student $name")}
}

特征的混入

（1）特质可以同时拥有抽象方法和具体方法
（2）一个类可以混入（mixin）多个特质
（3）所有的 Java 接口都可以当做 Scala 特质使用
（4）动态混入：可灵活的扩展类的功能
a . 动态混入：创建对象时混入 trait，而无需使类混入该 trait
b. 如果混入的 trait 中有未实现的方法，则需要实现

package com.yu.chapter06object test_TraitMixin {def main(args: Array[String]): Unit = {val student = new Student14student.study()student.increase()student.play()student.increase()student.dating()student.increase()//student alice is studying//student alice knowledge increased: 1//young people is playing//student alice knowledge increased: 2//student alice is dating//student alice knowledge increased: 3//动态混入:灵活扩展类的功能val studentWithTalent = new Student14 with Talent{override def dancing(): Unit = println("student is good at dancing")override def singing(): Unit = println("student is good at singing")}studentWithTalent.dancing()studentWithTalent.singing()//student is good at dancing//student is good at singing}
}
trait Knowledge {var amout: Int = 0def increase() : Unit
}
trait Talent {def singing(): Unitdef dancing(): Unit
}
class Student14 extends Person4 with Knowledge with Young{//Person Young中都有name，产生了冲突 需要重写override val name: String = "alice"//实现抽象方法override def dating(): Unit = {println(s"student $name is dating")}def study(): Unit = {println(s"student $name is studying")}//重写父类方法override def sayHello(): Unit = {super.sayHello()println(s"hello from student $name")}override def increase(): Unit = {amout += 1println(s"student $name knowledge increased: $amout")}
}

特征叠加

由于一个类可以混入（mixin）多个 trait，且 trait 中可以有具体的属性和方法，若混入的特质中具有相同的方法（方法名，参数列表，返回值均相同），必然会出现继承冲突问题。
冲突分为以下两种：
第一种，一个类（Sub）混入的两个 trait（TraitA，TraitB）中具有相同的具体方法，且两个 trait 之间没有任何关系，解决这类冲突问题，直接在类（Sub）中重写冲突方法。

第二种，一个类（Sub）混入的两个 trait（TraitA，TraitB）中具有相同的具体方法，且两个 trait 继承自相同的 trait（TraitC），及所谓的“钻石问题”，解决这类冲突问题，Scala采用了特质叠加的策略。

所谓的特质叠加，就是将混入的多个 trait 中的冲突方法叠加起来。

package com.yu.chapter06object test_TraitOverlying {def main(args: Array[String]): Unit = {val student = new Student15student.increase()  //super返回的是最后一个，从后往前，不是先考虑父类//talent increased//钻石问题特征叠加val myFootBall = new MyFootBallprintln(myFootBall.describe())//my ball is a red-foot-ball}
}
trait Ball {def describe(): String = "ball"
}
//定义颜色特征
trait ColorBall extends Ball {var color: String = "red"override def describe(): String = color+ '-' + super.describe()
}
//定义种类特征
trait CategoryBall extends Ball {var category: String = "foot"override def describe(): String = category + '-' + super.describe()
}
//定义一个自定义球的类
class MyFootBall extends CategoryBall with ColorBall {override def describe(): String = "my ball is a " + super.describe()
}trait Knowledge1 {var amout: Int = 0def increase() : Unit = {println("knowledge increased")}
}
trait Talent1 {def singing(): Unitdef dancing(): Unitdef increase() : Unit = {println("talent increased")}
}
class Student15 extends Person4 with Knowledge1 with Talent1 {override def dancing(): Unit = println("dancing")override def singing(): Unit = println("singing")override def increase(): Unit = super.increase()
}

特征叠加执行顺序

（1）案例中的 super，不是表示其父特质对象，而是表示上述叠加顺序中的下一个特质，即，MyClass 中的 super 指代 Color，Color 中的 super 指代 Category，Category 中的 super指代 Ball。
（2）如果想要调用某个指定的混入特质中的方法，可以增加约束：super[]，例如super[Category].describe()。
可以指定继承哪个特质！！

特质自身类型

自身类型可实现依赖注入的功能。

package com.yu.chapter06object test_TraitSelfType {def main(args: Array[String]): Unit = {val user = new RegisterUser("alice", "123")user.insert()//insert into db: alice}
}
//用户类
class User(val name: String, val password: String)trait UserDao{//定义一个自身类型，就像插入了一个user对象一样_: User =>//向数据库插入数据def insert(): Unit = {println(s"insert into db: " + this.name)}
}
//定义注册用户类
class RegisterUser(name: String, password: String) extends User(name, password) with UserDao

特质和抽象类的区别

（1）优先使用特质。一个类扩展多个特质是很方便的，但却只能扩展一个抽象类。
（2）如果你需要构造函数参数，使用抽象类。因为抽象类可以定义带参数的构造函数，而特质不行（有无参构造）。

6.8 扩展

类型检查和转换

（1）obj.isInstanceOf[T]：判断 obj 是不是 T 类型。
（2）obj.asInstanceOf[T]：将 obj 强转成 T 类型。
（3）classOf 获取对象的类名。

枚举类和应用类

枚举类：需要继承 Enumeration
应用类：需要继承 App

Type定义新类型

package com.yu.chapter06object test_Extends {def main(args: Array[String]): Unit = {//1. 类型的检测和转换val student: Student17 = new Student17("alice", 14)student.study()student.sayhi()val person: Person17 = new Student17("bob", 21)person.sayhi()//hi from student bob//类型判断println("student is Student17 " + student.isInstanceOf[Student17])println("student is Person17 " + student.isInstanceOf[Person17])println("person is Person17 " + person.isInstanceOf[Person17])println("person is Student17 " + person.isInstanceOf[Student17])//student is Student17 true//student is Person17 true//person is Person17 true//person is Student17 trueval person2: Person17 = new Person17("marrt", 22)println("person2 is Student17 " + person2.isInstanceOf[Student17])//person2 is Student17 false//类型转换if (person.isInstanceOf[Student17]) {val newStudent = person.asInstanceOf[Student17]newStudent.study()}//student studyprintln(classOf[Student17]) //class com.yu.chapter06.Student17//枚举类println(WorkDay.Monday)  //Monday}
}
class Person17(val name: String, val age: Int){def sayhi(): Unit = {println("hi from person " + name)}
}
class Student17(name: String, age: Int) extends Person17(name, age){override def sayhi(): Unit = {println("hi from student " + name)}def study(): Unit = {println("student study")}
}//定义枚举类
object WorkDay extends Enumeration {val Monday = Value(1, "Monday")val Tuesday = Value(2, "Tuesday")
}
//定义应用类
object TestAPP extends App {println("app start")  //里面有main方法，可以直接执行//app start//定义新类型type MyString = Stringval a: MyString = "abc"println(a)//abc
}

Scala——函数式编程、面向对象相关推荐

Scala函数式编程（三） scala集合和函数
前情提要: scala函数式编程(二) scala基础语法介绍 scala函数式编程(二) scala基础语法介绍前面已经稍微介绍了scala的常用语法以及面向对象的一些简要知识,这次是补充上一章的 ...
scala函数式编程_想要开始进行函数式编程，请进入scala
scala函数式编程意见 (Opinion) If you haven't used Scala yet, you're not the only one: Not even four percen ...
Scala函数式编程设计原理第一课编程范式（Programming Paradigms）
我使用Scala有一两年的时间了,这门语言仿佛有一种魔力,让人用过就不想放手.Scala给我的整个程序生涯带来了非常深刻的影响,让我学会了函数式编程,让我知道了世界上居然还有这么一种优雅.高效.强大的 ...
Scala 函数式编程_部分应用函数_Partially Applied Functions
2019独角兽企业重金招聘Python工程师标准>>> Scala 函数式编程部分应用函数或函数的部分应用和其他遵循函数式编程范式的语言一样,Scala 允许部分应用一个函数. 调 ...
scala函数式编程 educoder
第一关:冒泡排序本关任务:本关主题是利用Scala基础实现对冒泡排序算法的改进.使用冒泡算法存在这样一种情况:在第j(j<n-1)趟时就已排好序,但算法仍然执行后面几趟的比较.实际上,一旦算法 ...
【编程语言】Scala 函数式编程
函数是Scala 中的一等公民. 本文讨论Scala函数式编程的一些基本原理.你将会学到如何使用高阶函数,以及重用已有代码时,遵守 DRY 原则. Scala 的集合库很棒 # So what doe ...
【中英双语】高级Scala函数式编程
[中英双语]高级Scala函数式编程成为顶级 Scala 程序员,这样您就可以使用 Spark.Akka.Cats 或任何 Scala 工具!此教程共13.5小时,中英双语字幕,画质清晰无水印,源码 ...
周末班补充视频Scala第2课：动手编写和运行自己的第一个Scala函数式编程的实例.
周末班补充视频Scala第2课:动手编写和运行自己的第一个Scala函数式编程的实例. package com.dtspark.scala.functional.basics object MyFir ...
scala函数式编程笔记: 纯函数式状态
scala函数式编程:纯函数式状态读书笔记 Overview: 带状态的方法的声明式实现可能带有副作用,难以保持引用透明. 以纯函数式的方式实现带状态的函数的关键在于让状态更新是显式的,不要以副作用方 ...
scala函数式编程（二） scala基础语法介绍
上次我们介绍了函数式编程的好处,并使用scala写了一个小小的例子帮助大家理解,从这里开始我将真正开始介绍scala编程的一些内容. 这里会先重点介绍scala的一些语法.当然,这里是假设你有一些ja ...

Scala——函数式编程、面向对象