Scala基础学习笔记：变量 数据类型 基本输入输出

Scala基础学习笔记：变量 数据类型 基本输入输出

1.变量与常量

声明方式

在Scala中 使用val命名常量 使用var*命名变量

在Java中声明变量/常量的方法是 数据类型 名称 = 初始值 （例：int a = 10）

但是在Scala中声明的方法有一点另类

//scala声明方法:   var/val 变量/常量名称 [:数据类型] = 初始值
var n : Int = 10
val a : Double = 1.234

注意事项

（1）注意Scala中var声明变量必须要赋初值 不然会报错

（2）数据类型如果省略则编译器会进行自动推导

var n1 = 1		//自动推导为Int类型
var n2 = 1.234	//自动推导为Double类型

（3）Scala时强数据类型语言，类型确定以后不能修改

（4）不管是常量还是变量，它引用的变量还是可以修改的 但是常量本身不能修改（因为内存地址不能改变）

object Variable {
    def main(args: Array[String]): Unit = {
      val xzx = new Student()
      //stu1用var修饰，则他引用的属性也可以改变
      var stu1 = new Student()
      stu1.name = "ZHT"
    //    stu1.gender = "Female"  报错 因为引用的属性是常量
      stu1 = xzx   //stu1是变量本身也可以改变

      //stu2用val修饰 引用的变量属性能修改 本身不能修改
      val stu2 = new Student()
      stu2.name = "ZHT"
    //  stu2 = xzx  报错 stu2常量
    }
}

class Student{
  var name:String = "XZX"
  val gender :String = "Male"
}

2.基本输入输出

字符串输入输出

Scala类似于C语言 可以使用print和println和print进行输出

print：输出函数 只能有一个参数

println:相当于就是执行print以后再换行

printf: 可以打印出格式化的字符串

输出操作

（1）字符串拼接输出 直接使用加号

var st1: String = "a"
var st2: String = "b"
println(st1+st2)		//输出ab

（2）使用printf格式化输出

var name:String = "xzx"
var age:Int = 20
printf("name=%s age=%d\n",name,age)		//输出xzx 20
println(s"${name}已经${age}岁了")		//输出xzx已经20岁了

使用$获取变量的值 或者类似C语言使用占位符

值得注意的是在字符串前面加上s表示转换为字符串输出 raw表示以原格式输出（引号里面有什么就输出声明） f表示引用内容使用浮点数格式输出

val pi:Double = 3.14159
println(f"The pie is ${pi}%2.2f")	//输出The pie is 3.14
println(raw"The pie is ${pi}%2.2f") //输出The pie is 3.14159%2.2f

（3）多行输出（类似于字符串拼接 非常好用）

使用三引号进行多行输出

//格式为:
//varstr1=
//"""
//|
//|""".stripMargin
val s :String =
"""
    |xzx出门了
    |xzx吃早饭了
    |  前面有俩空格
    |""".stripMargin
println(s)
输出：
//xzx出门了
//xzx吃早饭了
//  前面有俩空格

输入操作

需要引入Scala中的Stdln包

import scala.io.StdIn
//基本方法
StdIn.readLine()
StdIn.readInt()	

//范例
println("请输入您的大名")
valname:String=StdIn.readLine()
println("请输入您的年龄")
valage:Int=StdIn.readInt()

读写文件

(1)读取文件：需要引入io包中的Source

import scala.io.Source
Source.fromFile(url).foreach(print)		//输出每一行

（2）写入文件:

因为Scala可以兼容Java中的包 所以Scala没有自带的文件读取包 直接调用Java的就可以

import java.io.PrintWriter
import java.io.File

val writer = new PrintWriter(new File(url))
writer.write("hello world")
writer.close()

3. 数据类型

终于到了万(fan)总(de)期(yao)待(si)的数据类型了

先回顾一下Java中的8大基本数据类型有：char byte short int long float double boolean

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

