Scala基础2——第2章：变量和数据类型

第2章、变量和数据类型

2.1 注释

​ scala的注释和Java完全一样。

​ （1）单行注释 //

​ （2）多行注释 /* 注释内容 */

​ （3）文档注释

/**
*
* @param args
*/
def main(args:Array[String]):Unit={
    
}

​ 代码规范

​ （1）使用一次tab操作，进行缩进

​ （2）运算符之间，添加一个空格，如2 + 4 * 5

​ （3） 一行最长不超过80个字符。

2.2 变量和常量（重点）

​ 常量：运行时值不会改变的量

​ （1）Java

int a = 10; //定义变量
final int a = 20; //定义常量

​ （2）Scala

var i:Int = 10 //变量用var
val j:Int = 20 //常量用val
// 注意：能用常量的地方不用变量。

​ 注：之所以Scala把Int等类型放到后面，是因为作者认为变量的类型并不重要，是可以通过数值进行推断的。

object Test02_Variable{
    def main(args:Array[String]):Unit={
        
        var a:Int = 10 // 声明变量
        
       	// （1）变量类型是可以省略
        var a1 = 10
        val b1 = 23
        
        // （2）类型确定之后，不能修改。
        // scala是强类型语言
        var a2 = 15 // a2被自动推断为Int
        //a2 = "hello" //!!!报错
        
        // （3）变量声明的时候，必须有初始值
        // var a3:Int //!!!报错
        
        // (4) var是变量，val是常量，不可更改
        a1 = 12
        // b1 = 25 //!!!报错
        
        
        // 常量的引用类型，引用指针不可以变，但是引用的对象可以改变。
        var alice = new Student("alice",20)
        alice = new Student("Alice",20)
        
        val bob = new Student("bob",21)
        //bob = new Student("Bob",21) //!!!报错
        bob.age=24
    }
}

2.3 标识符的命名规范

​ Scala把各种变量、方法、函数等命名的字符都是标识符

​ （1）必须以字母和下划线开头

​ （2）以操作符开头，且只包含操作符（+ - * / # ! 等）

​ 注：之所以可以这么定义，是因为scala是一个彻底的面向对象语言，即使是+ - * / 在scala中也是对象。

​ （3）可以用反引号``包含的任意字符串，通过反引号即使是Scala关键字也可以。

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

object Test03_Identifier{
    def main(args:Array[String]):Unit={
        // 以字母或下划线开头
        val hello:String = ""
        var Hello123 = ""
        var _abc = 123
        // var h-b = 12 //!!报错
        
        //（2）以操作符开头，且只包含操作符
        val -+/% = "hello" //编译通过
        println(-+/%)
        
        //（3）可以用反引号``包含的任意字符串，通过反引号即使是Scala关键字也可以。
        val `if` = "hello"
        println(`if`)
        // hello
        
    }
}

2.4 字符串输出

​ 基本语法

​ （1）字符串，通过+号连接

​ （2）printf用法，通过%传值

​ （3）字符串模板：通过$获取变量值

object Test03{
    def main(args:Array[String]):Unit={
        //  （1）字符串，通过+号连接
        val name:String = "alice"
        val age: Int = 19
       	println(name + " " + age + "岁")
        
        // * 将一个字符串复制多次
        println("hello" * 3)
        // 输出：hellohellohello
        
        // (2) printf用法，字符串，通过%传值
        printf("%s的年龄是%d",name,age)
        
        // （3）字符串模板：通过$获取变量值。
        println(s"${name}的年龄是${age}")
        
        val num:Double = 1.234
        print(f"the num is ${num}%2.2f") // 格式化模板字符串，2.2f表示长度为2，.2表示只保留两位小数
        // 输出：the num is 1.23
        print(raw"the num is ${num}%2.2f")
        // 输出the num is 1.234%2.2f
        
        
        //使用三引号表示字符串，多行字符串
        val sql = s"""
        	|select *
        	|from student
        	| where 
        	|  name = ${name}
        	|""".stripMargin
        println(sql)
        // 输出结果
        //select *
        //from student
        // where
        //  name = zhangsan
    }
}

2.5 键盘输入、文件输入

​ 1）基本语法

