本文详细介绍了Scala编程语言的基础知识，包括数据类型、变量、访问修饰符和运算符等内容。涵盖了Scala中整型、浮点型、字符和字符串等数据类型的使用，变量的声明与类型推断，以及算术、关系、逻辑和位运算符的使用。
一、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 | 32 位 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中数据类型都是对象，也就是说scala没有java中的原生类型。在scala是可以对数字等基础类型调用方法。
1、Scala 基础字面量
整型字面量
- 整型字面量用于 Int 类型，如果表示 Long，可以在数字后面添加 L 或者小写 l 作为后缀。eg：0 035 21 0xFFFFFFFF 0777L
浮点型字面量
- 如果浮点数后面有f或者F后缀时，表示这是一个Float类型，否则就是一个Double类型的。eg：0.0 1e30f 3.14159f
布尔型字面量
- 布尔型字面量有 true 和 false。
符号字面量
- 符号字面量被写成： '<标识符> ，这里 <标识符> 可以是任何字母或数字的标识（注意：不能以数字开头）。
- 这种字面量被映射成预定义类scala.Symbol的实例。
- 如： 符号字面量 'x 是表达式 scala.Symbol("x") 的简写，eg：
package scala
final case class Symbol private (name: String) {
override def toString: String = "'" + name
}
字符字面量
- 在 Scala 字符变量使用单引号 ' 来定义，eg：'a' '\u0041' '\n' '\t'
- 其中 \ 表示转义字符，其后可以跟 u0041 数字或者 \r\n 等固定的转义字符。
字符串字面量
- 在 Scala 字符串变量使用双引号 " 来定义，eg："Hello,\nWorld!" "菜鸟教程官网：www.runoob.com"
2、多行字符串的表示方法
多行字符串用三个双引号来表示分隔符，格式为：""" ... """。
eg：
val foo = """菜鸟教程 www.runoob.com www.w3cschool.cc www.runnoob.com 以上三个地址都能访问"""
3、Null 值
- 空值是 scala.Null 类型。
Scala.Null和scala.Nothing是用统一的方式处理Scala面向对象类型系统的某些"边界情况"的特殊类型。
- Null类是null引用对象的类型，它是每个引用类（继承自AnyRef的类）的子类。Null不兼容值类型。
4、Scala 转义字符
下表列出了常见的转义字符：
| 转义字符 | Unicode | 描述 |
|---|---|---|
| \b | \u0008 | 退格(BS) ，将当前位置移到前一列 |
| \t | \u0009 | 水平制表(HT) （跳到下一个TAB位置） |
| \n | \u000a | 换行(LF) ，将当前位置移到下一行开头 |
| \f | \u000c | 换页(FF)，将当前位置移到下页开头 |
| \r | \u000d | 回车(CR) ，将当前位置移到本行开头 |
| \" | \u0022 | 代表一个双引号(")字符 |
| \' | \u0027 | 代表一个单引号（'）字符 |
| \\ | \u005c | 代表一个反斜线字符 '\' |
0 到 255 间的 Unicode 字符可以用一个八进制转义序列来表示，即反斜线‟\‟后跟 最多三个八进制。
在字符或字符串中，反斜线和后面的字符序列不能构成一个合法的转义序列将会导致 编译错误。
eg：
object Test {
def main(args: Array[String]) {
println("Hello\tWorld\n\n" ); //Hello World
}
}
二、Scala 变量
变量是一种使用方便的占位符，用于引用计算机内存地址，变量创建后会占用一定的内存空间。
基于变量的数据类型，操作系统会进行内存分配并且决定什么将被储存在保留内存中。因此，通过给变量分配不同的数据类型，可以在这些变量中存储整数，小数或者字母。
变量声明
- 一、变量： 在程序运行过程中其值可能发生改变的量叫做变量。如：时间，年龄。
- 二、常量 ：在程序运行过程中其值不会发生变化的量叫做常量。如：数值 3，字符'A'。
在 Scala 中，使用关键词 "var" 声明变量，使用关键词 "val" 声明常量。
eg：
var myVar : String = "Foo" var myVar : String = "Too" val myVal : String = "Foo"
变量类型声明
变量的类型在变量名之后等号之前声明。语法格式：
var VariableName : DataType [= Initial Value] 或 val VariableName : DataType [= Initial Value] 变量声明一定需要初始值，否则会报错。
变量类型引用
在 Scala 中声明变量和常量不一定要指明数据类型，在没有指明数据类型的情况下，其数据类型是通过变量或常量的初始值推断出来的。
所以，如果在没有指明数据类型的情况下声明变量或常量必须要给出其初始值，否则将会报错。
var myVar = 10; val myVal = "Hello, Scala!";
以上实例中，myVar 会被推断为 Int 类型，myVal 会被推断为 String 类型。
Scala 多个变量声明
Scala 支持多个变量的声明：
val xmax, ymax = 100 // xmax, ymax都声明为100
如果方法返回值是元组，可以使用 val 来声明一个元组：
scala> val pa = (40,"Foo") pa: (Int, String) = (40,Foo)
三、Scala 访问修饰符
Scala 访问修饰符基本和Java的一样，分别有：private，protected，public。
如果没有指定访问修饰符，默认情况下，Scala 对象的访问级别都是 public。
- Scala 中的 private 限定符，比 Java 更严格，在嵌套类情况下，外层类甚至不能访问被嵌套类的私有成员。
私有(Private)成员
- 用 private 关键字修饰，带有此标记的成员仅在包含了成员定义的类或对象内部可见，同样的规则还适用内部类。
class Outer{
class Inner{
private def f(){println("f")}
class InnerMost{
f() // 正确
}
}
(new Inner).f() //错误
}
(new Inner).f( ) 访问不合法是因为 f 在 Inner 中被声明为 private，而访问不在类 Inner 之内。
但在 InnerMost 里访问 f 就没有问题的，因为这个访问包含在 Inner 类之内。
Java中允许这两种访问，因为它允许外部类访问内部类的私有成员。
保护(Protected)成员
- 在 scala 中，对保护（Protected）成员的访问比 java 更严格。只允许保护成员在定义了该成员的的类的子类中被访问。
- 在java中，用protected关键字修饰的成员，除了定义了该成员的类的子类可以访问，同一个包里的其他类也可以进行访问。
package p{
class Super{
protected def f() {println("f")}
}
class Sub extends Super{
f()
}
class Other{
(new Super).f() //错误
}
}
上例中，Sub 类对 f 的访问没有问题，因为 f 在 Super 中被声明为 protected，而 Sub 是 Super 的子类。相反，Other 对 f 的访问不被允许，因为 other 没有继承自 Super。而后者在 java 里同样被认可，因为 Other 与 Sub 在同一包里。
公共(Public)成员
- Scala中，如果没有指定任何的修饰符，则默认为 public。这样的成员在任何地方都可以被访问。
class Outer {
class Inner {
def f() { println("f") }
class InnerMost {
f() // 正确
}
}
(new Inner).f() // 正确因为 f() 是 public
}
作用域保护
- Scala中，访问修饰符可以通过使用限定词强调。格式为:
private[x] 或 protected[x]
这里的x指代某个所属的包、类或单例对象。如果写成private[x],读作"这个成员除了对[…]中的类或[…]中的包中的类及它们的伴生对像可见外，对其它所有类都是private。
这种技巧在横跨了若干包的大型项目中非常有用，它允许你定义一些在项目的若干子包中可见但对于项目外部的客户却始终不可见的东西。
package bobsrocckets{
package navigation{
private[bobsrockets] class Navigator{
protected[navigation] def useStarChart(){}
class LegOfJourney{
private[Navigator] val distance = 100
}
private[this] var speed = 200
}
}
package launch{
import navigation._
object Vehicle{
private[launch] val guide = new Navigator
}
}
}
上述例子中，类Navigator被标记为private[bobsrockets]就是说这个类对包含在bobsrockets包里的所有的类和对象可见。
比如说，从Vehicle对象里对Navigator的访问是被允许的，因为对象Vehicle包含在包launch中，而launch包在bobsrockets中，相反，所有在包bobsrockets之外的代码都不能访问类Navigator。
四、Scala 运算符
一个运算符是一个符号，用于告诉编译器来执行指定的数学运算和逻辑运算。
Scala 含有丰富的内置运算符，包括以下几种类型：
-
算术运算符
-
关系运算符
-
逻辑运算符
-
位运算符
-
赋值运算符
算术运算符
下表列出了 Scala 支持的算术运算符。
假定变量 A 为 10，B 为 20：
| 运算符 | 描述 | 实例 |
|---|---|---|
| + | 加号 | A + B 运算结果为 30 |
| - | 减号 | A - B 运算结果为 -10 |
| * | 乘号 | A * B 运算结果为 200 |
| / | 除号 | B / A 运算结果为 2 |
| % | 取余 | B % A 运算结果为 0 |
eg：
object Test {
def main(args: Array[String]) {
var a = 10;
var b = 20;
var c = 25;
var d = 25;
println("a + b = " + (a + b) );
println("a - b = " + (a - b) );
println("a * b = " + (a * b) );
println("b / a = " + (b / a) );
println("b % a = " + (b % a) );
println("c % a = " + (c % a) );
}
}
关系运算符
下表列出了 Scala 支持的关系运算符。
假定变量 A 为 10，B 为 20：
| 运算符 | 描述 | 实例 |
|---|---|---|
| == | 等于 | (A == B) 运算结果为 false |
| != | 不等于 | (A != B) 运算结果为 true |
| > | 大于 | (A > B) 运算结果为 false |
| < | 小于 | (A < B) 运算结果为 true |
| >= | 大于等于 | (A >= B) 运算结果为 false |
| <= | 小于等于 | (A <= B) 运算结果为 true |
eg：
object Test {
def main(args: Array[String]) {
var a = 10;
var b = 20;
println("a == b = " + (a == b) );
println("a != b = " + (a != b) );
println("a > b = " + (a > b) );
println("a < b = " + (a < b) );
println("b >= a = " + (b >= a) );
println("b <= a = " + (b <= a) );
}
}
逻辑运算符
下表列出了 Scala 支持的逻辑运算符。
假定变量 A 为 1，B 为 0：
| 运算符 | 描述 | 实例 |
|---|---|---|
| && | 逻辑与 | (A && B) 运算结果为 false |
| || | 逻辑或 | (A || B) 运算结果为 true |
| ! | 逻辑非 | !(A && B) 运算结果为 true |
eg：
object Test {
def main(args: Array[String]) {
var a = true;
var b = false;
println("a && b = " + (a&&b) );
println("a || b = " + (a||b) );
println("!(a && b) = " + !(a && b) );
}
}
结果：
a && b = false
a || b = true
!(a && b) = true
位运算符
位运算符用来对二进制位进行操作，~、&、|、^ 分别为取反，按位与与，按位与或，按位与异或运算，如下表实例：
| p | q | p & q | p | q | p ^ q |
|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 0 |
| 0 | 1 | 0 | 1 | 1 |
| 1 | 1 | 1 | 1 | 0 |
| 1 | 0 | 0 | 1 | 1 |
如果指定 A = 60; 及 B = 13; 两个变量对应的二进制为：
A = 0011 1100 B = 0000 1101 -------位运算---------- A&B = 0000 1100 A|B = 0011 1101 A^B = 0011 0001 ~A = 1100 0011
Scala 中的按位运算法则如下：
| 运算符 | 描述 | 实例 |
|---|---|---|
| & | 按位与运算符 | (a & b) 输出结果 12 ，二进制解释： 0000 1100 |
| | | 按位或运算符 | (a | b) 输出结果 61 ，二进制解释： 0011 1101 |
| ^ | 按位异或运算符 | (a ^ b) 输出结果 49 ，二进制解释： 0011 0001 |
| ~ | 按位取反运算符 | (~a ) 输出结果 -61 ，二进制解释： 1100 0011， 在一个有符号二进制数的补码形式。 |
| << | 左移动运算符 | a << 2 输出结果 240 ，二进制解释： 1111 0000 |
| >> | 右移动运算符 | a >> 2 输出结果 15 ，二进制解释： 0000 1111 |
| >>> | 无符号右移 | A >>>2 输出结果 15, 二进制解释: 0000 1111 |
eg：
object Test {
def main(args: Array[String]) {
var a = 60; /* 60 = 0011 1100 */
var b = 13; /* 13 = 0000 1101 */
var c = 0;
c = a & b; /* 12 = 0000 1100 */
println("a & b = " + c );
c = a | b; /* 61 = 0011 1101 */
println("a | b = " + c );
c = a ^ b; /* 49 = 0011 0001 */
println("a ^ b = " + c );
c = ~a; /* -61 = 1100 0011 */
println("~a = " + c );
c = a << 2; /* 240 = 1111 0000 */
println("a << 2 = " + c );
c = a >> 2; /* 15 = 1111 */
println("a >> 2 = " + c );
c = a >>> 2; /* 15 = 0000 1111 */
println("a >>> 2 = " + c );
}
}
执行以上代码，输出结果为：
$ scalac Test.scala $ scala Test a & b = 12 a | b = 61 a ^ b = 49 ~a = -61 a << 2 = 240 a >> 2 = 15 a >>> 2 = 15
赋值运算符
以下列出了 Scala 语言支持的赋值运算符:
| 运算符 | 描述 | 实例 |
|---|---|---|
| = | 简单的赋值运算，指定右边操作数赋值给左边的操作数。 | C = A + B 将 A + B 的运算结果赋值给 C |
| += | 相加后再赋值，将左右两边的操作数相加后再赋值给左边的操作数。 | C += A 相当于 C = C + A |
| -= | 相减后再赋值，将左右两边的操作数相减后再赋值给左边的操作数。 | C -= A 相当于 C = C - A |
| *= | 相乘后再赋值，将左右两边的操作数相乘后再赋值给左边的操作数。 | C *= A 相当于 C = C * A |
| /= | 相除后再赋值，将左右两边的操作数相除后再赋值给左边的操作数。 | C /= A 相当于 C = C / A |
| %= | 求余后再赋值，将左右两边的操作数求余后再赋值给左边的操作数。 | C %= A is equivalent to C = C % A |
| <<= | 按位左移后再赋值 | C <<= 2 相当于 C = C << 2 |
| >>= | 按位右移后再赋值 | C >>= 2 相当于 C = C >> 2 |
| &= | 按位与运算后赋值 | C &= 2 相当于 C = C & 2 |
| ^= | 按位异或运算符后再赋值 | C ^= 2 相当于 C = C ^ 2 |
| |= | 按位或运算后再赋值 | C |= 2 相当于 C = C | 2 |
eg：
object Test {
def main(args: Array[String]) {
var a = 10;
var b = 20;
var c = 0;
c = a + b;
println("c = a + b = " + c );
c += a ;
println("c += a = " + c );
c -= a ;
println("c -= a = " + c );
c *= a ;
println("c *= a = " + c );
a = 10; c = 15; c /= a ;
println("c /= a = " + c );
a = 10; c = 15; c %= a ;
println("c %= a = " + c );
c <<= 2 ;
println("c <<= 2 = " + c );
c >>= 2 ;
println("c >>= 2 = " + c );
c >>= 2 ;
println("c >>= a = " + c );
c &= a ;
println("c &= 2 = " + c );
c ^= a ;
println("c ^= a = " + c );
c |= a ;
println("c |= a = " + c );
}
}
执行以上代码，输出结果为：
c = a + b = 30
c += a = 40
c -= a = 30
c *= a = 300
c /= a = 1
c %= a = 5
c <<= 2 = 20
c >>= 2 = 5
c >>= a = 1
c &= 2 = 0
c ^= a = 10
c |= a = 10
- 运算符优先级取决于所属的运算符组，它会影响算式的的计算。
查看以下表格，优先级从上到下依次递减，最上面具有最高的优先级，逗号操作符具有最低的优先级。
| 类别 | 运算符 | 关联性 |
|---|---|---|
| 1 | () [] | 左到右 |
| 2 | ! ~ | 右到左 |
| 3 | * / % | 左到右 |
| 4 | + - | 左到右 |
| 5 | >> >>> << | 左到右 |
| 6 | > >= < <= | 左到右 |
| 7 | == != | 左到右 |
| 8 | & | 左到右 |
| 9 | ^ | 左到右 |
| 10 | | | 左到右 |
| 11 | && | 左到右 |
| 12 | || | 左到右 |
| 13 | = += -= *= /= %= >>= <<= &= ^= |= | 右到左 |
| 14 | , | 左到右 |
扫一扫
601
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
