Scala学习笔记Day-2

dr20 · 发表于 2021-12-1 20:25

本帖最后由 dr20 于 2021-12-2 20:19 编辑

Scala 包

定义包

Scala 使用 package 关键字定义包，在Scala将代码定义到某个包中有两种方式：

第一种方法和 Java 一样，在文件的头定义包名，这种方法就后续所有代码都放在该包中。比如：

package com.runoob
class HelloWorld

第二种方法有些类似 C#，如：

package com.runoob {
  class HelloWorld 
}

第二种方法，可以在一个文件中定义多个包。

引用

Scala 使用 import 关键字引用包。

import java.awt.Color  // 引入Color

import java.awt._  // 引入包内所有成员

def handler(evt: event.ActionEvent) { // java.awt.event.ActionEvent
  ...  // 因为引入了java.awt，所以可以省去前面的部分
}

import语句可以出现在任何地方，而不是只能在文件顶部。import的效果从开始延伸到语句块的结束。这可以大幅减少名称冲突的可能性。

如果想要引入包中的几个成员，可以使用selector（选取器）：

import java.awt.{Color, Font}

// 重命名成员
import java.util.{HashMap => JavaHashMap}

// 隐藏成员
import java.util.{HashMap => _, _} // 引入了util包的所有成员，但是HashMap被隐藏了

注意：默认情况下，Scala 总会引入 java.lang. 、 scala. 和 Predef._，这里也能解释，为什么以scala开头的包，在使用时都是省去scala.的。

基本语法

Scala区分大小写，所以说标识符Hello和hello在Scala中会有不同的含义
类名：首字母大写，如果需要使用几个单词来构成一个类的名称，每个单词的第一个字母要大写 class MyFirstScalaClass。
方法名：所有的方法名称的第一个字母用小写，如果若干单词被用于构成方法的名称，则每个单词的第一个字母应大写 def myMethodName()。
对象名应与文件名匹配。保存文件时，应该保存它使用的对象名称（记住Scala是区分大小写），并追加".scala"为文件扩展名。（如果文件名和对象名称不匹配，程序将无法编译）。
def main(args: Array[String]) - Scala程序从main()方法开始处理，这是每一个Scala程序的强制程序入口部分。

标识符的命名规范

Scala 对各种变量、方法、函数等命名时使用的字符序列称为标识符。即：凡是自己可以起名字的地方都叫标识符。

以字母或者下划线开头，后接字母、数字、下划线

val hello: String = ""
var Hello123 = ""
val _abc = 123

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

val -+*/% = "Hello"
println(-+*/%)

用反引号`....`包括的任意字符串，即使是 Scala 关键字（39 个）也可以
```
var `if` = "if"
println(`if`)
```

abstract	case	catch	class
def	do	else	extends
false	final	finally	for
forSome	if	implicit	import
lazy	match	new	null
object	override	package	private
protected	return	sealed	super
this	throw	trait	try
true	type	val	var
while	with	yield
-	:	=	=>
<-	<:	<%	>:
#	@

变量和常量

一、变量（variable）：在程序运行过程中其值可能发生改变的量叫做变量。如：时间，年龄。
二、常量（Values）：在程序运行过程中其值不会发生变化的量叫做常量。如：数值 3，字符'A'。

==在 Scala 中，使用关键词 "var" 声明变量，使用关键词 "val" 声明常量。==

声明变量实例如下：

var myVar : String = "Hello"
var myVar : String = "Scala"

以上定义了变量 myVar，我们可以修改它。

声明常量实例如下：

val myVal : String = "hh"
myval = "hello" //报错

以上定义了常量 myVal，它是不能修改的。如果程序尝试修改常量 myVal 的值，程序将会在编译时报错。

代码块（Blocks）

你可以组合几个表达式，并且用{}包围起来。我们称之为代码块（block）。

代码块中最后一个表达式的结果，也正是整个块的结果。

println({
  val x = 1 + 1
  x + 1
}) // 3

变量类型声明

变量的类型在变量名之后等号之前声明。定义变量的类型的语法格式如下：

var VariableName : DataType [=  Initial Value]

或

val VariableName : DataType [=  Initial Value]

==声明变量时，类型可以省略，编译器自动推导，即类型推导==

var age = 20
age = 30

==类型确定后，就不能修改，说明 Scala 是强数据类型语言==

age = "hello" //错误

==变量声明时，必须要有初始值==

var name //错误

==在声明/定义一个变量时，可以使用 var 或者 val 来修饰，var 修饰的变量可改变，val 修饰的变量不可改==

==var 修饰的对象引用可以改变，val 修饰的对象则不可改变，但对象的状态（值）却是可以改变的。（比如：自定义对象、数组、集合等等）==

object TestVar {
         def main(args: Array[String]): Unit = {
         // p1 是 var 修饰的，p1 的属性可以变，而且 p1 本身也可以变
         var p1 = new Person()
         p1.name = "jojo"
         p1 = null
         // p2 是 val 修饰的，那么 p2 本身就不可变（即 p2 的内存地址不能变），但是，p2 的属性是可以变，因为属性并没有用 val 修饰。
         val p2 = new Person()
         p2.name="yoyo"
        // p2 = null // 错误的，因为 p2 是 val 修饰的
         }
}
class Person{
        var name : String = "yoyo"
}

Scala 数据类型

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的类层级的最底端；它是任何其他类型的子类型。当一个函数，我们确认没有正常的返回值，可以用Nothing来指定返回类型，这样有一个好处，就是我们可以把返回的值（异常）赋给其他的函数或者变量（兼容性）
Any	Any是所有其他类的超类
AnyRef	AnyRef类是Scala里所有引用类(reference class)的基类

