Spark记录-Scala变量/访问修饰符/运算符

变量是保存存储值的内存位置的名称。这意味着当创建变量时，可以在内存中保留一些空间。

根据变量的数据类型，编译器分配内存并决定可以存储在预留内存中的内容。因此，通过为变量分配不同的数据类型，可以在这些变量中存储整数，小数或字符。

变量声明

Scala具有用于声明变量的不同语法。它们可以被定义为值，即常数或变量。 这里，myVar使用关键字var声明。 它是一个可以改变值的变量，这称为可变变量。 以下是使用var关键字定义变量的语法 -

语法

var myVar : String = "Foo"

Scala

下面示例中，myVal使用关键字val声明。它是一个不能被改变的变量，这被称为不可变变量。 以下是使用val关键字定义变量的语法 -

val myVal : String = "Foo"

Scala

可变数据类型

变量的类型在变量名称和等号之前指定。可以通过其数据类型来定义任何类型的Scala变量，如下所示：

val or val VariableName : DataType = [Initial Value]

Scala

如果您没有为变量分配任何初始值，则有效的语法如下：

var myVar :Int;
val myVal :String;

Scala

可变类型推断

当为变量分配初始值时，Scala编译器可以根据分配给它的值来推断变量的类型。这被称为变量类型推断。 因此，可以编写这样的变量声明 -

var myVar = 10;
val myVal = "Hello, Scala!";

Scala

默认情况下，myVar将会被计算推断为Int类型，myVal将计算推断为String类型变量。

多个赋值

Scala支持多个赋值。如果代码块或方法返回一个元组(Tuple - 保持不同类型的对象的集合)，则可以将元组分配给一个val变量。

注：我们将在随后的章节学习元组。

val (myVar1: Int, myVar2: String) = Pair(40, "Foo")

Scala

类型推断得到正确的类型 -

val (myVar1, myVar2) = Pair(40, "Foo")

Scala

示例程序

以下是一个示例程序，用于说明Scala中变量声明的过程。该程序声明了四个变量 - 两个变量用变量声明定义，其余两个变量没有变量声明。

例子

object Demo {
   def main(args: Array[String]) {
      var myVar :Int = 10;
      val myVal :String = "Hello Scala with datatype declaration.";
      var myVar1 = 20;
      val myVal1 = "Hello Scala new without datatype declaration.";

      println(myVar); println(myVal); println(myVar1); 
      println(myVal1);
   }
}

Scala

将上述程序保存在源文件：Demo.scala中，使用以下命令用于编译和执行此程序。

D:softwarescala-2.12.3in>scalac Demo.scala

D:softwarescala-2.12.3in>scala Demo
10
Hello Scala with datatype declaration.
20
Hello Scala new without datatype declaration.

D:softwarescala-2.12.3in>

Shell

变量的作用域

Scala中的变量可以有三个不同的范围，具体取决于它们被使用的位置。它们可以作为字段存在，作为方法参数和局部变量存在。以下是每种类型范围的详细信息。

字段

字段是属于对象的变量。这些字段可以从对象中的每个方法的内部访问。根据字段声明的访问修饰符，也可以在对象外部访问字段。 对象字段可以是可变的和不可变的类型，可以使用var或val来定义。

方法参数

方法参数是在调用该方法时用于传递方法中的值的变量。方法参数只能从方法内部访问，但是如果从方法外部引用了对象，则可以从外部访问传入的对象。方法参数始终是不可变的，由val关键字定义。

局部变量

局部变量是在方法中声明的变量。局部变量只能从方法内部访问，但如果从方法返回，则您创建的对象可能会转义该方法。局部变量可以是可变的和不可变的类型，可以使用var或val定义。

包，类或对象的成员可以使用私有(private)和受保护(protected)的访问修饰符进行标注，如果不使用这两个关键字的其中一个，那么访问将被视为公开(public)的。这些修饰符限制了对某些代码区域的成员访问。

1.算术运算符

下表显示了Scala支持的所有算术运算符。假设变量A的值是10，变量B的值是20，那么 -

