目录
一、变量与常量
var 变量名 [: 变量类型] = 初始值 例：var i:Int = 10
val 常量名 [: 常量类型] = 初始值 例：val j:Int = 20
注意事项：
（1）声明变量时，类型可以省略，编译器自动推导，即类型推导
（2）类型确定后，就不能修改，说明Scala是强数据类型语言。
（3）变量声明时，必须要有初始值
（4）在声明/定义一个变量时，可以使用var或者val来修饰，var修饰的变量可改变，val修饰的变量不可改。
（5）var修饰的对象引用可以改变，val修饰的对象则不可改变，但对象的状态（值）却是可以改变的。（比如：自定义对象、数组、集合等等）
代码示例：
object Hello {
def main(args: Array[String]): Unit = {
//声明变量时，类型可以省略，编译器自动推导，即类型推导
var i1 = 10
//Scala是强数据类型语言,类型确定后，就不能修改
var i2: Int = 10
i2 = "10" //报错
//变量声明时，必须要有初始值
var i3: Int//报错
//在声明/定义一个变量时，可以使用var或者val来修饰，var修饰的变量可改变，val修饰的变量不可改
var i4: Int = 10
val i5: Int = 20
i4 = 30
i5 = 40 //报错
//var修饰的对象引用可以改变，val修饰的对象则不可改变，
// 但对象的状态（值）却是可以改变的。（比如：自定义对象、数组、集合等等）
val stu01 = new stu()
var stu02 = new stu()
// var 可以修改引用数据类型的地址值,val不行
stu01 = new stu() //报错
stu02 = new stu()
// 引用数据类型中的属性值能否发生变化，取决于内部的属性在定义的时候是var还是val
stu01.age = 26 //报错
stu01.name = "lss"
//在类中定义为_可以让编译器自动设置初始值
println(stu02.i7)
}
class stu {
var name: String = "ls"
val age: Int = 25
var i7: Int = _
}
}二、标识符
Scala对各种变量、方法、函数等命名时使用的字符序列称为标识符。
命名规则：（1）字母下划线开头，后跟数字字母下划线。 a1 a2_
（2）只包含+ - * / # !
（3）用反引号` `包含的字段，可包括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
var Int:String = "a" //在Scala中Int是预定义的字符,不是关键字 var _: String = "a" // 单独一个下划线不可以作为标识符，因为_被认为是一个方法 println(_) // IDEA不报错，运行报错
三、字符串
字符串的基本用法
1.通过+号拼接
2.重复字符串拼接
3.printf:通过%传值
4.通过$获取变量值
5.应用三引号和scala的stripMargin方法，在scala中stripMargin默认是“|”作为连接符
object test01 {
def main(args: Array[String]): Unit = {
//1.通过+号拼接
println("hello"+"world")//helloworld
//2.重复字符串拼接
println("hello"*10)//hellohellohellohellohellohellohellohellohellohello
//3.printf:通过%传值
printf("hello %s world %d\n",1,2) //hello 1 world 2
//4.通过$获取变量值
var name = "ls"
var age = 25
val s1 = s"name:${name},age:${age}" //name:ls,age:25
println(s1)
//5.长字符串
println("1" +
"2" +
"3")//123
//6.应用三引号和scala的stripMargin方法，在scala中stripMargin默认是“|”作为连接符
println(
"""一
|只
|老
|虎
|""".stripMargin) //一
//只
//老
//虎
}
}四、键盘输入
输入字符串：StdIn.readLine()
输入整型：StdIn.readInt()
输入浮点型：StdIn.readDouble()
object test02 {
def main(args: Array[String]): Unit = {
print("请输入姓名")
val name = StdIn.readLine()
print("请输入年龄")
val age = StdIn.readInt()
print(s"姓名：${name},年龄：${age}")
}
}
//请输入姓名ls
//请输入年龄25
//姓名：ls,年龄：25五、数据类型
1 ) Scala中一切数据都是对象,都是Any的子类。
2) Scala中数据类型分为两大类:数值类型(AnyVa1) 、引用类型（AnyRef)，不管是值类型还是引用类型都是对象。
3)Scala数据类型仍然遵守低精度的值类型向高精度值的自动转换
4)Scala中的StringOps是对Java中的String增强
5)Unit :对应Java中的void，用于方法返回值的位置,表示方法没有返回值。Unit是一个数据类型，只有一个对象就是()。Void不是数据类型，只是一个关键字。
6)Null是一个类型，只有一个对象就是ru1l。它是所有引用类型(AnyRef〉的子类。
7) Nothing，是所有数据类型的子类，主要用在一个函数没有明确返回值时使用，因为这样可以把抛出的返回值，返回给任何的变量或者函数。
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 |
object test03 {
def main(args: Array[String]): Unit = {
//scala中任何代码都会被当做代码块执行，最终将最后一行代码的返回值返回
val i:Int = {
5 + 4
2
6
}
//val unit:Unit= print(i)
//val exception:Nothing = throw new RuntimeException()
val i1 = 5
//Scala各整数类型有固定的表示范围和字段长度，不受具体操作的影响，以保证Scala程序的可移植性
//val i2:Byte = 128//报错
val i2:Byte = 126+1
println(i2)
var i3 = 1
//var i1:Byte = 126 + i3 //因此每一行都是代码块 一行一行编辑 此时不知道i3的值 报错
}
}2.浮点类型
| 数据类型 |
描述 |
| Float [4] |
32 位, IEEE 754标准的单精度浮点数 |
| Double [8] |
64位 IEEE 754标准的双精度浮点数 |
object test04 {
def main(args: Array[String]): Unit = {
var i1:Float = 12.0f
var i2:Double = 12.36
}
}3.字符类型
（1）字符常量是用单引号 ' ' 括起来的单个字符。
（2）\t ：一个制表位，实现对齐的功能
（3）\n ：换行符
（4）\\ ：表示\
（5）\" ：表示"
object test05 {
def main(args: Array[String]): Unit = {
//字符常量是用单引号 ' ' 括起来的单个字符
val a1: Char = 'a' //a
val a2: Char = 97 //a
// \t ：一个制表位，实现对齐的功能
val a3: Char = '\t'
println(a3)
// \n ：换行符
val a4: Char = '\n'
println(a3 + 0) //9
println(a4 + 0) //10
// \\ ：表示\
val a5: Char = '\\'
println(a5 + 0) //92
// \" ：表示"
val a6: Char = '\"'
println(a6 + 0) //34
}
}4.布尔类型
（1）Booolean类型数据只允许取值true和false
（2）boolean类型占1个字节
val bo1: Boolean = true
val bo2: Boolean = false5.Unit类型、Null类型和Nothing类型
| 数据类型 |
描述 |
| Unit |
表示无值，和其他语言中void等同。用作不返回任何结果的方法的结果类型。Unit只有一个 实例值，写成()。 |
| Null |
null , Null 类型只有一个实例值null |
| Nothing |
Nothing类型在Scala的类层级最低端；它是任何其他类型的子类型。 当一个函数，我们确定没有正常的返回值，可以用Nothing来指定返回类型，这样有一个好处，就是我们可以把返回的值（异常）赋给其它的函数或者变量（兼容性） |
Unit：Unit只有一个实例（）
def main(args: Array[String]): Unit = {
val `unit`:Unit = {
1+1
println(1)
}
println(`unit`) //()
//如果标记对象的类型是unit的话,后面有返回值也没法接收
val i:Unit = "hello"
println(i) // Unit虽然是数值类型,但是可以接收引用数据类型,表示不接收返回值
}Null：Null类只有一个实例对象，Null类似于Java中的null引用。Null可以赋值给任意引用类型（AnyRef），但是不能赋值给数值类型（AnyVal）
var s:String = "hello"
s = null
println(s) //null
var i2:Int = 5
i2 = null //报错Nothing：可以作为没有正常返回值的方法的返回类型，而且该方法不会正常返回
val value: Nothing = {
println("hello")
1 + 1
throw new RuntimeException()
}六、类型转换
1.数值类型自动转换
当Scala程序在进行赋值或者运算时，精度小的类型自动转换为精度大的数值类型，这个就是自动类型转换（隐式转换）。数据类型按精度（容量）大小排序为：
（1）自动提升原则：有多种类型的数据混合运算时，系统首先自动将所有数据转换成精度大的那种数据类型，然后再进行计算。
（2）把精度大的数值类型赋值给精度小的数值类型时，就会报错，反之就会进行自动类型转换。
（3）（byte，short）和char之间不会相互自动转换，因为byte和short是有符号的数值,而char是无符号的
（4）byte，short，char他们三者可以计算，在计算时首先转换为int类型。
object test07 {
def main(args: Array[String]): Unit = {
//自动提升原则
val num:Double = 1 + 2.0f + 3.65
//把精度大的数值类型赋值给精度小的数值类型时，就会报错，反之就会进行自动类型转换
val num1:Double = 2.0
//num1 = 1 //报错
//（byte，short）和char之间不会相互自动转换
var c:Char = 'a'
//byte，short，char他们三者可以计算，在计算时首先转换为int类型
val a:Short = 20
val b:Byte = 30
println(a+b+c)
}
}2.强制类型转换
自动类型转换的逆过程，将精度大的数值类型转换为精度小的数值类型。
（1）将数据由高精度转换为低精度，就需要使用到强制转换
（2）强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级
val a1:Double = 2.3
println(a1.toInt) //2
println((a1+0.5).toInt) //四舍五入3.数值类型和String类型间转换
（1）基本类型转String类型（语法：将基本类型的值+"" 即可）
（2）String类型转基本数值类型（语法：s1.toInt、s1.toFloat、s1.toDouble、s1.toByte、s1.toLong、s1.toShort）
//基本类型转String类型
val s1:Int = 20
println(s1+"")
val s2: String = s1.toString
//String类型转基本类型
val str1 = "3.14"
val double: Double = str1.toDouble