《JAVA编程思想》学习备忘（第93页：Operators--1）

    在最底层，数据在Java中靠运算符来控制。

Simpler print statements

    以下为简化了的打印语句包及方法,使用时可导入包:

| package staticPrint;

| public class Print {   
|     public static void print(Object obj){
|         System.out.print(obj);
|     }
| }

使用时导入包:

| import static staticPrint.Print.print;

| public class showSimplerPrint{

|     public static void main(String [] args){

|         print("这是简化了的打印语句演示");

|     }

| }

以上为静态方法的创建与应用。

 

Using Java operators

The String class supports '+' and '+='.

 

Precedence

(本节讲运算顺序) 

 

Assignment

右值(rvalue)可以是任意的常量、变量、表达式（产生一个值），但左值（lvalue）必须是一个变量（就是说那里必须有一个物理空间娲⒅担?/DIV>

请注意这句原文：when you assign primitives,you copy the contents from one place to another.

拷贝一个副本，仅仅是拷贝了一个副本。

举个原始数据付值例子：a = b, b的内容拷贝进了a,这时你再修改a的值,b里的值不受影响。

再请注意以下原文：

When you assign objects,however,things change.Whenever you manipulate an object,what you're manipulating is the reference,so when you assign "from one object to another,"you're actually copying a reference from one place to another.

举个对象付值的例子：c=d, 最初d指向一个对象（的地址），付值后，修改c的内容，这时就影响到了d的内容，因为经过地址（指针）的传递后，它们指向了同一地址空间。

实例：

| import static staticPrint.Print.print;

| class Tank{

|     int level;

|}

 

| public class Assignment{

|     public static void main(String[] args){

|         Tank t1 = new Tank();

|         Tank t2 = new Tank();

|         t1.level = 9;

|         t2.level = 47;

|         print("1:t1.level: "+t1.level+", t2.level: "+t2.level);

|         t1 = t2;

|         print("2:t1.level: "+t1.level+", t2.level: "+t2.level);

|         t1.level = 27;

|         print("3:t1.level: "+t1.level+", t2.level: "+t2.level);

|     }

|}

请运行以上程序观察输出结果。

这种现象叫做：“别名化”，在以上例子中，如果你想避免这种现象的发生，请将地址的传递改为值的传递：

| t1.level = t2.level;

 

分辨清“值的传递”与“地址的传递”，在Java中非常重要，能够在编程中灵活应用它们，则会取得非凡之效。

 

Aliasing during method calls

方法调用时的“别名化”：

| import static staticPrint.Print.print;

| class Letter{

|    char c;

| }

 

| public class PassObject{

|     static void f(Letter y){

|         y.c = 'z';

|     }

|     public static void main(String[] args){

|         Letter x = new Letter();

|         x.c = 'a';

|         print("1: x.c: " + x.c);

|         f(x);

|         print("2: x.c: " + x.c);

|     }

|}

以上输出结果：1: x.c: a

              2: x.c: z

方法f(),传递对象f(x),即传递了x的地址，因此出现了所谓的“别名化现象”。

 

Mathematical operators

关于算术运算符的使用例子：

import java.util.*;

import static staticPrint.Print.print;

 

public class MathOps{

    public static void main(String[] args){

        //创建一个带种子(确保程序每次运行产生同一值)的随机数生成器

        Random rand = new Random(47);

        int i,j,k;

        //在 1 到 100 间取值

        j = rand.nextInt(100)+1;

        print("j : " + j);

        k = rand.nextInt(100)+1;

        print("k : " + k);

        i = j + k;

        print("j + k : " + i);

        i = j - k;

        print("j - k : " + i);

        i = k / j;

        print("k / j : " + i);

        i = k * j;

        print("k * j : " + i);

        i = k % j;

        print("k % j : " + i);

        j %= k;

        print("k %= j : " + j);

        // Floating-point number tests:

        float u, v, w;  //Applies to doubles, too

        v = rand.nextFloat();

        print("v : " + v);

        w = rand.nextFloat();

        print("w : " + w);

        u = v + w;

        print("v + w : " + u);

        u = v - w;

        print("v - w : " + u);

        u = v * w;

        print("v * w : " + u);

        u = v + w;

        print("v / w : " + u);

       //The following also works for char,byte,short,int,long and double

        u += v;

        print("u += v : " + u);

        u -= v;

        print("u -= v : " + u);

        u *= v;

        print("u *= v : " + u);

        u /= v;

        print("u /= v : " + u);

    }

}

 

Unary minus and plus operators

(一元运算符)（略）

 

Auto increment and decrement

自增自减运算符。如果 a 是一个 int 型，举例：++a 等值于 a = a + 1 。

预增预减方式（++a 和 --a）, 表示先运算后使用；

后增后减方式（a++ 和 a--），表示先使用后运算。

 

Relational operators

关系运算符产生一个 boolean 结果。

关系运算符：<,>,<=,>=,==,!= 。

“等于”和“非等”用于比较所有原始数据类型。而其它的比较则不能用于 boolean 类型，因为 boolean 类型之间不能分“大”“小”。

 

Testing object equivalence

关系运算符 == 和 != 也用于比较对象，但要注意它们的含义：

public class Equivalence{

    public static void main(String[] args){

        Integer n1 = new Integer(47);

        Integer n2 = new Integer(47);

        System.out.println(n1 == n2);

        System.out.println(n1 != n2);

    }

}

打印结果为：false true

为什么会这样呢？对了，因为比较的是对象的地址而非对象的内容。

要想比较对象的内容，要用一个特殊的方法： equals() ：

public class EqualsMethod{

    public static void main(String[] args){

        Integer n1 = new Integer(47);

        Integer n2 = new Integer(47);

        System.out.println(n1.equals(n2));

    }

}

打印结果为：true

现在的结果正是你想要的吧。啊，但事情往往不是这样简单，如果你创建自己的类如下：

class Value{

    int i;

}

 

public class EqualsMethod2{

    public static void main(String[] args){

        Value v1 = new Value();

        Value v2 = new Value();

        v1.i = v2.i = 100;

        System.out.println(v1.equals(v2));

    }

}

事情再次变得令人费解：打印结果为 false

这是因为 equals()方法默认的行为是比较对象地址，这样说来，除非你在你创建的类中重写equals方法才能得到期望的行为。（在以后章节中会细讲）

大多数的Java库类实现了equals方法，所以它可用来比较这些类对象的内容。

 

Logical operators

基于它的参数的逻辑关系，每一个逻辑运算符，与（&&），或（||），非（!），产生一个 boolean 型的值：true 或者 false 。

 

(待续)