变量和常量

var 变量名：[变量类型] = 变量值
val 变量名：[变量类型] = 变量值

  • 尽量使用常量
  • 声明一个变量，类型可以省略，编译器自动推断
  • 类型确定以后不能改变
  • 变量声明时必须要有初值
  • var可修改，val不可修改
    1. val alice = new Student("Alice",23)
    2. alice.age = 24 // 常量指向的对象不可更改，但其中的属性如果是var，就可以更改
    1. class Student(name: String, var age: Int) {}

    关键字

  1. 以字母或者下划线开头，后接字母、数字、下划线
  2. 以操作符开头，且只包含操作符 + - * /……
  3. 以反引号 ...包含的任意字符串
    1. var +-*/ = "sdsda"
    2. var `if` = "sdasdjo"

    字符串

    ```scala // 字符串通过 + 连接 val name String = “alice” val age: Int = 18 println(age + “岁的” + name + “在学习”)

// 用于字符串复制多次拼接 println(name 3)

// printf用法，字符串通过%传值 printf(“%d岁的%s在学习/n”, age, name)

//字符串模板（插值字符串）：通过$获取变量值 println(s”${age}岁的${name}在学习”)

val num: Double = 2.3456 println(f”The num is ${num}%3.2f”) // 格式化模板字符串 3：整个数的长度至少为3，不够补空格 // 2：只保留两位小数

println(raw”The num is ${num}%2.2f”)//不解析2.2f

//三引号表示字符串，保持多行字符串原格式输出、 val sql = s””” |select * |from | student |where | name = ${name} |and | age > ${age} |”””.stripMargin println(sql)

  1. <a name="wLZ7A"></a>
  2. ## 标准控制台输入
  3. ```scala
  4. import scala.io.StdIn
  6. object Test {
  7.   def main(args: Array[String]): Unit = {
  8.     println("请输入名字：")
  9.     val name: String = StdIn.readLine()
  10.     println("请输入年龄")
  11.     val age: int = StdIn.readInt()
  13.     //控制台输出
  14.     println(s"欢迎${age}岁的${name}来学习")
  15.   }
  16. }

读写文件

  1. import scala.io.Source
  3. object Test {
  4.   def main(args: Array[String]): Unit = {
  5.     //从文件读数据并打印
  6.     Source.fromFile("src/main/test.txt").foreach(print)
  8.     //将数据写入文件
  9.     val writer = new PrintWriter(new File("src/main/output.txt"))
  10.     writer.write("hello")
  11.     writer.close()
  12.   }
  13. }

数据类型

由于Java有基本类型，所以不是完全面向对象的语言
unified-types-diagram.svg

  • Scala中一切数据都是对象，都是Any的子类
  • Scala中数据类型分为两大类：数值类型（AnyVal）引用类型（AnyRef），不管是值类型还是引用类型都是对象
  • Scala数据类型仍然遵守：低精度的值类型向高精度值类型转换
  • Scala中StringOps是对Java中String增强
  • Unit对应Java中的void。Unit是一个数据类型，只有一个对象就是0。Void不是数据类型只是关键字
  • Null是一个类型，只有一个对象是null。是所有引用类型AnyRef的子类
  • Nothing是所有数据类型的子类，主要用在一个函数没有明确返回值时使用，因为这样我们可以把输出的返回值，返回给任何的变量或者函数
    1. val b: Int = null // error, null 是引用类型的子类

    整数类型 （Byte Short Int Long)

    Byte [1]: 8位有符号补码整数。数值区间为 -128 ~ 127
    Short[2]：16位有符号补码。区间 -32767 ~ 32767
    Int[4]：32位有符号补码整数。数值区间 -2147483648 ~ 2147483647
    long[8]：64位有符号补码 ```scala val b1: Byte = 10 val b2: Byte = (10 + 20) val b3: Byte = (b1 + 20)//error val b4: Byte = (b1 + 20).toByte

// 浮点类型 val f1: Float = 1.234f val d1: = 24.232

// 字符类型 val c1: Char = ‘a’ val c2: Char = ‘9’ val c3: Char = ‘\t’ // 制表符 val c4: Char = ‘\n’ // 换行符

// 字符变量底层保存ASCII码 val i1: Int =c1 println(“i1:” + i1) //97 val i2: Int = c2 // 57

val c7: Char = (i1+1).toChar println(c7)//b val c8: Char = (i2 - 1).toChar println(c8) //8

  1. <a name="1mNw8"></a>
  2. ### Unit类型、Null类型和Nothing类型
  3. | 数据类型 | 描述 |
  4. | --- | --- |
  5. | Unit | 表示无值，和void等同。用作不返回任何结果的方法的类型。Unit只有一个实例：0 |
  6. | Null | Null类型只有一个实例值null |
  7. | Nothing | Nothing类型再Scala类型最底层，它是任何类型的子类型<br />当一个函数，我们确定没有正常的返回值，可以用Nothing来指定返回类型，这样的好处是我们可以把返回的值（异常)赋给其它的函数或者变量 |
  9. ```scala
  10. // 空类型Unit
  11. def m1(): Unit = {
  12.   println("m1被调用执行")
  13. }
  15. val a: Unit = m1()
  16. println("a:" + a) 
  17. //结果：
  18. m1被调用执行
  19. a:()
  1. // 空引用Null
  2. val n: Int = null   //error
  3. var student = new Student("Alice",20)
  4. student = null
  5. println(student)// null
  1. // Nothing
  2. def m2(n: Int): Int = {
  3.   if (n==0) 
  4.     throw new NullPointerException // 返回值为Nothing
  5.   else
  6.       return n // 返回值为Int，为Nothing的父类
  7. }
  8. val b = m2(2)
  9. println(b)//2

类型转换

  1. object Test {
  2.   def main(args: Array[String]): Unit = {
  3.     //自动提升原则
  4.     val a1: Byte = 10
  5.     val b1: Long = 2333
  6.     val result1: Long = a1 + b1
  7.     val result2: Int = (a1 + b1.toInt) //强转
  9.     // 精度大的值赋给精度小的，就会报错，反之就会进行自动类型转换
  10.     val a2: Byte = 10
  11.     val b2: Int = a2
  12.     val c2: Byte = b2//error
  14.     // byte short 和char之间不会相互自动转换
  15.     val a3: Byte = 10
  16.     val b3: Char = 'b'
  17.     val c3: Byte = b3 // error
  19.     //byte short char 三者计算，首先转换为int类型
  20.     val a4: Byte = 12
  21.     val b4: Short = 25
  22.     val c4: Char = 'c'
  23.     val result4: Int = a4 + b4 + c4 //136
  24.   }
  25. }

强制类型转换

  1. Java：int num = (int)2.5
  2. Scala: var num: Int = 2.7.toInt
  1. val n1: Int = -2.9.toInt
  2. println("n1:" + n1) //-2
  4. val n2: Int = 2.6.toInt + 3.7.toInt
  5. val n3: Int = (2.6 + 3.7).toInt
  6. println(n2)//5
  7. println(n3)//6
  9. //Strint 类型转换
  10. //数值转String
  11. val n: Int = 27
  12. val s: String = n + ""
  13. val s2: String = n.toString
  15. // String转数值
  16. val m: Int = "12".toInt
  17. val f: Float = "12.3".toFloat
  18. val f2: Int = "12.3".toDouble.toInt
  20. // String转Char
  21. val 变量名: 值类型 = 字符串.toCharArray