Scala变量和数据类型
JunLeon——go big or go home
目录
前言：
Scala 是一种有趣的语言。它一方面吸收继承了多种语言中的优秀特性，一方面又没有抛弃 Java 这个强大的平台，它运行在 Java 虚拟机 (Java Virtual Machine) 之上，轻松实现和丰富的 Java 类库互联互通。它既支持面向对象的编程方式，又支持函数式编程。它写出的程序像动态语言一样简洁，但事实上它确是严格意义上的静态语言。Scala 就像一位武林中的集大成者，将过去几十年计算机语言发展历史中的精萃集于一身，化繁为简，为程序员们提供了一种新的选择。
一、Scala注释及代码规范
1、Scala注释
注释是一个程序员必须要具有的良好编程习惯。将自己的思想通过注释先整理出来，再用代码去体现。
1）基本语法
（1）单行注释
//用于单行注释（2）多行注释
/*
用于多行注释
*/（3）文档注释
/**
* 用于文档注释,多用于对类，方法的文档注释
*/2）示例
package com.junleon.chapter01
/* 这是多行注释
创建一个单例对象：HelloWorld
*/
object HelloWorld {
/**这是文档注释
* 这是main方法，是运行入口
* @param args
*/
def main(args: Array[String]): Unit = {
//这是单行注释，输出 Hello World
println("Hello World")
}
}2、代码规范
（1）使用一次 tab 操作，实现缩进，默认整体向右边移动，用 shift+tab 整体向左移；
（2）或者使用 ctrl + alt + L 来进行格式化；
（3）运算符两边习惯性各加一个空格。比如 2 + 4 * 5 ；
（4）一行最长不超过 80 个字符，超过的 请使用换行展示 ，尽量保持格式优雅。
二、Scala变量
1、变量与常量
1）基本语法
var 变量名 [: 变量类型] = 初始值 例如：创建变量v1 var v1:Int = 10
val 常量名 [: 常量类型 ] = 初始值 例如：创建常量v2 val v2:Int = 20
注意：能用常量的地方不用变量
（1）声明变量时，类型可以省略，编译器自动推导，即类型推导；
（2）类型确定后，就不能修改，说明 Scala 是强数据类型语言；
（3）变量声明时，必须要有初始值；
（4）在声明定义一个变量时，可以使用 var 或者 val 来修饰， var 修饰的变量可改变，val 修饰的变量不可改。
（5）var 修饰的对象引用可以改变，val 修饰的对象则不可改变，但对象的状态（值）却是可以改变的。（比如：自定义对象、数组、集合等等）
2）示例
package com.junleon.chapter02
object TestVariable {
def main(args: Array[String]): Unit = {
//定义一个变量v1,初始化值为10
var v1 : Int = 10
//定义一个常量v2,初始化值为20
val v2 : Int = 20
//打印输出v1、v2的值
println("v1值为：" + v1)
println("v2值为：" + v2)
var v3 = 30 //声明变量时，类型可以省略，编译器自动推导类型
v1 = 15 //var修饰的变量可以改变
//v2 = 25 则会报错，val修饰的常量值不可以改变
//v1 = "hello" 报错，v1是整型，不能赋值为字符串，即类型确定后，就不能修改，说明Scala是强数据类型语言。
//var v4 : int 报错，声明变量时，必须初始化值
}
}2、标识符的命名规范
Scala对各种变量 、方法 、函数等命名时使用的字符序列称为标识符 。即凡是自己可以起名字的地方都叫标识符。
1）命令规则
Scala中的标识符声明，基本和Java是一致的 ，但是细节上会有所变化，有以下三种规则：
（1）以字母或者下划线开头，后接字母、数字、下划线；
（2）以操作符开头，且只包含操作符等；
（3）用反引号包括的任意字符串，即使是 Scala 关键字（ 39 个）也可以（红色表示Java中没有的关键字）
-
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
2）示例
需求判断 hello 、 Hello12 、 1hello 、 h b 、 x h 、 h_4 、 _ab 、 Int 、 _、 、 ++--/#!1 、 if 、'if'，这些 名字是否合法 。
package com.junleon.chapter02
object TestName {
def main(args: Array[String]): Unit = {
// (1) 以字母或者下划线开头，后接字母、数字、下划线
var hello: String = "" // ok
var Hello12: String = "" // ok
// var 1hello: String = "" // error 数字不能开头
var h-b: String = "" // error 不能用-
// var x h: String = "" // error 不能有空格
var h_4: String = "" // ok
var _ab: String = "" // ok
var Int: String = "" // ok 因为在Scala中Int是预定义的字符,不是关键字，但不推荐
var _: String = "hel lo" // ok 单独一个下划线不可以作为标识符，因为被认为是一个方法
println(_)
//(2) 以操作符开头，且只包含操作符 （+ * / # 等）
var +*--/#! : String = "" // ok
// var +*--/#!1 : String = "" // error 以操作符开头，必须都是操作符
//(3) 用反引号'xxx'包括的任意字符串，即使是 Scala 关键字（ 39 个）也可以
// var if : String = "" // error 不能用关键字
var `if` : String = "" // ok 用反引号`包括的任意字符串包括关键字
}
}3、字符串的输出
1）基本语法
（1）字符串，通过‘+’号连接
（2）printf()用法：字符串，通过%传值。
-
%d 数值类型
-
%s 字符串类型
-
%f 浮点型
（3）字符串格式化模板 s"${xxx}"（插值字符串通过${}获取变量值)
2）示例
package com.junleon.chapter02
object TestString {
def main(args: Array[String]): Unit = {
var name: String = "zhangsan"
var age: Int = 18
//(1) 字符串，通过+号连接
println(name + "\t" + age)
//(2) printf用法：字符串通过%传值
printf("name=%s age=%d \n", name, age)
//(3)字符串，通过${}引用
println(s"name=${name},age=${age}")
/*
多行字符串，在Scala中，利用三个双引号包围多行字符串就可以实现。
输入的内容，带有空格、\t之类，导致每一行的开始位置不能整洁对齐。
应用scala的stripMargin方法，在scala中stripMargin默认
是 | 作为 连接符， 在多行换行的行头前面加一个 | 符号即可。
*/
val s =
"""
|select
| name,
| age
|from user
|where name = "zhangsan"
|""".stripMargin
println(s)
//如果需要对变量进行运算，那么可以加${}
val s1 =
s"""
|select
| name,
| age
|from user
|where name = "$name" and age = ${age+2}
|""".stripMargin
println(s1)
}
}4、键盘输入
在编程中，需要接收用户输入的数据，就可以使用键盘输入语句来获取。
1）基本语法
StdIn.readLine()、StdIn.readShort() 、StdIn.readDouble()
2）示例
package com.junleon.chapter02
import scala.io.StdIn
object TestInput {
def main(args: Array[String]): Unit = {
// 1 输入姓名
println("请输入姓名:")
var name = StdIn. readLine
// 2 输入年龄
println("请输入年龄:")
var age = StdIn. readShort
// 3 输入薪资
println("请输入薪资:")
var sal = StdIn. readDouble
// 4 打印
println("姓名：" + name)
println("年龄：" + age)
println("薪资：" + sal)
}
}三、Scala数据类型
Java知识注入：
Java基本类型：char、byte、short、int、long、float、double、boolean
Java引用类型：String等（对象类型）
Java基本类型的包装类：Character、Byte、Short、Integer、Long、Float、Double、Boolean
注意：Java中基本类型和引用类型没有共同的祖先。
1、Scala数据类型
1）Scala中一切数据都是对象，都是Any的子类；
2）Scala中数据类型分为两大类：数值类型（AnyVal）、引用类型（AnyRef），不管是数值类型还是引用类型都是对象；
3）Scala数据类型仍然遵守，低精度的值类型向高精度值类型，自动转换（隐式转换）；
4）Scala中的StringOps是对Java中的String增强；
5）Unit：对应Java中的void，用于方法返回值的位置，表示方法没有返回值。Unit是一个数据类型，只有一个对象就是()。Void不是数据类型，只是一个关键字；
6）Null是一个类型，只有一个对象就是null。它是所有引用类型（AnyRef）的子类。
7）Nothing，是所有数据类型的子类，主要用在一个函数没有明确返回值时使用，因为这样我们可以把抛出的返回值，返回给任何的变量或者函数。
2、整数类型
Scala 的整数类型就是用于存放整数值的，比如12，30，3456 等等。
1）整型分类
| 数据类型 | 描述 |
|---|---|
| Byte [1] | 8位有符号补码整数。数值区间为 -128 到 127 |
| Short [2] | 16位有符号补码整数。数值区间为 -32768 到 32767 |
| Int [4] | 32位有符号补码整数。数值区间为 -2147483648 到 2147483647 |
| Long [8] | 64位有符号补码整数。数值区间为 -9223372036854775808 到 9223372036854775807 =2的(64-1)次方-1 |
2）示例
（1） Scala 各整数类型有固定的 表示 范围和字段长度，不受具体操作的影响，以保证Scala 程序的可移植性。
（2）Scala 的整型，默认为 Int 型，声明 Long 型，须后加‘ l ’或 L。
（3） Scala 程序中 变量常声明为 Int 型 ，除非不足以表示大数，才使用 Long。
package com.junleon.chapter02
object TestDataType {
def main(args: Array[String]): Unit = {
// 正确
var n1:Byte = 127
var n2:Byte = -128
// 错误
// var n3:Byte = 128
// var n4:Byte = -129
var n5 = 10
println(n5)
var n6 = 9223372036854775807L
println(n6)
}
}3、浮点数类型
Scala的浮点类型可以表示一个小数，比如 123.4f 7.8 0.12 等等。
1）浮点型分类
| 数据类型 | 描述 |
|---|---|
| Float [4] | 32 位, IEEE 754标准的单精度浮点数 |
| Double [8] | 64 位 IEEE 754标准的双精度浮点数 |
2）示例
Scala的浮点型常量默认为 Double 型，声明 Float 型常量，须后加‘ f’ 或‘ F’ 。
package com.junleon.chapter02
object TestDataTypeFloat {
def main(args: Array[String]): Unit = {
//建议，在开发中需要高精度小数时，请选择Double
var float_num = 2.2345678912f
var double_num = 2.2345678912
println("float_num=" + float_num)
println("double_num=" + double_num)
}
}运行结果：
float_num=2.2345679
double_num=2.23456789124、字符类型
1）基本说明
字符类型可以表示单个字符，字符类型是Char 。
2）案例实操
（1）字符常量是用单引号 ' ' 括起来的单个字符;
（2） \t ：制表符
（3）\n ：换行符
（4）\\：表示\
（5）\" ：表示"
package com.junleon.chapter02
object TestCharType {
def main(args: Array[String]): Unit = {
//（1）字符常量是用单引号 ' ' 括起来的单个字符;
var c1 : Char = 'a'
println("c1="+c1)
//（2） \t ：制表符
println("姓名\t年龄")
//（3）\n ：换行符
println("姓名\n张三")
//（4）\\：表示\
println("C:\\bigdata\\scala")
//（5）\" ：表示"
println("军哥很\"帅\"")
}
}运行结果：
c1=a
姓名 年龄
姓名
张三
C:\bigdata\scala
军哥很"帅"5、布尔类型-Boolean
1）基本说明
（1）布尔类型也叫 Boolean 类型， Booolean 类型数据只允许取值 true 和 false； （2） boolean 类型占 1 个字节。
| 数据类型 | 描述 |
|---|---|
| boolean [1] | Booolean 类型数据只允许取值 true 和 false |
2）示例
package com.junleon.chapter02
object TestBooleanType {
def main(args: Array[String]): Unit = {
var isOk : Boolean = true
var isOk1 : Boolean = false
println("isok="+isOk+",类型为"+isOk.getClass)
println("isok1="+isOk1+",类型为"+isOk1.getClass)
}
}运行结果：
isok=true,类型为boolean
isok1=false,类型为boolean6、Unit类型、Null类型和Nothing类型（重点）
1）基本说明
| 数据类型 | 描述 |
|---|---|
| Unit | 表示无值，和其他语言中void等同。用作不返回任何结果的方法的结果类型。Unit只有一个实例值，写成()。 |
| Null | null , Null 类型只有一个实例值null |
| Nothing | Nothing类型在Scala的类层级最低端；它是任何其他类型的子类型。 当一个函数，我们确定没有正常的返回值，可以用Nothing来指定返回类型，这样有一个好处，就是我们可以把返回的值（异常）赋给其它的函数或者变量（兼容性） |
2）示例
（1）Unit 类型用来标识过程，也就是没有明确返回值的函数。
由此可见，Unit 类似于 Java 里的 void 。 Unit 只有一个实例 ——( )，这个实例也没有实质意义。
package com.junleon.chapter02
object TestSpecialType {
def main(args: Array[String]): Unit = {
def sayOk: Unit = { // unit 表示没有返回值，即 void
println(sayOk)
}
}
}（2）Null 类只有一个实例对象， Null 类似于 Java 中的 null 引用。
Null 可以赋值给任意引用类型（ AnyRef ），但是不能赋值给值类型 AnyVal。
package com.junleon.chapter02
object TestSpecialType {
def main(args: Array[String]): Unit = {
//null 可以赋值给任意引用类型（ AnyRef ），但是不能赋值给值类型AnyVal
var cat = new Cat();
cat = null // 正确
var n1: Int = null // 错误
println("n1:" + n1)
}
}
class Cat{
}（3） Nothing ，可以作为没有正常返回值的方法的返回类型，非常直观的告诉你这个方法不会正常返回，而且由于 Nothing 是其他任意类型的子类，他还能跟要求返回值的方法兼容。
package com.junleon.chapter02
object TestSpecialType {
def main(args: Array[String]): Unit = {
def test() : Nothing = {
throw new Exception()
}
test
}
}7、类型转换
1）数值类型自动转换
当Scala 程序在进行赋值或者运算时，精度小的类型自动转换为精度大的数值类型，这 个就是自动类型转换（隐式转换）。数据类型按精度（容量）大小排序为：
（1 ）自动提升原则：有多种类型的数据混合运算时，系统首先 自动将所有数据转换成精度大的那种数据类型 ，然后再进行计算。
（2）把精度大的数值类型赋值给精度小的数值类型时，就会报错 ，反之就会进行自动类型转换。
（3）（byte、short ）和 char 之间不会相互自动转换。
（4）byte、short、char 他们三者可以计算， 在计算时首先转换为 int 类型 。
示例：
package com.junleon.chapter02
object TestValueTransfer {
def main(args: Array[String]): Unit = {
//(1) 自动提升原则：有多种类型的数据混合运算时，系统首先自动将所有数据转换成精度大的那种数值类型，然后再进行计算。
var n = 1 + 2.0
println(n,n.getClass) // n 就是 Double
//(2) 把精度大的数值类型赋值给精度小的数值类型时，就会报错，反之就会进行自动类型转换。
var n2 : Double = 1.0
//var n3 : Int = n2 错误，原因不能把高精度的数据直接赋值和低精度。
//(3) （byte short）和 char之间不会相互自动转换。
var n4 : Byte = 1
//var c 1 : Char = n4 // 错误
var n5:Int = n4
//(4) byte、short、char他们三者可以计算，在计算时首先转换为int类型。
var n6 : Byte = 1
var c2 : Char = 1
// var n : Short = n6 + c2 当 n6 + c2 结果类型就是 int
// var n7 : Short = 10 + 90 错误
}
}注意：Scala还提供了非常强大的隐式转换机制（隐式函数，隐式类等）
2）强制类型转换
基本说明：
自动类型转换的逆过程，将精度大的数值类型转换为精度小的数值类型。使用时要加上强制转函数，但可能造成精度降低或溢出，格外要注意。
Java : int num = (int)2.5
Scala : var num : Int = 2.7.toInt示例：
（1）将数据由高精度转换为低精度，就需要使用到强制转换;
（2）强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级。
package com.junleon.chapter02
object TestForceTransfer {
def main(args: Array[String]): Unit = {
//(1) 将数据由 高精度 转换为 低精度 ，就需要使用到强制转换
var n1: Int = 2.5 .toInt // 这个存在精度损失
//(2) 强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级
var r1: Int = 10 * 3.5.toInt + 6 * 1.5.toInt // 10 * 3 + 6 * 1 = 36
var r2: Int = (10 * 3.5 + 6 * 1.5).toInt // 44.0.toInt = 44
println("r1=" + r1 + " r2=" + r2)
}
}3）数值类型和String类型间转换
基本说明:
在程序开发中，我们经常需要将基本数值类型转成String 类型。或者将 String 类型转成基本数值类型。
示例：
（1）基本类型转String类型（语法将基本类型的值 +"" 即可）
（2）String 类型转基本数值类型
（语法： s1.toInt 、s1.toFloat 、s1.toDouble 、s1.toByte 、s1.toLong、s 1.toShort）
package com.junleon.chapter02
object TestStringTransfer {
def main(args: Array[String]): Unit = {
//(1) 基本类型转 String 类型（语法：将基本类型的值 +"" 即可）
var str1: String = true + ""
var str2: String = 4.5 + ""
var str3: String = 100 + ""
//(2) String 类型转基本数值类型（语法：调用相关API）
var s1: String = "12"
var n1: Byte = s1.toByte
var n2: Short = s1.toShort
var n3: Int = s1.toInt
var n4: Long = s1.toLong
}
}下一篇：Scala运算符及流程控制语句
如果你喜欢、对你有帮助，点赞+收藏，跟着军哥学知识……