scala基础

1.声明变量：val var 

object Test {
  def main(args: Array[String]): Unit = {
    var num1 = 10 //var 可变
    num1 = 20
    println(num1)
    val num = 12 // 不可变
    //num2 = 10    // 报错

    //多个变量声明
    val num3, num4 = 10
    println(num3)
    println(num4)
  }
}

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

    val name: String = "zhangsan" // 声明变量及类型
    //scala中可以不用声明类型，scala会自动类型推断
    println(name)
  }
}

2.数据类型

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

    // scala中的几种数据类型：byte char short int long float double boolean richint richdouble richchar bigint bigdecimal
    //scala中没有基本数据类型和包装类之分，所有的数据类型都是类

    val a  = 1.toString
    println(a)

    println(1.to(10))  //Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
  }
}

3.if条件表达式

object Test {
  def main(args: Array[String]): Unit = {
    //scala中的if条件语句 与 java中的不同  java中的条件语句没有返回值  scala中有返回值
    val num = 10
    val a = if (num > 10) {
      1
    } else {
      0
    }
    println(a)
  }
}

object Test {
  def main(args: Array[String]): Unit = {
    //scala的每个表达式都有一个类型  
    //Int类型
    val num = 10
    val a = if (num > 10) {
      1
    } else {
      0
    }
    println(a)
    
    //混合类型  Any类型
    val b = if (num > 10) {
      1
    } else {
      "b"
    }

    println(b)
  }
}

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

    val num = 10
    if (num > 20) {
      println("num>20")
    } else if (num > 10) {
      println("num<=20 and num>10")
    } else {
      println("num<=10")
    }
  }
}

scala中没有switch语句，但是有强大的模式匹配

4.块表达式和赋值

object Test {
  def main(args: Array[String]): Unit = {
    //scala中 {  } 包围的就是一个语句块，里面可以有很多表达式，最后一个表达式就是块的值
    val num = 10
    val result = {
      num + 10
    }
    println(result)

  }
}

5.输入和输出

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

    //输出 print println printf
    printf("name=%s,age=%d", "zhangsan", 10)

    //    name=zhangsan,age=10
  }
}

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

    //输入
    val name = readLine("name:")
    val age = readInt()
    printf("name=%s,age=%d", name, age)

//    name:zhangsan
//    10
//    name=zhangsan,age=10
  }
}

6.while循环、for循环

import scala.util.control.Breaks._

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

    //while 循环
    var num = 1
    while (num <= 5) {
      println(num)
      num += 1
      //      num--  scala中没有++ --
    }

    //for循环

    for (i <- 1 to 5) { //包含5
      println(i)
    }
    for (i <- 1 until 5) { //不包含5
      println(i)
    }


    //    退出循环

    breakable {
      for (i <- 1 to 5) {
        if (i == 3) {
          break
        }
        println(i)
      }
    }

    breakable {
      while (num <= 5) {
        println(num)
        num += 1
        if (num == 3) {
          break
        }
      }
    }

  }

}

7.高级for循环和for推导式

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

    //变量 <- 表达式 多个生成器，分号分隔
    for (i <- 1 to 3; j <- 1 to 3) {
      print(i * j) //123246369
    }

    //if守卫
    for (i <- 1 to 3 if i % 2 == 0; j <- 1 to 3) {
      print(i * j) //246
    }
  }

}

object Test {
  def main(args: Array[String]): Unit = {
    //   for推导式
    //for循环体用yield开始，循环会构造出一个集合，每次迭代生成集合中的一个元素
    val a = for (i <- 1 to 3) yield i
    println(a) // Vector(1, 2, 3)
  }
}

8.函数

object Test {
  // 函数
  //方法对对象进行操作 而函数不是

  //函数定义
  /*
  def 函数名(参数1：参数1类型，参数2：参数2类型)：返回值类型 = {
          函数体
      }
  非递归函数不需要指定函数返回值类型
   */


  def mySum(a: Int, b: Int): Int = {
    a + b
  }

  //递归函数：函数本身调用函数
  def fac(n: Int): Int = {
    if (n <= 0) {
      1 //递归函数出口
    } else {
      n * fac(n - 1)
    }
  }


  def main(args: Array[String]): Unit = {
    //函数调用
    val result = mySum(1, 2)
    println(result) // 3

    val a = fac(3)
    println(a) // 6
  }
}

9.默认参数与带名参数

object Test {
  //默认参数
  def myString(str: String, left: String = "{", right: String = "}"): String = {
    left + " " + str + " " + right
  }


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

    //使用默认参数
    println(myString("zhangsan"))
    //使用自定义参数
    println(myString("zhangsan", "<<<", ">>>"))
    //参数格式不够
    println(myString("zhangsan", "<<<"))
    //使用带名参数
    println(myString(right = ">>>", left = ">>>", str = "zhangsan"))
    //带名参数与非带名参数混用   非带名参数要在带名参数前面
    println(myString("zhangsan", right = ">>>"))
  }
}

10.变长参数

object Test {
  //变长参数
  def mySum(num: Int*) = { // 计算偶数之和
    var sum = 0
    for (i <- num if i % 2 == 0) {
      sum += i
    }
    sum
  }


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

    //传入单个值时，必须是Int类型
    val result: Int = mySum(1, 2, 3)
    println(result)
    //传入一个序列
    val a = mySum(1 to 5: _*)
    println(a)

  }
}

11.过程

object Test {
  //过程
  //函数中不使用 = ，那么函数返回值类型为Unit 该函数称之为过程
  def myString(str: String, left: String = "{", right: String = "}") {
    println(left + " " + str + " " + right)
  }


  def main(args: Array[String]): Unit = {
   myString("zhangsan")
  }
}

12.懒值

object Test {


  def main(args: Array[String]): Unit = {
    // val 被声明为lazy 时，该变量将会推迟初始化
    // 只有到该变量的时候才会初始化
    lazy val words = scala.io.Source.fromFile("/usr/local/test.txt")

  }
}

13.异常

import java.io.FileNotFoundException

import math._

object Test {


  def main(args: Array[String]): Unit = {
    val x = 4
    //if else表达式 Double类型
    if (x > 0) {
      sqrt(x) //Double类型
    } else {
      throw new IllegalArgumentException("x should not be negative") //Nothing类型
    }
    //scala异常捕获，常用方式是模式匹配


    try {
      val words = scala.io.Source.fromFile("/usr/local/test.txt")
    } catch {
      case e: FileNotFoundException => {
        println("文件未找到")
      }
      case _ => {
        println("其他异常捕获处理")
      }
    } finally {
      println("最终处理")
    }
  }
}