深入浅出scala之变量定义（P11-20）

文章目录

• ​​1. 变量定义​​
• ​​2.数据类型​​
• ​​3.数值类型​​
• ​​4.浮点类型​​
• ​​5.字符类型​​
• ​​6.字符串类型​​
• ​​7.其他数据类型​​
• ​​8.类型转换​​

1. 变量定义

基本语法:

• 变量定义一定要初始化

var|val变量名[: 变量类型] .变量值

使用var或者val定义一个变量。

使用var(variable)声明变量，可以被重新赋值。
//定义变量a2,手动指定类型为Int,此时需要保证所赋值类型匹配
var 12:Int=2

//变量间可以互相赋值，并可以使用var重新定义
i1=12

使用val(value)声明常量-引用不可变

• val修饰的变量，相当于Java中final修饰的变量;
• 编译器具有类型推断功能

//定义常量s1,使用字符串“1"赋值，自动推断为String类型,值不可变
val s1="1"

//定义常量s2,手动指定类型为String,此时需要保证所赋值类型匹配
val s2: String="2"
//使用val定义基本数据类型时，值不可变，可以使用va1重新定义

• var修饰的变量可以修改，val修饰的变量不能修改；若是数组的话，里面的内容都是可以修改的
• 优先使用val：能够更快的被回收，适合并发编程，可以使用lazy修饰

scala> val v1 = 1
v1: Int = 1

scala> val v2:Int = 1
v2: Int = 1
scala> val v1,v2 = 1
v1: Int = 1
v2: Int = 1

scala> val (a,b,c) = (1,2.0,"abc")
a: Int = 1
b: Double = 2.0
c: String = abc



scala> var arr1=Array(1,2)
arr1: Array[Int] = Array(1, 2)