​ StdIn.readLine()

​ StdIn.readInt()

​ StdIn.readDouble()

import scala.io.StdIn
object Test05{
    def main(args:Array[String]):Unit = {
        
        println("请输入你的名字")
        var name:String = StdIn.readLine()
        print("请输入年龄")
        val age:Int = StdIn.readInt()
        
        println(s"${name}的年龄是${age}")
    }
}

从文件中读取

import scala.io.Source
import java.io.{File, PrintWriter}
object Test06{
    def main(args:Array[String]):Unit={
        // 从文件读取数据,并打印每一行
        Source.fromFile("a.txt").foreach(print)
         
        // 将数据写入文件
        // scala中并没有提供写入，可以直接java的方法
        val writer = new PrintWriter(new File("D:\\test.txt"))// 定义一个可以写入的对象
        writer.write("hello scala from java...")
        writer.close()
        
    }
}

2.6 数据类型（重点）

​ Java的基本类型：char、byte、short、int、long、float、double、boolean

​ Java引用类型（对象类型）

​ Java基本类型的包装类：Character、Byte、Short、Integer、Long、Float、Double、Boolean

​ 注：Java中基本类型和引用类型没有共同的祖先

​ 注：这因为有Java的基本类型，所以Java没有彻底的面向对象，所以Scala去掉了所有的基本类型

Scala

​ （1）Scala的一切数据都是对象，都是Any的子类

​ （2）Any下有两大分支，分别是AnyVal（对应的基本类型）和AnyRef（对应的引用类型）。

​ （3）AnyVal包含：Double、Float、Long、Int、Short、Byte、Boolean、Unit、Char、StringOps

​ （StringOps对应Java中的string的基本类型）

​ （Unit表示空返回值）

​ （4）AnyRef包含：（Scala collections集合类)、(Other Scala classes其他的类)、（all java classes所有的java类）

​ (5) AnyRef还包含特殊的引用类型：Null、Null是所有引用类的子类。

​ （6）Nothing：是所有数据类的子类，作用：函数没有明确返回值时使用。抛出异常时的返回值。

2.7 整数类型

​ Scala的整数类型用于存放整数

​ Byte 占据1个字节，表示区间[-128,127]

​ Short 占据2个字节，表示区间[-32768,32767]

​ Int 占据4个字节，表示区间[-2147483648,2147483647]

​ Long 占据8个字节

object Test07{
    def main(args:Array[String]):Unit={
        
        val a1:Byte = 127
        val a2:Byte = -128
        //val a2:Byte = 128 // !!!报错
        
        val a3 = 13 // 默认的类型推断为Int
        //val a4 = 123456616516114 //!!!报错
        val a4 = 123456616516114L //表示为Long类型
        //val a5:Long = 123456616516114//!!!报错
        
        val b1:Byte = 10
        val b2 = 10 + 20
        val b2:Byte = 10 + 20 //IDE提示报错，但是是可以运行的。
        
        //val b3:Byte = (b1 + 20) //!!!报错
        val b3:Byte = (b1 + 20).toByte //强制类型转换
        print(b3)
        
        // 浮点类型
        val f1 = 1.123 //类型自动推断为Double
        val f2:Float = 2.345f
    }
}

2.8 浮点类型

​ Float、Double

// 浮点类型
val f1 = 1.123 //类型自动推断为Double
val f2:Float = 2.345f

2.9 字符类型

val c1:Char = 'a'
println(c1)

val c2:Char = '9'
println(c2)

val c3:Char = '\t' // 制表符
val c4:Char = '\n' // 换行符

// 转义字符
val c5 = '\\'  
val c6 = '\''

// 字符变量底层保存为ASCII码
val i1:Int = '9'
val i2:Int = i1 + 1
print(i1)
print(i2)
// 输出结果
// 57

2.10 布尔类型

​ 只有true和false

val isTrue:Boolean = true
val isFalse:Boolean = false

2.11 Unit类型、Null类型和Nothing类型（重点）

数据类型	描述
Unit	与Java中的void等价。
Null	null，Null只有一个实例null
Nothing	Nothing类型在Scala的类的最低端。他是任何类型的子类型。 应用场景：当一个函数出现异常，那就不会有任何返回，则返回Nothing。

