日积月累--Groovy语言规范之操作符_putat()

这篇文章介绍的是Groovy编程语言的操作符,不知为何Groovy将其单独列为了一个部分。
关于操作符的官方文档地址:(http://groovy-lang.org/operators.html)

再次说明一下:本文不是对官方文档的完完整整翻译,而是掺杂了一些个人的理解,使其更加本土化。关于Groovy的一些语法,可参照我的另一篇文章(http://blog.csdn.net/dabaoonline/article/details/50469704);

1. 算术运算符Arithmetic operators

同Java语言一样Groovy支持同样的算术运算符。

1.1. 普通算术运算符Normal arithmetic operators

以下这些二元算术运算符在Groovy中是适用的:

举一些例子:
assert 1 + 2 == 3
assert 4 - 3 == 1
assert 3 * 5 == 15
assert 3 / 2 == 1.5
assert 10 % 3 == 1
assert 2 ** 3 == 8

这个没啥难点,主要是关于除以和幂。整数的除以得到的结果和java中有所不同,如若想达到java中的效果,需要使用intdiv()方法,具体参考:我的另一篇文章(http://blog.csdn.net/dabaoonline/article/details/50469704);

1.2. 一元运算符Unary operators

共三个+,-,++,–这个和Java中相同
例子:

def a = 2
def b = a++ * 3             

assert a == 3 && b == 6

def c = 3
def d = c-- * 2             

assert c == 2 && d == 6

def e = 1
def f = ++e + 3             

assert e == 2 && f == 5

def g = 4
def h = --g + 1             

assert g == 3 && h == 4
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

1.3. 赋值运算符Assignment arithmetic operators

我们上面看到的二元算术运算符同样可以用作赋值运算符:

• +=
• -=
• *=
• /=
• %=

来看看它们的表现:
def a = 4
a += 3
assert a == 7
def b = 5
b -= 3
assert b == 2
def c = 5
c *= 3
assert c == 15
def d = 10
d /= 2
assert d == 5
def e = 10
e %= 3
assert e == 1
def f = 3
f **= 2
assert f == 9

2. 关系运算符Relational operators

关系运算符允许两个对象间的比较,以确定其二者是否相同,或者用于判断那个大,那个小,还是相等。
以下操作符是适用的:

举几个它们之间比较的例子:
assert 1 + 2 == 3
assert 3 != 4
assert -2 < 3
assert 2 <= 2
assert 3 <= 4
assert 5 > 1
assert 5 >= -2

3.逻辑运算符 Logical operators

Groovy提供了三个用于布尔表达式的逻辑运算符:

• &&: logical “and”
• ||: logical “or”
• !: logical “not”

通过几个例子阐述一下:
assert !false
assert true && true
assert true || false

这里需要说明的是Groovy中的&&、||与Java中的含义相同。
另外除了这些逻辑运算符,Groovy中还有&,|均和Java中含义相同。

3.1.优先级 Precedence

“非”的优先级大于”且”

assert (!false && false) == false 

“且”的优先级高于”或”

assert true || true && false  

3.2. 短路Short-circuiting

这些知识同Java,短路的目的说白了就是效率高一些。
什么是短路?
1. 逻辑与（&&），如果第一个操作数为false，那么结果肯定false，所以在这种情况下，将不会执行逻辑与后面的运算了，即发生了短路。
2. 逻辑或（||），如果第一个操作数为ture，那么结果肯定是ture，所以在这种情况下，将不会执行逻辑与后面的运算了，即发生了短路。

boolean checkIfCalled() {   
    called = true
}

called = false
true || checkIfCalled()
assert !called              

called = false
false || checkIfCalled()
assert called               

called = false
fals
1
2
3
4
5
6
7
8
9
10
11
12
13