vlambda博客
学习文章列表

• 单行注释：

//

• 多行注释：

/* */

• 文档注释：

/****/

1. 以字母或者下划线开头，后接字母、数字、下划线

2. 以操作符开头，且只包含操作符（+ - * / # !等）

3. 第一种和第二种拼接，第一种在前，二者以下划线分隔

4. 用反引号`....`包括的任意字符串，即使是关键字（39个）也可以

   
   

Scala关键字

• package, import, class, object, trait, extends, with, type, for

• private, protected, abstract, sealed, final, implicit, lazy, override

• try, catch, finally, throw

• if, else, match, case, do, while, for, return, yield

• def, val, var

• this, super

• new

• true, false, null

基本语法

说明：在Scala中声明一个变量时，可以不指定类型，编译器根据值确定

案例

（1）声明变量时，类型可以省略（编译器自动推导，即类型推导）

（2）类型确定后，就不能修改，说明Scala是强数据类型语言。

（3）变量声明时，需要初始值

 def main(args: Array[String]): Unit = { //（1）声明变量时，类型可以省略（编译器自动推导，即类型推导） var age = 18 age = 30  //（2）类型确定后，就不能修改，说明Scala是强数据类型语言。 // 错误 age = "tom"   //（3）变量声明时，需要初始值 //错误 var name  }

（4）在声明/定义一个变量时，可以使用var或者val来修饰，var修饰的变量可改变，val修饰的变量不可改。

（5）val修饰的变量在编译后，等同于加上final通过反编译看下底层代码

（6）var修饰的对象引用可以改变，val修饰的则不可改变，但对象的状态（值）却是可以改变的。（比如：自定义对象、数组、集合等等）

基本语法

（1）字符串，通过+号连接

（2）printf用法：字符串，通过%传值。

（3）字符串，通过$引用

基本语法

• StdIn.readLine()

• StdIn.readShort()

• StdIn.readDouble()

案例

Scala数据类型关系总结

• Scala中一切数据都是对象，都是Any的子类。

• Scala中数据类型分为两大类：数值类型（AnyVal）、引用类型（AnyRef），不管是值类型还是引用类型都是对象。

• Scala数据类型仍然遵守，低精度的值类型向高精度值类型，自动转换（隐式转换）

• Scala特殊的类型之Null，它只有一个实例就是Null，它是所有引用类型（AnyRef）的子类。

• Scala特殊类型之Nothing，是所有数据类型的子类，主要在一个函数没有正常返回值使用，因为这样我们可以把抛出的返回值，返回给任何的变量或者函数。

整数类型

浮点类型

字符类型（Char）

• 字符类型可以表示单个字符，字符类型是Char，16位无符号Unicode字符（2个字节），区间值为U+0000到U+FFFF。

• 字符常量是用单引号 ' ' 括起来的单个字符。

• 可以直接给Char赋一个整数，然后输出时，会按照对应的unicode字符输出

• Char类型是可以进行运算的，相当于一个整数，因为它都对应有Unicode码。

布尔类型（Boolean）

• Booolean类型数据只允许取值true和false

• boolean类型占1个字节

Unit类型、Null类型和Nothing类型

（1）Null类只有一个实例对象，Null类似于Java中的null引用。Null可以赋值给任意引用类型（AnyRef），但是不能赋值给值类型（AnyVal）

（2）Unit类型用来标识过程，也就是没有明确返回值的函数。

由此可见，Unit类似于Java里的void。Unit只有一个实例——( )，这个实例也没有实质意义

（3）Nothing，可以作为没有正常返回值的方法的返回类型，非常直观的告诉你这个方法不会正常返回，而且由于Nothing是其他任意类型的子类，他还能跟要求返回值的方法兼容。

• 数值类型隐式转换
  

数据类型按精度（容量）大小排序为

（1）自动提升原则：有多种类型的数据混合运算时，系统首先自动将所有数据转换成精度大的那种数据类型，然后再进行计算。

（2）当我们把精度大的数值类型赋值给精度小的数值类型时，就会报错，反之就会进行自动类型转换。

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

（4）byte，short，char他们三者可以计算，在计算时首先转换为int类型。

def main(args: Array[String]): Unit = {  //（1）自动提升原则：有多种类型的数据混合运算时，系统首先自动将所有数据转换成精度大的那种数值类型，然后再进行计算。 var n = 1 + 2.0 println(n) // n 就是Double  //（2）当我们把精度大的数值类型赋值给精度小的数值类型时，就会报错，反之就会进行自动类型转换。 var n1: Long = 1L //错误，原因不能把高精度的数据直接赋值和低精度。 var n2 : Int = n1  //（3）（byte，short）和char之间不会相互自动转换。 var n3: Byte = 1 //错误 var n4 : Char = n3  //（4）byte，short，char他们三者可以计算，在计算时首先转换为int类型。 var n5: Byte = 1 var n6: Char = 1 //当n5 + c2 结果类型就是int var n7 : Short = n5 + n6 //错误 var n7 : Short = 10 + 90 //正确 var n8: Short = 100}

• 强制类型转换

（1）当进行数据的从大——>小，就需要使用到强制转换

（2）强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级

（3）Char类型可以保存Int的常量值，但不能保存Int的变量值，需要强转

（4）Byte和Short类型在进行运算时，当做Int类型处理。

 def main(args: Array[String]): Unit = {  //（1）当进行数据的从大——>小，就需要使用到强制转换 // 这个存在精度损失 var n1: Int = 2.5.toInt  //（2）强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级 // 10 *3 + 6*1 = 36 var n2: Int = 10 * 3.5.toInt + 6 * 1.5.toInt // 44.0.toInt = 44 var n3: Int = (10 * 3.5 + 6 * 1.5).toInt  //（3）Char类型可以保存Int的常量值，但不能保存Int的变量值，需要强转 // 正确，因为直接将一个数值给char，编译器只判断是否越界 var c2: Char = 98 // 错误，Int高->char低，编译器判断类型 var c3: Char = 'a' + 1 var c4: Char = ('a' + 1).toChar   //（4）Byte和Short类型在进行运算时，当做Int类型处理。 var a: Short = 5 // 错误， Int->Short a = a - 2  var b: Byte = 3 // 错误，Int->Byte b = b + 4  }

（1）基本类型转String类型（基本类型的值+"" ）

（2）String类型转基本数值类型（语法：s1.toInt、s1.toFloat、s1.toDouble、s1.toByte、s1.toLong、s1.toShort）