Scala数据类型，函数式编程

Scala语言特点

Scala 是一以Java虚拟机为运行环境并面向对象和函数式编程结合在一起的静态类型编程语言

• 1）Scala 是一门多范式编程语言，Scala 支持面向对象和函数式编程
• 2）Scala 源代码会编译成java 字节码，然后在JVM上运行，并调用现有的java类库
• 3）Scala 语言非常简洁
• 4）Scala 将函数式编程语言的特点融合到JAVA中。

变量与常量

在 JAVA 中的变量和常量的格式：

变量： 变量类型 变量名称=初始值  int  a = 10

常量：final 常量类型 常量名称 = 初始值     final int  b = 10

在 Scala 中的基本语法

• var 变量名 [ : 变量类型] = 初始值 var a:Int = 10
• val 常量名 [: 常量类型] = 初始值  val b :Int = 10

按操

//    （1）声明变量时，类型可以省略，编译器自动推导，即类型推导
    var age = 20
    age = 18
//    （2）类型确定后，就不能修改，说明Scala是强数据类型语言。
//    age = "Bob"   // Error
//    （3）变量声明时，必须要有初始值
//    var name   // Error
//    （4）在声明/定义一个变量时，可以使用var或者val来修饰，var修饰的变量可改变，
    var num1 = 10   // 可变
    val num2 = 20   // 不可变

    num1 = 30  // 正确
//    num2 = 100  //错误，因为num2是val修饰的

数据类型

Java 数据类型

• Java 基本数据类型：char, byte, short, int, long, float, double boolean
• java 基本类型的包装类：Character, Byte, Integer, Long, Float, Double, Boolean

Scala 数据类型

• Scala 中一切数据都是对象，都是 Any 的子类
• Scala数据类型分为两类：数值类型（AnyVal), 引用类型（AnyRef)
• Scala 中低精度的值类型会向高精度值类型自动转换
• Unit 对应Java 中的void 用于方法返回值的位置，Unit 是一个数据类型
• Null 是一个类型，它是所有引用类型的子类
• Nothing 是所有数据类型的子类

Unit类型，Null 类型，Nothing 类型

数据类型	描述
Unit	表示无值，和其他语言中void等同。用作不返回任何结果的方法的结果类型。Unit只有一个实例值，写成()。
Null	null , Null 类型只有一个实例值null
Nothing	Nothing类型在Scala的类层级最低端；它是任何其他类型的子类型。 当一个函数，我们确定没有正常的返回值，可以用Nothing来指定返回类型，这样有一个好处，就是我们可以把返回的值（异常）赋给其它的函数或者变量（兼容性）

数值类型自动转换

当Scala进行运算或赋值时，精度小会向精度大的值类型转换，这个自动转换是按照精度容量大小排序为：

（1）自动提升原则：自动将所有数据转换成精度大的那种数据类型

（2）把精度大的数值类型赋值给精度小的数值类型时，就会报错

（3）（ byte，short）和char之间不会相互自动转换

强制类型转换

自动类型转换的逆过程，将精度大的数值类型转换为精度小的数值类型。使用时要加上强制转函数，但可能造成精度降低或溢出，格外要注意。

Java : int num = (int)5.2

Scala: var num:Int = 2.9.toInt

Scala 循环控制

范围数据范围（To）

• 1）基本语法

for(i <- 1 to 3){

    print(i + " ")

}

println()

（1） i 表示循环变量，<- 规定 to

(2) i 会从 1-3 循环，前后闭合

循环守卫

基本语法

for(i <- 1 to 3 if i != 2) {
    print(i + " ")
}
println()
 // 1 3
// 循环守卫，即循环保护式（也称条件判断式，守卫）。保护式为true则进入循环体内部，为false则跳过，类似于continue。
// 等价于
for(i <- 1 to 3){
    if(i != 2){
        print(i + " ")
    }
}

循环步长

基本语法

// by 表示步长
//需求：输出1到10以内的所有奇数
for (i <- 1 to 10 by 2) {
println("i=" + i)
}
// 结果
i=1
i=3
i=5
i=7
i=9

引入变量

基本语法

for(i <- 1 to 3; j = 4 - i) {
    println("i=" + i + " j=" + j)
}

