一:注释
与java一模一样
二:变量和常量
var 变量名 [:变量类型] = 初始值 var i:Int = 10
val 常量名 [:常量类型] = 初始值 val j:Int = 20
1:声明变量时,类型可以省略,编译器自动推导,即类型推导
2:类型确定后,就不能修改,说明 Scala 是强数据类型语言
3:变量声明时,必须要有初始值
4:在声明 定义一个变量时,可以使用var或者val来修饰,var修饰的变量可改变val bob = new Student("bob",23)
bob = new Student("bob",25)会出错,因为bob为val
但是可以用bob.age=25,来进行改变
三:标识符
1:命名规则
Scala中的标识符声明,基本和Java是一致的,但是细节上会有所变化,有以下三种
1:以字母或者下划线开头,后接字母、数字、下划线
2:以操作符开头,且只包含操作符(+ - * / # !等)
3:用反引号'....'包括的任意字符串,即使是Scala关键字也可以
2: 案例实操
package chapter02
object TestName {
def main(args: Array[String]): Unit = {
// 以字母或者下划线开头,后接字母,数字,下划线
var hello:String = ""
var hello12:String = ""
//var 1hello:String = "" //数字不能开头
var h-b:String = "" // 不能有-号,这个在运行代码的时候才会显示出来
var x h:String = ""
var h_4:String = ""
var _ab:String = ""
var Int:String = ""
var _:String = "hello" //单独一个下划线不能作为标识符,因为_被认为是一个方法
println(_)
// 以操作符开头,且只包含操作符(+ - * / # !等)
var +*-/#! :String = ""
var +*-/#!1 :String = "" //以操作符开头,必须都是操作符
// 用反引号'....'包含的任意字符串,即使是Scala关键字也可以
var if :String = "" //不能使用关键字
var `if` : String = "" //用`...`包括的任意字符串,包括关键字
}
}
四:字符串
1:基本语法
1:字符串,通过+号连接
2:printf用法:字符串,通过%传值
3:字符串模板(插值字符串):通过$获取变量值
2:案例实操(代码)
package chapter02
object TestCharType {
def main(args: Array[String]): Unit = {
var name : String = "jinlian"
var age : Int = 18
// 字符串,通过+号连接
println(name + " " + age)
// printf用法字符串,通过%传值
printf("name=%s age=%d\n",name,age)
// 字符串,通过$引入
println(s"${age}岁的${name}在学习")
val num : Double = 2.3456
println(f"The num is ${num}%2.2f") //格式化模板字符串,可以设置保留多少位小数
// 三引号表示字符串,保持多行字符串的原格式输出
val sql = s"""
|select *
|from
| student
|where
| name = ${name}
|and
| age > ${age}
|""".stripMargin
println(sql)
}
}
3:结果
五: 键盘输入
需求:可以从控制台接收用户信息(姓名,年龄,薪水)
六:读写文件
七:数据类型
1:Java基本类型:char、byte、short、int、long、float、double、boolean
2:Java基本类型的包装类:Character、Byte、Short、Integer、Long、Double、Boolean
八:整数和浮点,字符类型
1:整数分类
Byte:-128~127
Short:-32768~32767
Int:-2147483648~2147483647
Long:负的,2的63次方至2的63次方-1
2:实操
package chapter02
object DataType {
def main(args: Array[String]): Unit = {
//1.整数类型
val a1:Byte = 127
val a2:Byte = -128
// val a2:Byte = 128 //ERROR
val a3 = 12 //整数默认类型为int
val a4 = 1232434334343L //超出int范围,加一个L
val b1:Byte = 10
val b2 = 10 + 20
// val b3:Byte = b1 + 20
val b3 : Byte = (b1 + 20).toByte
//浮点
val f1 : Float = 1.2345f
val d1 = 34.313
// 字符类型
val c1:Char = 'a'
println(c1)
val c2:Char = '9'
println(c2)
val c3:Char = '\t'
val c4:Char = '\n'
println("abc" + c3 + "def")
println("abc" + c4 + "def")
//转义字符
val c5 = '\\' //表示\自身
val c6 = '\"' //表示"
println("abc"+c5+"def")
println("abc"+c6+"def")
// ASCII码
val i1:Int = c1
println("i1: " + i1)
val i2:Int =c2
println("i2: " + i2)
// 布尔类型
val isTrue:Boolean = true
println(isTrue)
}
}
九:空类型
1:基本说明
Unit:表示无值,和其他语言中void等同。用作不返回任何结果的方法的结果类型。Unit只有一个实例值,写成()。
Null:null,Null类型只有一个实例值null
Nothing:Nothing类型在Scala的类层级最低端;它是任何其他类型的子类型。 当一个函数,我们确定没有正常的返回值,可以用Nothing来指定返回类型,这样有一个好处,就是我们可以把返回的值(异常)赋给其它的函数或者变量(兼容性)
2:案例
package chapter02
import chapter01.Student
object TestNull {
// 控制Unit
def m1():Unit = {
println("m1被调用执行")
}
val a = m1()
println(a) //这个a输出是()
// 空引用null
val student:Student = new Student("alice",20)
student = null
println(student)
//nothing
def m2(n:Int):Nothing = {
throw new NullPointerException
}
val b = m2(0)
println(b)
}
十:类型转换
精度小的类型自动转换为精度大的数值类型,这个就是自动类型转换,隐式转换。
1:基本说明
1:自动提升原则:有多种类型的数据混合运算时,系统首先自动将所有数据转换成精度大的那种数据类型,然后再进行计算。
2:把精度大的数值类型赋值给精度小的数值类型时,会报错,反正就会自动类型转换
3:(byte、short)和char之间不会相互自动转化
4:byte、short、char他们三种可以计算,在计算时首先转换为int类型
2:案例
package chapter02
object DataTypeConversion {
def main(args: Array[String]): Unit = {
//1
val a1:Byte = 10
val b1:Long = 2353L
val result1 = a1 + b1 //Long类型
val result11:Int = (a1 + b1).toInt //int类型
//2
val a2:Byte = 10
val b2:Int = a2
val c2:Byte = b2 //error
//3
val a3:Byte = 10
val b3:Char = 'b'
// val c3:Byte = b3 //error
val c3:Byte = b3.toByte
println(c3)
//4
val a4:Byte = 12
val b4:Short = 25
val c4:Char = 'c'
// val result4:Short = a4 + b4//error
}
}
十一:强制类型转换
强转可能照成精度的降低,或者数据的溢出
1:高精度转低精度,要使用强制类型转换
val n1:Int = 2.5.toInt
println("n1: " + n1) //结果为2,如果时-2.5的话,取-2,只是取整数部分
2:强转符号只针对于最近的操作数有效,往往会使用小括号提升优先级
val n2:Int = 2.6.toInt + 3.7.toInt
val n3:Int = (2.6 + 3.7).toInt
println("n2: " + n2) //n2是5,实际得到应该是6.3取整为6
println("n3: " + n3)
3:string和数值转换
//数值类型和String类型
//数值转string
val n:Int = 27
val s:String = n + ""
println(s)
//string转数值
val m:Int = "12".toInt
val f:Float = "12.3".toFloat
val f2:Int = "12.3".toInt //这个是有问题的
val f3:Int = "12.3".toDouble.toInt //先转换为double,再转int
4:强转溢出
130源码补码最后八位是:1000 0010
byte截取最后一个字节得到补码,1000 0010,得到对应原码取反加一,符号位不变
即是:1111 1110:-126,则b为-126