包,类或对象的成员可以标记访问修饰符private和protected,如果我们不使用这两种关键字,那么访问将被默认设置为public。这些修饰 限制为成员的代码的某些区域访问。要使用访问修饰符,包括它的包,类或对象的成员定义的关键字,我们将在下一节中看到。
私有成员:
私有成员只能看到里面包含的成员定义的类或对象。下面是一个例子:
class Outer {
class Inner {
private def f() { println("f") }
class InnerMost {
f() // OK
}
}
(new Inner).f() // Error: f is not accessible
}
在Scala中,访问 (new Inner).f() 是非法的,因为f被声明为private内部类并且访问不是在内部类内。与此相反,到f第一接入类最内层是确定的,因为该访问包含在类内的主体。 Java将允许这两种访问,因为它可以让其内部类的外部类访问私有成员。
保护成员:
受保护的成员是从该成员定义的类的子类才能访问。下面是一个例子:
package p {
class Super {
protected def f() { println("f") }
}
class Sub extends Super {
f()
}
class Other {
(new Super).f() // Error: f is not accessible
}
}
类分给 f 访问是正常的,因为f被声明为受保护的超类和子类是超级的子类。相比之下,访问 f 在其他是不允许的,因为其他没有从超级继承。在Java中,后者访问将仍然允许的,因为其他的是在同一个包子。
公共成员:
未标示私有或受保护的每一个成员是公开的。不需要明确使用修饰符public。这样的成员可以从任何地方访问。下面是一个例子:
class Outer {
class Inner {
def f() { println("f") }
class InnerMost {
f() // OK
}
}
(new Inner).f() // OK because now f() is public
}
保护范围:
Scala中的访问修饰符可以增加使用修饰符。形式:private[X]或protected[X]的修饰符意味着访问私有或受保护“达到”X,其中X代表了一些封闭的包,类或单个对象。考虑下面的例子:
package society {
package professional {
class Executive {
private[professional] var workDetails = null
private[society] var friends = null
private[this] var secrets = null
def help(another : Executive) {
println(another.workDetails)
println(another.secrets) //ERROR
}
}
}
}
注意,上面的例子中以下几点:
· 变量workDetails将可对任何一类封闭包professional范围内。
· 变量friends 将可对任何一类封闭包society中。
· 变量secrets 将可只在实例方法隐含的对象(this)。
运算符是一个符号,告诉编译器执行特定的数学或逻辑操作。 Scala有丰富的内置运算符,运算符提供了以下类型:
· 算术运算符
· 关系运算符
· 逻辑运算符
· 位运算符
· 赋值运算符
本章将学习研究算术,关系,逻辑,按位,分配赋值和其他运算符。
算术运算符:
Scala语言支持以下算术运算符:
假设变量A=10和变量B=20,则:
运算符 | 描述 | 示例 |
+ | 两个操作数相加 | A + B = 30 |
- | 从第一操作减去第二操作数 | A - B = -10 |
* | 两个操作数相乘 | A * B = 200 |
/ | 通过分子除以分子 | B / A = 2 |
% | 模运算,整数除法后的余数 | B % A = 0 |
关系运算符:
Scala语言支持以下关系运算符
假设变量A=10和变量B=20,则:
运算符 | 描述 | 示例 |
== | 检查两个操作数的值是否相等,如果是的话那么条件为真。 | (A == B) 不为 true. |
!= | 检查两个操作数的值是否相等,如果值不相等,则条件变为真。 | (A != B) 为 true. |
> | 检查左边的操作数的值是否大于右操作数的值,如果是的话那么条件为真。 | (A > B) 不为 true. |
< | 检查左边的操作数的值是否小于右操作数的值,如果是的话那么条件为真。 | (A < B) 为 true. |
>= | 检查左边的操作数的值是否大于或等于右操作数的值,如果是的话那么条件为真。 | (A >= B) 不为 true. |
<= | 检查左边的操作数的值是否小于或等于右操作数的值,如果是的话那么条件为真。 | (A <= B) 为 true. |
逻辑运算符:
Scala语言支持以下逻辑运算符
假设变量A=1和变量B=0,则:
运算符 | 描述 | 示例 |
&& | 所谓逻辑与操作。如果两个操作数为非零则条件为真。 | (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=60和变量B=13,则:
运算符 | 描述 | 示例 |
& | 二进制和运算符副本位的结果,如果它存在于两个操作数。 | (A & B) = 12, 也就是 0000 1100 |
| | 二进制或操作拷贝,如果它存在一个操作数。 | (A | B) = 61, 也就是 0011 1101 |
^ | 二进制异或运算符的副本,如果它被设置在一个操作数而不是两个比特。 | (A ^ B) = 49, 也就是 0011 0001 |
~ | 二进制的补运算符是一元的,具有“翻转”位的效应。 | (~A ) = -61, 也就是 1100 0011在2补码形式,由于一个带符号二进制数。 |
<< | 二进制左移位运算符。左边的操作数的值向左移动由右操作数指定的位数。 | A << 2 = 240, 也就是 1111 0000 |
>> | 二进制向右移位运算符。左边的操作数的值由右操作数指定的位数向右移动。 | A >> 2 = 15, 也就是 1111 |
>>> | 右移补零操作。左边的操作数的值由右操作数指定的位数向右移动,并转移值以零填充。 | A >>>2 = 15 也就是 0000 1111 |
赋值运算符:
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 |
|= | 按位或并赋值运算符 | C |= 2 等同于 C = C | 2 |
Scala的运算符优先级:
运算符优先级决定术语的表达式分组。这会影响一个表达式是如何进行计算。某些运算符的优先级高于其他;例如,乘法运算符的优先级比所述加法运算符优先级更高:
例如X =7 + 3* 2;这里,x 被赋值13,而不是20,因为运算符* 优先级高于+,所以它首先做乘法3 * 2,然后加上7。
这里,具有最高优先级的运算符在表的顶部,那些优先低级排在底部。在一个表达式,优先级高的运算符将首先计算。
分类 | 运算符 | 关联 |
Postfix | () [] | 从左到右 |
Unary | ! ~ | 从右到左 |
Multiplicative | * / % | 从左到右 |
Additive | + - | 从左到右 |
Shift | >> >>> << | 从左到右 |
Relational | > >= < <= | 从左到右 |
Equality | == != | 从左到右 |
Bitwise AND | & | 从左到右 |
Bitwise XOR | ^ | 从左到右 |
Bitwise OR | | | 从左到右 |
Logical AND | && | 从左到右 |
Logical OR | || | 从左到右 |
Assignment | = += -= *= /= %= >>= <<= &= ^= |= | 从右到左 |
Comma | , | 从左到右
from: http://www.yiibai.com/scala/scala_basic_syntax.html |