//for推导式一行中有多个表达式时，所以要加 ; 来隔断逻辑

循环中断

Scala 内置控制结构去掉了break 和 continue 是为了更好适应 函数时编程，推荐使用函数式的风格解决break和continue的功能，而不是一个关键字。Scala中使用breakable控制结构来实现break和continue功能。

 

函数式编程

当解决问题时，我们把问题分解成一个个步骤，将每一个步骤封装起来，通过调用这些封装好的步骤，解决问题。

Scala语言是一个完全函数式编程，万物皆函数

object TestFunction {

def main(args: Array[String]): Unit = {

        // （1）函数定义
        def f(arg: String): Unit = {
            println(arg)
        }

        // （2）函数调用
        // 函数名（参数）
        f("hello world")
    }
}

函数定义

object Test_fun {
  def main(args: Array[String]): Unit = {

//    （1）函数1：无参，无返回值
    def test1():Unit = {
    println("无参数，无返回值")
    }
    test1()
//    （2）函数2：无参，有返回值
    def test2():String={
      return "无参， 有返回值"
    }
    println(test2())
//    （3）函数3：有参，无返回值
    def test3(s:String):Unit={
      println(s)
    }
    test3("hello scala")
//    （4）函数4：有参，有返回值
    def test4(s:String):String={
      return s + "有参，有返回值"
    }
    println(test4("hello"))
//    （5）函数5：多参，无返回值
    def test5(name:String,age:Int):Unit={
      println(s"$name,$age")
    }
    test5("wang", 18)
//    （6）函数6：多参，有返回值
    def test6(name:String,age:Int):String={
      return age + "岁的" + name + "正在学习"
    }
    test6("wang",18)
  }
}

// 答案
无参数，无返回值
无参， 有返回值
hello scala
hello有参，有返回值
wang,18

函数至简原则

原则：能省就省

（1）return可以省略，Scala会使用函数体的最后一行代码作为返回值

（2）如果函数体只有一行代码，可以省略花括号

（3）返回值类型如果能够推断出来，那么可以省略（:和返回值类型一起省略）

（4）如果有return，则不能省略返回值类型，必须指定

（5）如果函数明确声明unit，那么即使函数体中使用return关键字也不起作用

（6）Scala如果期望是无返回值类型，可以省略等号

（7）如果函数无参，但是声明了参数列表，那么调用时，小括号，可加可不加

（8）如果函数没有参数列表，那么小括号可以省略，调用时小括号必须省略

（9）如果不关心名称，只关心逻辑处理，那么函数名（def）可以省略

def main(args: Array[String]): Unit = {

    //（1） return可以省略,Scala会使用函数体的最后一行代码作为返回值
    def f1( s : String ): String =  {
      s + " Mr wang"
    }
    println(f1("Hello"))

    //（2）如果函数体只有一行代码，可以省略花括号
    def f2(s:String):String = s + " Mr wang"


    //（3）返回值类型如果能够推断出来，那么可以省略（:和返回值类型一起省略）
    def f3( s : String ) = s + " wang"
    println(f3("Hello3"))

    //（4）如果有return，则不能省略返回值类型，必须指定。
    def f4() :String = {
      return "ximenqing4"
    }
    println(f4())

    //（5）如果函数明确声明unit，那么即使函数体中使用return关键字也不起作用
    def f5(): Unit = {
      return "dalang5"
    }
    println(f5())

    //（6）Scala如果期望是无返回值类型,可以省略等号
    // 将无返回值的函数称之为过程
    def f6() {
      "dalang6"
    }
    println(f6())

    //（7）如果函数无参，但是声明了参数列表，那么调用时，小括号，可加可不加
    def f7() = "dalang7"
    println(f7())
    println(f7)

    //（8）如果函数没有参数列表，那么小括号可以省略,调用时小括号必须省略
    def f8 = "dalang"
    //println(f8())
    println(f8)

    //（9）如果不关心名称，只关心逻辑处理，那么函数名（def）可以省略
    def f9 = (x:String)=>{println("wusong")}

    def f10(f:String=>Unit) = {
      f("")
    }
    f10(f9)
    
  }

// 答案
Hello Mr wang
Hello3 wang
ximenqing4
()
()
dalang7
dalang7
dalang
wusong