scala> arr1=Array(2,3)
arr1: Array[Int] = [I@1e287867

scala> arr1(0)=100

scala> arr1
res3: Array[Int] = Array(100, 3)

scala> val arr2=Array(1,2)
arr2: Array[Int] = Array(1, 2)

scala> arr2=Array(4,5)
<console>:12: error: reassignment to val
       arr2=Array(4,5)
           ^

scala> arr2(0)=100

scala> arr2
res5: Array[Int] = Array(100, 2)

scala>

• lazy可以修饰val的变量，使用的时候才会赋值

scala> lazy val aa =100
aa: Int = <lazy>

scala> print(aa)
100

2.数据类型

scala类型层级关系

• scala中所有的值都有类型，包括数值和函数、scala 中一切皆为对象，分为两大类 AnyVal (值类型)， AnyRef (引用类型)， 他们都是 Any 子类 Null 类型是 scala 的特别类型，它只有一个值 null, 他是 bottom calss,是 所有 AnyRef 类型的子类
  

Unit是值类型，他只有一个实例对象()。

Nothing是所有类型的子类，他没有一个具体的实例对象，一个常见的应用如:抛出异常、程序exit, 无限循环等。

Nothing是所有类型的子类，也是Null的子类。 Nothing没有对象， 但是可以用来定义类型。

• 例如，如果一个方法抛出异常，则异常的返回值类型就是Nothing(虽然不会返回) .

def get(intdex:Int):Int = {
  if (x < 0) throw new Exception(...)
  else ...
}

if语句是表达式，有返回值，必然有返回值类型，如果x≤0,抛出异常，返回值的类型为Nothing, Nothing也是

In的子类，所以，i[表达式的返回类型为Int, get方法的返回值类型也为int,

Null是所有引用类型的子类，它只有一个实例对象null, 主要用来和其他的JVM语言进行互操作。

3.数值类型

Scala和Java一样，有8种数值类型 Byte、Char、Short、Int、Long、Float、Double和一个Boolean类型。

• Scala 数值类型的取值范围和 Java 对应类型的取值范围相同。
• 和Java不同的是Scala没有基本类型和包装类型之分，这些类型都是类，有自己的属性和方法。

Byte
//直接使用整数赋值时，会被判断为Int类型，需要定义时指定类型
varb:Byte=2

Short
//直接使用整数赋值时，会被判断为Int类型，需要定义时指定类型
var s: Short = -3
//低精度可直接隐式转换为高精度
s = b // Byte- >Short

Int
//可以直接使用数字赋值
vari=5

// 定义Long类型的两种方式
scala> val d:Long = 8888
d: Long = 8888

scala> val d1 = 8888L
d1: Long = 8888

4.浮点类型

浮点类型包括float类型和double类型。
浮点值是由十进制、可选的小数点、可选的e或者E以及指数部分组成。
浮点类型的数值以F或者f结束，否则就是Double类型，Double类型的数值也可以以D或者d结尾，是可选的。
浮点型常量有两种表示形式：

• 十进制数形式：5.12，512.0f
• 科学计数法形式：如5.12e2 = 5.12乘以10的2次方

// 定义浮点类型，默认是Double类型
scala> val f = 3.1415
f: Double = 3.1415
// 在小数点后加上F，定义为Float类型
scala> val f = 3.14F
f: Float = 3.14

scala> val f1 = 3.14e2
f1: Double = 314.0

scala> val f1 = 3.14e2f
f1: Float = 314.0
// 在小数点后加上D，定义为Double类型
scala> val d1 = 3.1415D
d1: Double = 3.1415

scala> val d1 = 3.14e10
d1: Double = 3.14E10

5.字符类型

定义字符类型通常使用单引号字符赋值；也可以指定类型后，使用范围内的数字赋值

scala> val c = 'A'
c: Char = A

scala> val c1:Char = 'B'
c1: Char = B

scala> val c2:Char = 100
c2: Char = d

scala> val c3 = '\n'
c3: Char =

也可以使用转义字符：

6.字符串类型

String类型是有双引号包含的一个或者多个字符组成，语法和字符类型基本一致

scala> val a = "hello world"
a: String = hello world

7.其他数据类型

Unit为空类型行，相当于void，使用（）进行初始化

scala> val u =()
u: Unit = ()

Boolean类型，只能为true，false

scala> val b1 = false
b1: Boolean = false

scala> val b2:Boolean = true
b2: Boolean = true

Any可以接收任意的基本类型和引用类型

scala> val any:Any = 123
any: Any = 123

scala> val any:Any = null
any: Any = null

AnyRef可以接收任意的引用类型

scala> val any:AnyRef = 123
<console>:11: error: the result type of an implicit conversion must be more specific than AnyRef
       val any:AnyRef = 123
                        ^

scala> val any:AnyRef = "dsd"
any: AnyRef = dsd

Null：null值只能被推断为Null类型，null代表为空值，可以被赋值给任何AnyRef类型的常量或变量

scala> val n = null
n: Null = null

scala> val any:AnyRef = null
any: AnyRef = null

Nothing

• Nothing类型在Scala的类层级的最低端;它是任何其他类型的子类型。
• 当一个函数，我们确定没有正常的返回值，可以用Nothing 来指定返回类型，这样有一个好处，就是我们可以把返回的值(异常)赋给其它的函数或者变量(兼容性)

Option

• Option类型用来表示一个值是可选的（有值或无值）

scala> val m = Map("key1"->"value")
m: scala.collection.immutable.Map[String,String] = Map(key1 -> value)

scala> m.get("key1")
res24: Option[String] = Some(value)

scala> m.get("key2")
res25: Option[String] = None

8.类型转换

自动类型转换（低精度->高精度）

scala> val x:Long = 123456
x: Long = 123456

scala> val y:Float = x
y: Float = 123456.0

强制类型转换（高精度->低精度）

scala> val a = 9.9
a: Double = 9.9
//这样转换不成功
scala> val b:Int = a
<console>:12: error: type mismatch;
 found   : Double
 required: Int
       val b:Int = a
                   ^
scala> val b:Int = a.toInt
b: Int = 9

数值类型和字符串类型的转换

• 数值类型转字符串类型：
  只需要在后面加上""

scala> val s1 = 1234+""
s1: String = 1234

scala> val s2 = true + ""
s2: String = true

scala> val s3 = 3.14 + ""
s3: String = 3.14

字符串类型转数值类型：

scala> val s4 = "3.1415"
s4: String = 3.1415

scala> val res = s4.toInt
java.lang.NumberFormatException: For input string: "3.1415"
  at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
  at java.lang.Integer.parseInt(Integer.java:580)
  at java.lang.Integer.parseInt(Integer.java:615)
  at scala.collection.immutable.StringLike.toInt(StringLike.scala:304)
  at scala.collection.immutable.StringLike.toInt$(StringLike.scala:304)
  at scala.collection.immutable.StringOps.toInt(StringOps.scala:33)
  ... 28 elided

scala> val res = s4.toDouble
res: Double = 3.1415

scala> res.toInt
res26: Int = 3

scala> val s5 = "1234"
s5: String = 1234

scala> val res = s5.toInt
res: Int = 1234

• 参考：​​深入浅出Scala编程语言入门到精通​​，​​Scala深入学习之数据类型学习​​