第2章 Scala变量和数据类型
第2章 变量和数据类型
2.1 注释
Scala注释使用和Java完全一样。注释是一个程序员必须要具有的良好编程习惯。将自己的思想通过注释先整理出来，再用代码去体现。
2.1.1 单行注释
// 单行注释
2.1.2 多行注释
/*
多行注释
*/
2.1.3 文档注释
/**
文档注释
*/
2.2 变量
变量是一种使用方便的占位符，用于引用计算机内存地址，变量创建后会占用一定的内存空间。基于变量的数据类型，操作系统会进行内存分配并且决定什么将被储存在保留内存中。因此，通过给变量分配不同的数据类型，你可以在这些变量中存储整数，小数或者字母。
2.2.1 语法声明
变量的类型在变量名之后等号之前声明。
scala中变量声明(1) => var 变量名 : 变量的类型 = 变量的值
scala中变量声明(2) => val 变量名 : 变量的类型 = 变量的值
object Scala02_Var {
def main(args: Array[String]): Unit = {
// TODO 变量
// scala中变量声明(1) => var 变量名 : 变量的类型 = 变量的值
var name1 : String = "zhangsan"
// scala中变量声明(2) => val 变量名 : 变量的类型 = 变量的值
val name : String = "lisi"
println(name)
}
}
变量的类型如果能够通过变量值推断出来，那么可以省略类型声明，这里的省略，并不是不声明，而是由Scala编译器在编译时自动声明编译的。
def main(args: Array[String]): Unit = {
// TODO 变量
// 强类型的语言中，类型的声明应该前后统一，如果我明确的知道变量的取值是多少，那么变量的类型就确定了。
// 马丁说：我能猜出来的语法，你不要写了，我帮你。
// 能够通过取值推断变量的类型，那么变量类型可以省略
// 如果使用多态，那么类型不能省略
var name : String = "zhangsan"
var name1 : Object = "lisi"
println(name1)
}
2.2.2 变量初始化
Java语法中变量在使用前进行初始化就可以，但是Scala语法中是不允许的，必须显示进行初始化操作。
object Scala02_Var_2 {
def main(args: Array[String]): Unit = {
// TODO 变量
// scala中声明变量一定要初始化
val name : String = "123"
}
}
2.2.3 可变变量var
值可以改变的变量，称之为可变变量，但是变量类型无法发生改变, Scala中可变变量使用关键字var进行声明
object ScalaVariable {
def main(args: Array[String]): Unit = {
// 用户名称
var username : String = "zhangsan"
username = "lisi" // OK
username = true // Error
}
}
2.2.4 不可变变量val
值一旦初始化后无法改变的变量，称之为不可变变量。Scala中不可变变量使用关键字val进行声明, 类似于Java语言中的final关键字
object ScalaVariable {
def main(args: Array[String]): Unit = {
// 用户名称
val username : String = "zhangsan"
username = "lisi" // Error
username = true // Error
}
}
思考两个问题：
- val和var两个修饰符，哪一个会推荐使用？
- Java中的字符串为何称之为不可变字符串？
2.3 标识符
Scala 可以使用两种形式的标志符，字符数字和符号。
- 字符数字使用字母或是下划线开头，后面可以接字母或是数字，符号" " 在 S c a l a 中 也 看 作 为 字 母 。 然 而 以 " "在 Scala 中也看作为字母。然而以" "在Scala中也看作为字母。然而以"“开头的标识符为保留的 Scala 编译器产生的标志符使用，应用程序应该避免使用”$"开始的标识符，以免造成冲突。
- Scala 的命名规范采用和 Java 类似的 camel 命名规范，首字符小写，比如 toString。类名的首字符还是使用大写。此外也应该避免使用以下划线结尾的标志符以避免冲突。
- Scala 内部实现时会使用转义的标志符，比如:-> 使用 c o l o n colon colonminus$greater 来表示这个符号。
// 和Java一样的标识符命名规则
val name = "zhangsan" // OK
val name1 = "zhangsan0" // OK
//val 1name = "zhangsan0" // Error
val name$ = "zhangsan1" // OK
val $name = "zhangsan2" // OK
val name_ = "zhangsan3" // OK
val _name = "zhangsan4" // OK
val $ = "zhangsan5" // OK
val _ = "zhangsan6" // OK
//val 1 = "zhangsan6" // Error
//val true = "zhangsan6" // Error
// 和Java不一样的标识符命名规则
val + = "lisi" // OK
val - = "lisi" // OK
val = "lisi" // OK
val / = "lisi" // OK
val ! = "lisi" // OK
//val @ = "lisi" // Error
val @@ = "lisi" // OK
//val # = "lisi" // Error
val ## = "lisi" // OK
val % = "lisi" // OK
val ^ = "lisi" // OK
val & = "lisi" // OK
//val ( = "lisi" // Error
//val ( = "lisi" // Error
//val ) = "lisi" // Error
//val = = "lisi" // Error
val == = "lisi" // OK
//val [ = "lisi" // Error
//val ] = "lisi" // Error
//val : = "lisi" // Error
val :: = "lisi" // OK
//val ; = "lisi" // Error
//val ' = "lisi" // Error
//val " = "lisi" // Error
val "" = "lisi" // OK
val < = "lisi" // OK
val > = "lisi" // OK
val ? = "lisi" // OK
val | = "lisi" // OK
val = "lisi" // OK
//val ` = "lisi" // Error
val ~ = "lisi" // OK
val :-> = "wangwu" // OK
val :-< = "wangwu" // OK
// 切记，能声明和能使用是两回事
Scala 中的标识符也不能是关键字或保留字，那么Scala中有多少关键字或保留字呢？
思考两个问题：
-
如何在Java语言中访问Scala对象？
-
如果变量就想使用特定含义的关键字怎么办？
def main(args: Array[String]): Unit = { val `private` = "私有的" println(`private`) Thread.`yield`() }
2.4 字符串
在 Scala 中，字符串的类型实际上就是 Java中的 String类，它本身是没有 String 类的。
在 Scala 中，String 是一个不可变的字符串对象，所以该对象不可被修改。这就意味着你如果修改字符串就会产生一个新的字符串对象。
object ScalaString {
def main(args: Array[String]): Unit = {
val name : String = "scala"
val subname : String = name.substring(0,2)
}
}
2.4.1 字符串连接
object ScalaString {
def main(args: Array[String]): Unit = {
// 字符串连接
println("Hello " + name)
}
}
2.4.2 传值字符串
object ScalaString {
def main(args: Array[String]): Unit = {
// 传值字符串(格式化字符串)
printf("name=%s\n", name)
}
}
2.4.3 插值字符串
object ScalaString {
def main(args: Array[String]): Unit = {
// 插值字符串
// 将变量值插入到字符串
println(s"name=${name}")
}
}
2.4.4 多行字符串
val sql = "select id from (select from t_user where id = 1 order by id desc) a group by id"
val sql1 =
"""
| select
| id
| from
| (
| select
|
| from t_user
| where id = 1
| order by id desc
|
| ) a
| group by id
|
|""".stripMargin
2.5 输入输出
2.5.1 输入
- 从屏幕（控制台）中获取输入
object ScalaIn {
def main(args: Array[String]): Unit = {
// 标准化屏幕输入
val age : Int = scala.io.StdIn.readInt()
println(age)
}
}
- 从文件中获取输入
object Scala05_IO {
def main(args: Array[String]): Unit = {
// TODO IO
// read - 控制台
val line: String = StdIn.readLine()
println(line)
// 从文件中获取输入
// IDEA中基准路径为项目的根路径
val source: BufferedSource = Source.fromFile("data/word.txt")
val strings: Iterator[String] = source.getLines()
while ( strings.hasNext ) {
println(strings.next())
}
source.close()
}
}
2.5.2 输出
Scala进行文件写操作，用的都是 java中的I/O类
object ScalaOut {
def main(args: Array[String]): Unit = {
val writer = new PrintWriter(new File("output/test.txt" ))
writer.write("Hello Scala")
writer.close()
}
}
2.5.3 网络
Scala进行网络数据交互时，采用的也依然是 java中的I/O类
object Scala06_Master {
def main(args: Array[String]): Unit = {
// TODO 连接服务器
val client = new Socket("localhost", 9999)
val out: OutputStream = client.getOutputStream
out.write(300)
out.flush()
out.close()
println("客户端向服务器发送数据 ：1")
client.close
}
}
object Scala06_Slaver {
def main(args: Array[String]): Unit = {
// TODO 启动服务器
val server = new ServerSocket(9999)
println("服务器已经启动，等待客户端的连接。。。")
val client: Socket = server.accept()
val in: InputStream = client.getInputStream
val i: Int = in.read()
println("从客户端接收的数据为 " + i)
in.close()
client.close()
server.close()
}
}
思考一个问题：java的序列化怎么回事？
-
java将内存中的对象存储到磁盘文件中，要求对象必须实现可序列化接口
-
在网络中想要传递对象，这个对象需要序列化。
object Scala06_Master_Object {
def main(args: Array[String]): Unit = {
// TODO 连接服务器
val client = new Socket("localhost", 9999)
val user = new User()
val objOut = new ObjectOutputStream(client.getOutputStream)
objOut.writeObject(user)
objOut.flush()
objOut.close()
println("客户端向服务器发送数据 ：1")
client.close
}
}
object Scala06_Slaver_Object {
def main(args: Array[String]): Unit = {
// TODO 启动服务器
val server = new ServerSocket(9999)
println("服务器已经启动，等待客户端的连接。。。")
val client: Socket = server.accept()
val objIn = new ObjectInputStream(client.getInputStream)
val user = objIn.readObject()
println("从客户端接收的数据为 " + user)
objIn.close()
client.close()
server.close()
}
}
User.java
public class User implements Serializable {
public static int age;
static {
age = 30;
System.out.println("user static init...");
}
@Override
public String toString() {
return "User["+age+"]";
}
public static String test() {
//int i = 10 / 0;
return "abc";
}
}
2.6 数据类型
Scala与Java有着相同的数据类型，但是又有不一样的地方
2.6.1 Java数据类型
Java的数据类型包含基本类型和引用类型
- 基本类型：byte,short,char,int,long,float,double,boolean
- 引用类型：Object，数组，字符串，包装类，集合，POJO对象等
2.6.2 Scala数据类型
Scala是完全面向对象的语言，所以不存在基本数据类型的概念，有的只是任意值对象类型（AnyVal）和任意引用对象类型(AnyRef)
Scala 与 Java有着相同的数据类型，下表列出了 Scala 支持的数据类型：
| 数据类型 | 描述 |
|---|---|
| Byte | 8位有符号补码整数。数值区间为 -128 到 127 |
| Short | 16位有符号补码整数。数值区间为 -32768 到 32767 |
| Int | 32位有符号补码整数。数值区间为 -2147483648 到 2147483647 |
| Long | 64位有符号补码整数。数值区间为 -9223372036854775808 到 9223372036854775807 |
| Float | 32 位, IEEE 754 标准的单精度浮点数 |
| Double | 64 位 IEEE 754 标准的双精度浮点数 |
| Char | 16位无符号Unicode字符, 区间值为 U+0000 到 U+FFFF |
| String | 字符序列 |
| Boolean | true或false |
| Unit | 表示无值，和其他语言中void等同。用作不返回任何结果的方法的结果类型。Unit只有一个实例值，写成()。 |
| Null | null 或空引用 |
| Nothing | Nothing类型在Scala的类层级的最底端；它是任何其他类型的子类型。 |
| Any | Any是所有其他类的超类 |
| AnyRef | AnyRef类是Scala里所有引用类(reference class)的基类 |
上表中列出的数据类型都是对象，也就是说scala没有java中的原生类型。在scala是可以对数字等基础类型调用方法的。
object Scala07_DataType {
def main(args: Array[String]): Unit = {
// TODO 数据类型
// 任意值类型
val b : Byte = 20
val s : Short = 20
val c : Char = 'a'
val i : Int = 20
val lon : Long = 20
val f : Float = 20.0F
val d : Double = 20.0
val flg : Boolean = true
val u : Unit = test() // Unit是一个类型，这个类型只有一个对象，打印就是小括号
println(u)
}
def test(): Unit = {
}
}
引用数据类型
object Scala07_DataType_1 {
def main(args: Array[String]): Unit = {
// TODO 数据类型
val list : AnyRef = List(1,2,3,4)
val obj : AnyRef = new User()
val obj1 : AnyRef = Scala07_DataType_1
println(list)
println(obj)
println(obj1)
}
}
Nothing
object Scala07_DataType_4 {
def main(args: Array[String]): Unit = {
// Nothing是scala语言中特殊的类型，用于统一方法的异常和正常的返回
}
def test(): Nothing = {
throw new Exception()
}
def test1(): String = {
throw new Exception()
}
}
2.7 类型转换
2.7.1 自动类型转化（隐式转换）
object ScalaDataType {
def main(args: Array[String]): Unit = {
val b : Byte = 10
val s : Short = b
val i : Int = s
val lon : Long = i
}
}
思考一个问题：如下代码是否正确？
val c : Char = 'A' + 1
println(c)
2.7.2 强制类型转化
- Java语言
int a = 10
byte b = (byte)a
- Scala语言
var a : Int = 10
Var b : Byte = a.toByte
// 基本上Scala的AnyVal类型之间都提供了相应转换的方法。
2.7.3 字符串类型转化
scala是完全面向对象的语言，所有的类型都提供了toString方法，可以直接转换为字符串
lon.toString
任意类型都提供了和字符串进行拼接的方法
val i = 10
val s = "hello " + i
尚硅谷2022Java大数据线下面授班 完结
链接: https://pan.baidu.com/s/1vcN1-S5st3azs_VRmxXMAg 提取码: s3vj
失效加V：x923713
QQ交流群 欢迎加入690763341
