Scala基础：定义变量和逻辑判断语句以及方法和函数

定义变量和逻辑判断语句

package com.zy.scala

import scala.collection.immutable

object ScalaDemo {
  def main(args: Array[String]): Unit = {
    //定义变量-------------------------------------------
    // var 定义的变量是可变的
    var str1: String = "111"
    // 使用 val 定义的变量值是不可变的，相当于 java 里用 final 修饰的变量 scala鼓励使用val
    val str2: String = "222"

    //定义块表达式
    val a = 10
    val b = 20
    //在 scala 中{}中包含一系列表达式，块中最后一个表达式的值就是块的值
    //下面就是一个块表达式
    val result: Any = {
      val c = b - a
      val d = b - c
      d //块中最后一个表达式的值
    }
    //result 的值就是块表达式的结果
    println(result)

    //条件表达式----------------------------------------
    //if else的使用
    val x = 1
    val y = if (x == 1) "111" else "222"
    println(y)

    //if else if  else
    val z = if (x > 1) "111" else if (x < 1) "222" else false
    println(z)

    //循环
    //for(i <- 表达式),表达式 1 to 10 返回一个 Range（区间）
    //每次循环将区间中的一个值赋给 i
    for (i <- 1 to 10)
      println(i)

    //for(i <- 数组)
    val arr = Array("a", "b", "c")
    for (i <- arr)
      println(i)

    //高级 for 循环
    //每个生成器都可以带一个条件，注意：if 前面没有分号
    for (i <- 1 to 3; j <- 1 to 3 if i != j)
      print((10 * i + j) + " ")
    println()
    //for 推导式：如果 for 循环的循环体以 yield 开始，则该循环会构建出一个集合
    //每次迭代生成集合中的一个值
    val v: immutable.IndexedSeq[Int] = for (i <- 1 to 10) yield i * 10
    println(v)
  }
}

方法和函数

package com.zy.scala

object FunctionDemo {
  def main(args: Array[String]): Unit = {
    //方法和函数--------------------------------------

    //定义方法 def 函数名(参数列表):返回值类型={方法体}
    def method1(x: Int, y: Int): Int = {
      x * y
    }

    //调用方法
    val a: Int = method1(3, 2)
    println(a)

    //定义函数
    val function1 = (x: Int, y: Int) => {
      x + y
    }
    //调用函数
    val b: Int = function1(1, 2)
    println(b)

    //定义一个方法
    //方法 m2 参数要求是一个函数，函数的参数必须是两个 Int 类型
    //返回值类型也是 Int 类型
    def m1(f: (Int, Int) => Int): Int = {
      f(2, 6)
    }

    //定义一个函数 f1，参数是两个 Int 类型，返回值是一个 Int 类型
    val f1 = (x: Int, y: Int) => x + y
    //再定义一个函数 f2
    val f2 = (m: Int, n: Int) => m * n

    //调用 m1 方法，并传入 f1 函数
    val r1 = m1(f1)
    println(r1)
    //调用 m1 方法，并传入 f2 函数
    val r2 = m1(f2)
    println(r2)

    //将方法转换成函数，只需要在方法的后面加上一个下划线
    var f3 = m1 _
    val r3: Int = f3(
      f1
    )
    println(r3)
  }
}