Scala和Java创新的区别就是 他的引用类型和基本类型有一个共同的父类Any

让我们来看一下Scala数据类型的脑图

1.Any 是所有数据类型的父类

2.AnyVal是任意值 AnyRef是任意引用

3.虚箭头表示隐式转换（自动类型转换的关系）

4.Null是一个类型 只有一个对象是null 是AnyRef的子类

5.StringOps是一个字符串变量

6.Unit是一个类型 只有一个对象是（） 表示空值

7.Nothing是所有类型的子类 主要用在一个函数没有明确返回值时使用 这样可以作为返回值返回给任意函数

整数类型

数据类型	描述
Byte	8位有符号补码整数。数值区间为 -128 到 127
Short	16位有符号补码整数。数值区间为 -32768 到 32767
Int	32位有符号补码整数。数值区间为 -2147483648 到 2147483647
Long	64位有符号补码整数。数值区间为 -9223372036854775808 到 9223372036854775807

Byte的范围因为存在补码表示 所以只有7位表示数值 最高位表示正负 这样范围变成了-2^7~27-1

再给一组数据：
$$\begin{gathered} 2^7=128 \\ {2}^{10}=1,024 \\ {2}^{15}=32,768 \\ {2}^{31}=2E9 \\ {2}^{63}=9E18 \end{gathered}$$
那么Int能够表示的就是-2^(15)~2(15)-1

浮点数类型

数据类型	描述
Float	32 位, IEEE 754 标准的单精度浮点数
Double	64 位 IEEE 754 标准的双精度浮点数

Var f1 : Float = 1.234f
Var f2 : Double = 1.234  和 var f2 : 1.234是一样的 不加f就是double类型

字符类型

数据类型	描述
Char	16位无符号Unicode字符, 区间值为 U+0000 到 U+FFFF
String	字符序列

val a : Char = 'A'
print(c3)
val b : Char = '0'
print(c4)

val c = '\t'
val d = '\n'
print("abc" + c + "def")
print("abc" + d + "def")
//转义字符\+x(特殊字符)
val c5 = '\\'  //表示\自身
val c6 = '\"'

布尔类型

数据类型	描述
Boolean	true或false

val bool : Boolean = true
println(bool)

空类型

数据类型	描述
Unit	表示无值，和其他语言中void等同。用作不返回任何结果的方法的结果类型。Unit只有一个实例值，写成()。
Null	null 或空引用
Nothing	Nothing类型在Scala的类层级的最底端；它是任何其他类型的子类型。

类型转换

自动转换

转换依照原则：多种类型混合运算的时，先自动转换为精度大的那种数据类型

val a:Byte = 10
val b:Long = 2353
val result : Long = a1+b1

精度大的类型不能赋值给精度小的类型 但是可以向上

val a:Byte = 10
val b:Int = a2

强制类型转换

//1.数值转string
val n: Int = 27
val s : String = n + ""			//这个方法很好用 也可以使用.toString
print(s)

//2.string转数值
val m : Int = "12".toInt
val m1:Int = "12.3".toDouble.toInt

注:当数据类型从高精度转换为低精度时可能会导致数据溢出或者丢失

范例：

object Conversion {
  def main(args: Array[String]): Unit = {
    //下面是一个强制类型转换导致溢出的案例
    val n:Int = 128
      //Byte的范围是-127~128
    val b : Byte = n.toByte
    println(b)
    //输出结果是-128 这就是数据溢出导致的结果
    //是因为转换只截取了后面8位
  }
}

解释上面的类型也很简单

Int类型用4字节表示128 他的补码用二进制表示就是

0000 0000 0000 0000 0000 0000 1000 0000B

因为Byte只用1字节 所以只能截取原数据末尾的1字节作为补码 也就是1000 0000B

最高位是1所以是负数 取回源码就是-128

同理 如果129Int类型转换为Byte的话得到的就是-127