运算符	描述	示例
+	将两个操作数相加	A + B = 30
-	从第一个操作数减去第二个操作数	A − B = -10
*	将两个操作数相乘	A * B = 200
/	将第一个操作数除以第二个操作数
%	模数运算符和整数除法后的余数。	B % A = 0
++	递增运算符将整数值增加1。	A++ = 11
--	递减运算符将整数值减1。	A-- = 9

object Demo {
   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) );
   }
}

2.关系运算符

下表显示了Scala语言支持的关系运算符。假设变量A=10，变量B=20，则 -

运算符	描述	示例
==	检查两个操作数的值是否相等。 如果相等，则条件成立。	(A == B)结果为false
!=	检查两个操作数的值是否相等。 如果值不相等，则条件成立。	(A != B) 结果为true
>	检查左操作数的值是否大于右操作数的值。 如果是，则条件成立。	(A > B) 结果为false
<	检查左操作数的值是否小于右操作数的值。 如果是，则条件成立。	(A < B)结果为true
>=	检查左操作数的值是否大于等于右操作数的值。 如果是，则条件成立。	(A >= B) 结果为false
<=	检查左操作数的值是否小于等于右操作数的值。 如果是，则条件成立。	(A <= B)结果为true

object Demo {
   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) );
   }
}

3.逻辑运算符

下表显示了Scala支持的所有逻辑运算符。 假设变量A=1，变量B=0，则 -

运算符	描述	示例
&&	逻辑与运算符。 如果两个操作数都不为零，则条件成立。	(A && B)结果为false
	称为逻辑或运算符。如果两个操作数中的任何一个非零，则条件成立。	(AB)结果为true
!	称为逻辑非运算符，它用于反转其操作数的逻辑状态。如果条件为真，则逻辑NOT运算符将使其结果为false。

object Demo {
   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) );
   }
}

4.按位运算符

按位运算符对位进行操作，并执行逐位运算。 ＆，|和^的真值表如下 -

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

下表列出了Scala支持的按位运算符。假设变量A=60，变量B=13，则 -

运算符	描述	示例
&	如果二进制AND运算符存在于两个操作数中，则二进制AND运算符将对结果复制一位。	(A&B)= 12，即0000 1100
	二进制OR运算符如果存在于任一操作数中，则复制一位。	(AB) = 61, 即 0011 1101
^	二进制XOR操作符复制该位，如果它设置在一个操作数中，而不是两者。	(A ^ B) = 49, 即, 0011 0001
~	二进制补码运算符是一元的，具有“翻转”位的作用。	(~A)= -61，即 1100 0011的补码形式。
<<	二进制左移操作符，左操作数值左移由右操作数指定的位数。	A << 2 = 240 即, 1111 0000
>>	二进制右移操作符，左操作数值被右操作数指定的位移动。	A >> 2 = 15 即,0000 1111

5.赋值运算符

下表列出了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等价于C = C % A
<<=	左移与赋值运算符	C <<= 2等价于C = C << 2
>>=	右移与赋值运算符	C >> = 2等价于C = C >> 2
&=	按位与赋值运算符	C &= 2等价于C = C & 2
^=	按位异或运算符和赋值运算符。	C ^= 2等价于C = C ^ 2
	按位包含OR和赋值运算符。

6.运算符优先级

运算符优先级决定表达式中术语的分组，并决定如何评估计算表达式。 某些运算符的优先级高于其他运营商; 例如，乘法运算符的优先级高于加法运算符，则先要执行乘法运算符的运算。

让我们通过下面的例子了解优先级：

int value = 10 + 20 * 10;

C

value变量计算结果为：210，因为*(乘法运算符)的优先级比+(加法运算符)高，所以在+(加法运算符)之前进行求值。

C语言运算符的优先级和关联性如下：

分类	运算符	关联性
后缀	() [] -> . ++ - -	左到右
一元	+ - ! ~ ++ - - (type)* & sizeof	右到左
乘法	* / %	左到右
加法	+ -	左到右
位移	<< >>	左到右
关系	< <= > >=	左到右
等于	== !=	左到右
按位与	&	左到右
位异或	^	左到右
按位或	/	左到右
逻辑与	&&	左到右
逻辑或	//	左到右
条件	?:	右到左
赋值	= += -= *= /= %=>>= <<= &= ^= /=	右到左
逗号	,	左到右