上表中列出的数据类型都是对象，也就是说scala没有java中的原生类型。在scala是可以对数字等基础类型调用方法的。

Nothing和Null

Nothing是所有类型的子类型，也称为底部类型。没有一个值是Nothing类型的。它的用途之一是给出非正常终止的信号，如抛出异常、程序退出或者一个无限循环（可以理解为它是一个不对值进行定义的表达式的类型，或者是一个不能正常返回的方法）。

Null是所有引用类型的子类型（即AnyRef的任意子类型）。它有一个单例值由关键字null所定义。Null主要是使得Scala满足和其他JVM语言的互操作性，但是几乎不应该在Scala代码中使用。我们将在后面的章节中介绍null的替代方案。

数值类型自动转换

当 Scala 程序在进行赋值或者运算时，精度小的类型自动转换为精度大的数值类型，这个就是自动类型转换（隐式转换）。数据类型按精度（容量）大小排序为：

//（1）自动提升原则：有多种类型的数据混合运算时，系统首先自动将所有数据转换成精度大的那种数据类型，然后再进行计算。

//（2）把精度大的数值类型赋值给精度小的数值类型时，就会报错，反之就会进行自动类型转换。

//（3）(`byte`，`short`)和 `char`之间不会相互自动转换。

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

强制类型转换

基本说明

==自动类型转换的逆过程，将精度大的数值类型转换为精度小的数值类型。使用时要加上强制转函数，但可能造成精度降低或溢出，格外要注意。==

Java : int num = (int)2.5
Scala : var num : Int = 2.7.toInt

回顾：Java数据类型

Java基本类型：char、byte、short、int、long、float、double、boolean
Java引用类型：（对象类型）

由于Java有基本类型，而且基本类型不是真正意义的对象，即使后面产生了基本类型的包装类，但是仍然存在基本数据类型，所以Java语言并不是真正意思的面向对象。

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

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

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

2）Scala中数据类型分为两大类：数值类型（AnyVal）、引用类型（AnyRef），不管是值类型还是引用类型都是

对象。

3）Scala数据类型仍然遵守，低精度的值类型向高精度值类型，自动转换（隐式转换）

4）Scala中的StringOps是对Java中的String增强

5）Unit：对应Java中的void，用于方法返回值的位置，表示方法没有返回值。Unit是一个数据类型，只有一个对象就是()。Void不是数据类型，只是一个关键字

6）Null是一个类型，只有一个对象就是null。它是所有引用类型（AnyRef）的子类。

7）Nothing，是所有数据类型的子类，主要用在一个函数没有明确返回值时使

用，因为这样我们可以把抛出的返回值，返回给任何的变量或者函数。

Scala 转义字符

下表列出了常见的转义字符：

转义字符	Unicode	描述
\b	\u0008	退格(BS) ，将当前位置移到前一列
\t	\u0009	水平制表(HT) （跳到下一个TAB位置）
\n	\u000a	换行(LF) ，将当前位置移到下一行开头
\f	\u000c	换页(FF)，将当前位置移到下页开头
\r	\u000d	回车(CR) ，将当前位置移到本行开头
\"	\u0022	代表一个双引号(")字符
\'	\u0027	代表一个单引号（'）字符
\	\u005c	代表一个反斜线字符 '\'

0 到 255 间的 Unicode 字符可以用一个八进制转义序列来表示，即反斜线‟\‟后跟最多三个八进制。

在字符或字符串中，反斜线和后面的字符序列不能构成一个合法的转义序列将会导致编译错误。

字符串输出

字符串，通过+连接

val name : String = "alice"
val age : Int = 18
println(age + "岁的" + name + "在学习")

printf：字符串，通过%传值
```
printf("%d岁的%s在学习",age, name)
```
字符串模板（插值字符串）：通过$获取变量值
```
println('\n' + s"${age}岁的${name}在学习")
```
*可以将一个字符串复制多次并拼接
```
println((name + '\t') * 3)
```
"""三引号表示字符串，保持多行字符串的原始格式输出
- 多行字符串，在 Scala****中，利用三个双引号包围多行字符串就可以实现。
输入的内容，带有空格、\t 之类，导致每一行的开始位置不能整洁对齐。

应用 scala 的 stripMargin 方法，在 scala 中 stripMargin 默认是|作为连接符,在多行换行的行头前面加一个|符号即可。
```
  val sql = s"""
     |select *
     |from
     |  student
     |where
     |  name = ${name}
     |and
     |  age > ${age}
     |""".stripMargin
  println(sql)
```

键盘输入

在编程中，需要接收用户输入的数据，就可以使用键盘输入语句来获取。

StdIn.readLine()、StdIn.readShort()、StdIn.readDouble()

import scala.io.StdIn
object TestInput {
 def main(args: Array[String]): Unit = {
 // 1 输入姓名
 println("input name:")
 var name = StdIn.readLine()
 // 2 输入年龄
 println("input age:")
 var age = StdIn.readShort()
 // 3 输入薪水
 println("input sal:")
 var sal = StdIn.readDouble()
 // 4 打印
 println("name=" + name)
 println("age=" + age)
 println("sal=" + sal)
         }
}

文件输入输出

// 1、从文件中读取数据
Source.fromFile("../test.txt").foreach(print)

// 2、将数据写入文件
val writer  = new PrintWriter(new File("../output.txt"))
writer.write("hello scala from java writer")
writer.close()

icjhao · 发表于 2021-12-2 07:49

和楼主一起在学Scala，互相学习

帐号		自动登录	找回密码
密码			注册[Register]

[学习记录] Scala学习笔记Day-2