// 空类型 Unit
def m1():Unit={
    println("hello")
}
val a = m1()
println(a)
// 输出结果
// hello
// ()

// 空引用Null
//val n:Int = null //!!!报错
var student:Student = new Student("张三",20)
student = null 
print(student)
// 输出结果
// null


// Nothing
// Nothing在抛出异常的时候的返回值
def m2(n:Int):Nothing = {
    throw new NullPointerException
}
val b = m2(0)
print(b)
// 输出结果
// 直接异常，没有输出

// Nothing是任何类的子类
def m2(n:Int):Int = {
    if(n==0)
    	return new NullPointerException // 返回Nothing类
    else
    	return n // 返回Int类
}

2.12 类型转换

2.12.1 数据类型的自动转换

​ Java的隐式类型转换

​ Java的面试题

public static void main(String[] args){
    byte b = 10;
    test(b); // 调用哪个方法？
    char c = 10; 
    test2(c); // 调用哪个方法？
}

public static void test(byte b){
    System.out.println("bbb");
}
public static void test(short b){
    System.out.println("sss");
}
public static void test(char b){
    System.out.println("ccc");
}
public static void test(int b){
    System.out.println("iii");
}

问？test(b)调用哪个方法

答：如果是参数为byte的函数存在，则输出bbb，如果参数为byte的函数不存在，则输出sss，如果参数为short的函数不存在，则输出iii。

问？ char c = 10; test2©调用哪个方法？

答：如果有参数为char的函数存在，则输出ccc，如果参数为char的函数不存在，则输出iii

自动转换的规则

​ （1）自动提示原则，自动将所有数据类型转换成精度大的数据类型

​ （2）精度大的转换为精度小的数据类型，就会报错

​ （3）（byte、short）和char之间不会互相自动转换

​ （4）byte、short、char他们三者可以计算，计算时首先转换为int类型

//（1）自动提示原则，自动将所有数据类型转换成精度大的数据类型
val a1:Byte = 10
val b1:Long = 2355L
val result1:Long = (a1 + b1)
val result2:Int = (a1 + b1.toInt )

//（2）精度大的转换为精度小的数据类型，就会报错
val a2:Byte = 10
val b2:Int = a2
// val c2:Byte = b2//!!!报错


//（3）（byte、short）和char之间不会互相自动转换
val a3:Byte = 10
val b3:Char = 'b' 
// val c3:Byte = b3 //虽然IDE不提示，但是报错
val c3:Byte = b3.toByte 


//（4）byte、short、char他们三者可以计算，计算时首先转换为int类型
val a4:Byte = 12
val b4:Short = 25
val c4:Char = 'c'
val result4:Int =  a4 + b4 
val result44:Int = a4 + b4 + c4
print(result44)

2.12.2 强制类型转换

​ 对于Java的强制类型转换

char c = 'a';
short c2 = (short)c;//强制转换为short

​ Scala的强制类型转换

var num:Int = 2.7.toInt //转换为int类型

//（1）将高精度转换为低精度
val n1:Int = 2.5.toInt
println(s"n1:${n1}")
// 输出结果
// n1:2

// (2)强转的符号只针对最近的操作数有效
val n2:Int = (2.6 + 3.7).toInt
println(n2)
// 输出结果
// 6

2.12.3 数值类型和String之间的转换

// （3）数值类型和String类型的转换
val n :Int = 27
val s:String = n + ""
val s2:String = n.toString

val m:Int = "123".toInt
val f:Float = "12.3".toFloat
val f2:Int = "12.3".toDouble.toInt

面试扩展题

object Test03{
    def main(args:Array[String]):Unit={
        val n:Int = 128
        val b : Byte = n.toByte
        print(b)
    	// 输出结果-128
    }
}

// 强制类型转换为Byte，主要是截取最后一个字节

（1）Int类型占据4个字节，Byte占据1个字节

原码 0000 0000 0000 0000 0000 0000 1000 0000

补码 0000 0000 0000 0000 0000 0000 1000 0000

截取最后一个字节 得到 Byte

得到补码： 1000 0000

对于的十进制为 -128