一、变量和数据类型
1.1 注释
- 和java完全一样
package tiger.scala.chapter02
// 单行注释:可以出现在程序中的任意位置
/*
* 多行注释
*
* */
/**
* 文档注释:只能出现在类和方法上
* @param args
*
* */
object Scala01_TestComm {
}
1.2 变量和常量
1.2.1 基本语法
var 变量名:变量类型 = 值
val 常量名:常量类型 = 值
1.2.2 案例
- 声明变量时,类型可以省略,编译器自动推导,即类型推导
- 类型确定后,就不能修改,说明Scala是强数据类型语言
- 变量声明时,必须要有初始值
- 在声明/定义一个变量时,可以使用var或者val来修饰,var修饰的变量可改变,val修饰的变量不可改
- var修饰的对象引用可以改变,val修饰的对象则不可改变,但对象的状态(值)却是可以改变的。(比如:自定义对象、数组、集合等等)
package tiger.scala.chapter02
import tiger.scala.chapter01.Student
/*
* 变量:在程序执行过程中,其值可以改变
* 常量:在程序执行的过程中,其值不可以改变
* Scala
* 变量
* var 变量名:数据类型 = 值
* var a:Int = 10
* 常量
* val 常量名:数据类型 = 初始值
*
* */
object Scala02_Val {
def main(args: Array[String]): Unit = {
// 声明一个整数类型变量 a,并将10赋值给a
var a:Int = 10
println(a)
// 声明变量时,类型可以省略,编译器自动推导,即类型推导
var b = 20
println(b)
// 类型确定后,就不能修改,说明Scala是强数据类型语言。
// 变量声明时,必须要有初始值
// 在声明/定义一个变量时,可以使用var或者val来修饰,var修饰的变量可改变
// var修饰的对象引用可以改变,val修饰的对象则不可改变,但对象的状态(属性)却是可以改变的(比如:自定义对象,数组,集合等等)。
// 在实际开发中,var和val优先选val
}
}
1.3 标识符的命名规范
1.3.1 命名规则
- Scala对各种变量、方法、函数等命名时使用的字符序列称为标识符。即:凡是自己可以起名字的地方都叫标识符。
- 命名规则:Scala中的标识符声明,基本和Java是一致的,但是细节上会有所变化,有以下四种规则:
- 以字母或者下划线开头,后接字母、数字、下划线
- 以操作符开头,且只包含操作符(+ - * / # !等)
- 用反引号`....`包括的任意字符串,即使是Scala关键字(39个)也可以
1.3.2 案例
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 = "hello" // ok 单独一个下划线不可以作为标识符,因为_被认为是一个方法
println(_)
//(2)以操作符开头,且只包含操作符(+ - * / # !等)
var +*-/#! : String = "" // ok
var +*-/#!1 : String = "" // error 以操作符开头,必须都是操作符
//(3)用反引号`....`包括的任意字符串,即使是Scala关键字(39个)也可以
var if : String = "" // error 不能用关键字
var `if` : String = "" // ok 用反引号`....`包括的任意字符串,包括关键字
}
}
1.4 字符串输出
1.4.1 基本语法
- 字符串,通过+号连接
- printf用法:字符串,通过%传值。类似于c语言中的printf
- 字符串模板(插值字符串):通过$获取变量值
1.4.2 案例
package com.atguigu.chapter02
object TestCharType {
def main(args: Array[String]): Unit = {
var name: String = "jinlian"
var age: Int = 18
//(1)字符串,通过+号连接
println(name + " " + age)
//(2)printf用法字符串,通过%传值。
printf("name=%s age=%d\n", name, age)
//(3)字符串,通过$引用
//多行字符串,在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)
val s2 = s"name=$name"
println(s2)
}
}
1.5 键盘输入
1.5.1 基本语法
StdIn.readLine()、StdIn.readShort()、StdIn.readDouble()
1.5.2 案例
package tiger.scala.chapter02
import scala.io.StdIn
/*
* 获取键盘输入
*
* */
object Scala05_TestStdIn {
def main(args: Array[String]): Unit = {
println("请输入你的名字")
val name: String = StdIn.readLine()
println("请输入你的年龄")
val age: Int = StdIn.readInt()
println(s"欢迎${age}的${name}来到中国")
var a:Null = null
var a1:Null = null
}
}
1.6 数据类型
1.6.1 基本结构
- Scala中一切数据都是对象,都是Any的子类
- Scala中数据类型分为两大类:数值类型(AnyVal)、引用类型(AnyRef),不管是数值类型还是引用类型都是对象
- Scala数据类型仍然遵守,低精度的值类型向高精度值类型,自动转换(隐式转换)
- Scala中的StringOps是对Java中的String增强
- Unit:对应Java中的void,用于方法放回值的位置,表示方法没有返回值。Unit是一个数据类型,只有一个对象就是()。void不是数据类型,只是一个关键字。
- Null是一个类型,只有一个对象就是null。它是所有引用类型(AnyRef)的子类
- Nothing,是所有数据类型的子类,主要用在一个函数没有明确返回值时使用,因为这样我们可以把抛出的返回值,返回给任何变量或者函数
1.6.2 案例
package tiger.scala.chapter02
/*
*
*
* */
object Scala06_DataType {
def main(args: Array[String]): Unit = {
// 整数类型
// 正确
var n1:Byte = 127
var n2:Byte = -128
// 错误
// var n3:Byte = -129
// 在编译的时候会判断数值是否在当前类型表示的范围之内,如果在,底层默认进行转换
var b:Byte = 10 + 20
println(b)
var a = 10L
println(a)
// 字符类型
//(1)字符常量是用单引号 ' ' 括起来的单个字符。
var c1: Char = 'a'
println("c1=" + c1)
//注意:这里涉及自动类型提升,其实编译器可以自定判断是否超出范围,
//不过idea提示报错
// var c2:Char = 'a' + 1
// println(c2)
//
// //(2)\t :一个制表位,实现对齐的功能
// println("姓名\t年龄")
//
// //(3)\n :换行符
// println("西门庆\n潘金莲")
//
// //(4)\\ :表示\
// println("c:\\岛国\\avi")
//
// //(5)\" :表示"
// println("同学们都说:\"大海哥最帅\"")
// println(m1())
// println(m2(2))
}
// 演示Unit
def m1(): Unit = {
println("m1方法被执行了")
}
// 演示Nothing
def m2(n:Int): Nothing = {
if (n == 0) {
throw new NullPointerException
} else {
// 在Scala语言中,Nothing类型表示发生了异常
throw new RuntimeException
}
}
}
1.7 整数类型
1.7.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 |
1.7.2 案例
- Scala各整数类型有固定的表示范围和字段长度,不受具体操作的影响,以保证Scala程序的可移植性。
object TestDataType {
def main(args: Array[String]): Unit = {
// 正确
var n1:Byte = 127
var n2:Byte = -128
// 错误
// var n3:Byte = 128
// var n4:Byte = -129
}
}
- Scala的整型,默认为Int型,声明Long型,须后加‘l’或‘L‘
object TestDataType {
def main(args: Array[String]): Unit = {
var n5 = 10
println(n5)
var n6 = 9223372036854775807L
println(n6)
}
}
- Scala程序中变量常声明为Int型,除非不足以表示大数,才使用Long
1.8 浮点类型
1.8.1 分类
数据类型 | 描述 |
Float [4] | 32 位,IEEE 754标准的单精度浮点数 |
Double [8] | 64位,IEEE 754标准的双精度浮点数 |
1.8.2 案例
-
Scala的浮点型常量默认为Double型,声明Float型常量,须后加‘f’或‘F’。
object TestDataType {
def main(args: Array[String]): Unit = {
// 建议,在开发中需要高精度小数时,请选择Double
var n7 = 2.2345678912f
var n8 = 2.2345678912
println("n7=" + n7)
println("n8=" + n8)
}
}
1.9 字符类型
1.9.1 基本说明
- 字符类型可以表示单个字符,字符类型是Char。
1.9.2 案例
- 字符常量是用单引号 ' ' 括起来的单个字符。
- \t :一个制表位,实现对齐的功能
- \n :换行符
- \\ :表示\
- \" :表示"
object TestCharType {
def main(args: Array[String]): Unit = {
//(1)字符常量是用单引号 ' ' 括起来的单个字符。
var c1: Char = 'a'
println("c1=" + c1)
//注意:这里涉及自动类型提升,其实编译器可以自定判断是否超出范围,
//不过idea提示报错
var c2:Char = 'a' + 1
println(c2)
//(2)\t :一个制表位,实现对齐的功能
println("姓名\t年龄")
//(3)\n :换行符
println("西门庆\n潘金莲")
//(4)\\ :表示\
println("c:\\hhh\\avi")
//(5)\" :表示"
println("同学们都说:\"hhh最帅\"")
}
}
1.10 布尔类型
1.10.1 基本说明
- 布尔类型也叫Boolean类型,Booolean类型数据只允许取值true和false
- boolean类型占1个字节。
1.10.2 案例
object TestBooleanType {
def main(args: Array[String]): Unit = {
var isResult : Boolean = false
var isResult2 : Boolean = true
}
}
1.11 Unit类型、Null类型和Nothing类型
1.11.1 基本说明
数据类型 | 描述 |
Unit | 表示无值,和其他语言中void等同。用作不返回任何结果的方法的结果类型。Unit只有一个实例值,写成()。 |
Null | null , Null 类型只有一个实例值null |
Nothing | Nothing类型在Scala的类层级最低端;它是任何其他类型的子类型。 当一个函数,我们确定没有正常的返回值,可以用Nothing来指定返回类型,这样有一个好处,就是我们可以把返回的值(异常)赋给其它的函数或者变量(兼容性) |
1.11.2 案例
- Unit类型用来标识过程,也就是没有明确返回值的函数。相当于Java中的void,Unit只有一个实例——( ),这个实例也没有实质意义
object TestSpecialType {
def main(args: Array[String]): Unit = {
def sayOk : Unit = {// unit表示没有返回值,即void
}
println(sayOk)
}
}
- Null类只有一个实例对象,Null类似于Java中的null引用。Null可以赋值给任意引用类型(AnyRef),但是不能赋值给值类型(AnyVal)
object TestDataType {
def main(args: Array[String]): Unit = {
//null可以赋值给任意引用类型(AnyRef),但是不能赋值给值类型(AnyVal)
var cat = new Cat();
cat = null // 正确
var n1: Int = null // 错误
println("n1:" + n1)
}
}
class Cat {
}
- Nothing,可以作为没有正常返回值的方法的返回类型,非常直观的告诉你这个方法不会正常返回,而且由于Nothing是其他任意类型的子类,他还能跟要求返回值的方法兼容。
object TestSpecialType {
def main(args: Array[String]): Unit = {
def test() : Nothing={
throw new Exception()
}
test
}
}
1.12 类型转换
1.12.1 数值类型自动转换
-
当Scala程序在进行赋值或者运算时,精度小的类型自动转换为精度大的数值类型,这个就是自动类型转换(隐式转换)。数据类型按精度(容量)大小排序为:
- 基本说明
- 自动提升原则:有多种类型的数据混合运算时,系统首先自动将所有数据转换成精度大的那种数据类型,然后再进行计算。
- 把精度大的数值类型赋值给精度小的数值类型时,就会报错,反之就会进行自动类型转换。
- (byte,short)和char之间不会相互自动转换。
- byte,short,char他们三者可以计算,在计算时首先转换为int类型。
1.12.2 隐式类型转换案例
object TestValueTransfer {
def main(args: Array[String]): Unit = {
//(1)自动提升原则:有多种类型的数据混合运算时,系统首先自动将所有数据转换成精度大的那种数值类型,然后再进行计算。
var n = 1 + 2.0
println(n) // n 就是Double
//(2)把精度大的数值类型赋值给精度小的数值类型时,就会报错,反之就会进行自动类型转换。
var n2 : Double= 1.0
//var n3 : Int = n2 //错误,原因不能把高精度的数据直接赋值和低精度。
//(3)(byte,short)和char之间不会相互自动转换。
var n4 : Byte = 1
//var c1 : 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 //错误
}
1.12.3 强制类型转换
- 基本说明
-
自动类型转换的逆过程,将精度大的数值类型转换为精度小的数值类型。使用时要加上强制转函数,但可能造成精度降低或溢出,格外要注意。
-
1.12.4 强制类型转换案例
- 将数据由高精度转换为低精度,就需要使用到强制转换
- 强转符号只针对于最近的操作数有效,往往会使用小括号提升优先级
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)
}
}
1.12.5 数值类型和String类型间转换
- 基本说明
-
在程序开发中,我们经常需要将基本数值类型转成String类型。或者将String类型转成基本数值类型。
-
1.12.6 数值类型和String类型间转换案例
- 基本类型转String类型(语法:将基本类型的值+"" 即可)
- String类型转基本数值类型(语法:s1.toInt、s1.toFloat、s1.toDouble、s1.toByte、s1.toLong、s1.toShort)
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
}
}
- 注意
-
在将String类型转成基本数值类型时,要确保String类型能够转成有效的数据,比如我们可以把"123",转成一个整数,但是不能把"hello"转成一个整数。
-
二、运算符
2.1 算数运算符
2.1.1 基本语法
运算符 | 运算 | 范例 | 结果 |
+ | 正号 | +3 | 3 |
- | 负号 | b=4; -b | -4 |
+ | 加 | 5+5 | 10 |
- | 减 | 6-4 | 2 |
* | 乘 | 3*4 | 12 |
/ | 除 | 5/5 | 1 |
% | 取模(取余) | 7%5 | 2 |
+ | 字符串相加 | “He”+”llo” | “Hello” |
- 对于除号“/”,它的整数除和小数除是有区别的:整数之间做除法时,只保留整数部分而舍弃小数部分。
- 对一个数取模a%b,和Java的取模规则一样。
2.1.2 案例
object TestArithmetic {
def main(args: Array[String]): Unit = {
//(1)对于除号“/”,它的整数除和小数除是有区别的:整数之间做除法时,只保留整数部分而舍弃小数部分。
var r1: Int = 10 / 3 // 3
println("r1=" + r1)
var r2: Double = 10 / 3 // 3.0
println("r2=" + r2)
var r3: Double = 10.0 / 3 // 3.3333
println("r3=" + r3)
println("r3=" + r3.formatted("%.2f")) // 含义:保留小数点2位,使用四舍五入
//(2)对一个数取模a%b,和Java的取模规则一样。
var r4 = 10 % 3 // 1
println("r4=" + r4)
}
}
2.2 关系运算符
2.2.1 基本语法
运算符 | 运算 | 范例 | 结果 |
== | 相等于 | 4==3 | false |
!= | 不等于 | 4!=3 | true |
< | 小于 | 4<3 | false |
> | 大于 | 4>3 | true |
<= | 小于等于 | 4<=3 | false |
>= | 大于等于 | 4>=3 | true |
2.2.2 案例
- 案例一
object TestRelation {
def main(args: Array[String]): Unit = {
// 测试:>、>=、<=、<、==、!=
var a: Int = 2
var b: Int = 1
println(a > b) // true
println(a >= b) // true
println(a <= b) // false
println(a < b) // false
println("a==b" + (a == b)) // false
println(a != b) // true
}
}
- 关于Scala中的==与equals
package tiger.scala.chapter02
object Scala09_Operator {
def main(args: Array[String]): Unit = {
// 比较运算符
/*
* Scala
* ==和equals功能一样,比较的是内容是否相等,底层调用的是equals
*
* */
var s1:String = new String("abc")
var s2:String = "abc"
println(s1 == s2) // true
println(s1.equals(s2)) // true
println(s1.eq(s2)) // 比较地址
var b:Int = 10
b += 1 // 在java语言中,+=运算符可以自动进行强转,但是在scala语言中,+=底层不会自动进行强转
println(b)
// println(10 toString)
}
}
2.3 逻辑运算符
2.3.1 基本语法
-
假定:变量A为true,B为false
运算符 | 描述 | 实例 |
&& | 逻辑与 | (A && B) 运算结果为 false |
|| | 逻辑或 | (A || B) 运算结果为 true |
! | 逻辑非 | !(A && B) 运算结果为 true |
2.3.2 案例
object TestLogic {
def main(args: Array[String]): Unit = {
// 测试:&&、||、!
var a = true
var b = false
println("a&&b=" + (a && b)) // a&&b=false
println("a||b=" + (a || b)) // a||b=true
println("!(a&&b)=" + (!(a && b))) // !(a&&b)=true
}
}
2.4 赋值运算符
2.4.1 基本语法
运算符 | 描述 | 实例 |
= | 简单的赋值运算符,将一个表达式的值赋给一个左值 | C = A + B 将 A + B 表达式结果赋值给 C |
+= | 相加后再赋值 | C += A 等于 C = C + A |
-= | 相减后再赋值 | C -= A 等于 C = C - A |
*= | 相乘后再赋值 | C *= A 等于 C = C * A |
/= | 相除后再赋值 | C /= A 等于 C = C / A |
%= | 求余后再赋值 | C %= A 等于 C = C % A |
<<= | 左移后赋值 | C <<= 2等于 C = C << 2 |
>>= | 右移后赋值 | C >>= 2 等于 C = C >> 2 |
&= | 按位与后赋值 | C &= 2 等于 C = C & 2 |
^= | 按位异或后赋值 | C ^= 2 等于 C = C ^ 2 |
|= | 按位或后赋值 | C |= 2 等于 C = C | 2 |
-
注意:Scala中没有++、--操作符,可以通过+=、-=来实现同样的效果;
2.4.2 案例
object TestAssignment {
def main(args: Array[String]): Unit = {
var r1 = 10
r1 += 1 // 没有++
r1 -= 2 // 没有--
}
}
2.5 位运算符
2.5.1 基本语法
- 下表中变量 a 为 60,b 为 13。
运算符 | 描述 | 实例 |
& | 按位与运算符 | (a & b) 输出结果 12 ,二进制解释: 0000 1100 |
| | 按位或运算符 | (a | b) 输出结果 61 ,二进制解释: 0011 1101 |
^ | 按位异或运算符 | (a ^ b) 输出结果 49 ,二进制解释: 0011 0001 |
~ | 按位取反运算符 | (~a ) 输出结果 -61 ,二进制解释: 1100 0011, 在一个有符号二进制数的补码形式。 |
<< | 左移动运算符 | a << 2 输出结果 240 ,二进制解释: 0011 0000 |
>> | 右移动运算符 | a >> 2 输出结果 15 ,二进制解释: 0000 1111 |
>>> | 无符号右移 | a >>>2 输出结果 15, 二进制解释: 0000 1111 |
2.5.2 案例
object TestPosition {
def main(args: Array[String]): Unit = {
// 测试:1000 << 1 =>10000
var n1 :Int =8
n1 = n1 << 1
println(n1)
}
}
2.6 Scala运算符本质
- 在Scala中其实是没有运算符的,所有运算符都是方法。
- 如果函数参数只有一个,或者没有参数,()可以省略
object TestOpt {
def main(args: Array[String]): Unit = {
// 标准的加法运算
val i:Int = 1.+(1)
// (1)当调用对象的方法时,.可以省略
val j:Int = 1 + (1)
// (2)如果函数参数只有一个,或者没有参数,()可以省略
val k:Int = 1 + 1
println(1.toString())
println(1 toString())
println(1 toString)
}
}