操作符

• 在最底层，Java中的数据是通过使用操作符来操作的

1，使用Java操作符

• 操作符接受一个或者多个参数，并且生成一个新值。参数的形式和普通的方法调用不同，但是效果是相同的。
• 加号和一元正号（+）、减号和一元负号（-）、乘号（*）、除号（/）以及赋值号（=）的用法与其他编程语言类似。
• 几乎所有的操作符都只能操作“基本类型”。例外的操作符是“=”、“==”、和“！=”，这些操作符可以操作所有的对象。
• String类支持“+”和“+=”。
• -

---

2，优先级

• 先乘除后加减，有时我们用括号明确规定计算顺序。

public class Precedence{
    public static void main(String[] args) {
      int x = 1, y = 2, z = 3;
      int a = x + y - 2/2 + z;
      int b = x + (y - 2)/(2 + z);
      System.out.println(" a = " + a + " b = " + b);
      }
}  
/* output: a = 5  b = 1 */    

• 注意：System.out.println（）语句中包含“+”操作符。在这种上下文环境中，“+”意味“字符串连接”，并且如果有必要，还要进行“字符串转换”。当编译器发现String后面紧跟一个“+”，而这个“+”的后面又紧跟一个非String类型的元素时，就会尝试将这个非String类型的元素转换为String。正如在输出中所看到的，它成功的将a和b从int转换为String了。

---

3，赋值

赋值的操作符是“=”。它的意思就是“去右边的值（即右值）把它复制给左边（即左值）”。右值可以是任何常数变量或者表达式（只要它能生成一个值就行）。但左值必须是一个明确的、已命名变量。例：

a = 4;

• 但是我们不能把任何东西赋值给一个常数，常数不能为左值（比如说 4 = a ，这样就是错误的不可行的）。

---

对基本数据类型赋值的时候，其实就是将一个地方的内容复制到了另外一个地方。比如说对数据类型使用a = b，那么b的内容就是复制给了a 。如果接着又修改了a，那么b不会受到这种修改的影响。

---

在为对象赋值的时候，也就是说我们对一个对象进行操作的时候，我们真正操作的是对对象的引用。所以如果“将一个对象赋值给另一个对象”，实际上就是将引用从一个地方复制到另一个地方。这就意味着如果对对象使用c = d,那么c和d都指向原本只有d指向的那个对象。例如：

class A{
   int level;
}
public class Assignment{
  public static void mian(String[] args) {
   A t1 = new A();
   A t2 = new A();
   t1.level = 9;
   t2.level = 10;
   print("1: t1.level: " + t1.level + ", t2.level: " + t2.level);
   t1 = t2;
   print("2: t1.level: " + t1.level + ", t2.level: " + t2.level);
   t1.level = 25;
   print("3: t1.level: " + t1.level + ", t2.level: " + t2.level);
   }
}
/*
output:
1: t1.levle: 9, t2.level: 10
2: t1.levle: 10, t2.level: 10
1: t1.levle: 25, t2.level: 25
*/

A类的两个实例t1和t2是在main（）里面创建的，对每一个A类的对象赋予了一个不同的值，然后将t2赋值给t1,接着又修改了t1。由于赋值操作是对一个对象的引用，因此修改t1的同时改变了t2。这是由于t1和t2包含的相同的引用，它们指向相同的对象。

---

4，算术操作符

Java基本运算操作符合其它语言一样，包括加号（+）、减号（-）、乘号（）、除号（/）以及取模运算符（%，它从整数除法中产生余数）*。
Java也适用来自C和C++的简化符号同时进行运算与赋值操作，操作符后面紧跟一个等号表示，它对于Java中的所有操作符都适用。例如：

• 要将x加4，并将结果赋给x,可以写成：x+=4。

下面是几种算术运算符的基本用法：

public class test {
    public static void main(String[] args) {
        int a, b, result;
        a = 37;
        b = 13;
        result = a + b;
        System.out.println("a + b : " + result);
        result = a - b;
        System.out.println("a - b : " + result);
        result = a * b;
        System.out.println("a * b : " + result);
        result = a / b;
        System.out.println("a / b : " + result);
        result = a % b;
        System.out.println("a % b : " + result);
        a += b;
        System.out.println("a += b : " + a);
        a -= b;
        System.out.println("a -= b : " + a);
        a *= b;
        System.out.println("a *= b : " + a);
        a /= b;
        System.out.println("a /= b : " + a);
    }

}

/*
输出结果为：
a + b : 50
a - b : 24
a * b : 481
a / b : 2
a % b : 11
a += b : 50
a -= b : 37
a *= b : 481
a /= b : 37
*/

5，自动递增和递减

在自动递增和自动递减运算中，递增用符号“++”表示，意思就是增加一个单位；递减用符号“–”表示，意思就是减少一个单位。

• 举个例子来说就是：
  假设a是一个int值，则表达式++a就等价于（a = a+1)。
• 递增和递减操作不仅改变了变量，而且以变量的值作为了生成的结果。
• 前缀递增和前缀递减（如：++a或者–a）,会先执行运算，在生成值；后缀递增或者递减（如：a++或a–），会先生成值，在进行运算。意思也就是：如果是a++的话，在那一行代码中，a的值是不变的，下一行才发生变化，++a则是在那一行已经发生了变化。a–亦然。

举例如下：

public class test {
    public static void main(String[] args) {
        int i = 1;
        System.out.println("i : " + i);
        System.out.println("++i : " + ++i);
        System.out.println("i++ : " + i++);
        System.out.println("i : " + i);
        System.out.println("++i : " + --i);
        System.out.println("i++ : " + i--);
        System.out.println("i : " + i);
    }
}

输出结果为：

i : 1
++i : 2
i++ : 2
i : 3
++i : 2
i++ : 2
i : 1

---

6，关系操作符

• 关系操作符生成的一个Boolean（布尔）结果，它们计算的是操作数的值之间的关系。如果关系是真实的，关系表达式就会生成true（真）；如果关系不真实，则生成false（假）。
• 关系操作符包括小于（<）、大于（>）、小于等于（<=）、大于等于（>=）、等于（=）以及不等于（！=）。其中等于和不等于适用于所有的接本数据类型，而其他比较符不适用于Boolean类型。
• Boolean类型只有true和false，大于和小于没有实际意义。

---

• 关系操作符==和！=也适用于所有的对象：

public class test {
    public static void main(String[] args) {
        Integer n1 = new Integer(18);
        Integer n2 = new Integer(18);
        System.out.println(n1==n2);
        System.out.println(n1!=n2);
    }
}

• 运行结果为：false true
• 由于两个integer对象都是相同的，尽管对对象的内容相同，但是对象的引用是不同的，而==和！=就是比较的对象的引用，因此打印结果先是true而后是false。

若想比较两个对象的内容是否相同，就要使所有的对象都适用于特殊方法equals（）。但是这个方法不适用于基本类型，基本类型直接使用==和！=。

public class test {
    public static void main(String[] args) {
        Integer n1 = new Integer(18);
        Integer n2 = new Integer(18);
        System.out.println(n1.equals(n2));
    }
}

• 打印结果为：true

但是假如我们创建自己的类的话，结果就不一样了：

class Integer{
    int a;
}
public class test {
    public static void main(String[] args) {
        Integer n1 = new Integer();
        Integer n2 = new Integer();
        n1.a = n2.a = 100;
        System.out.println(n1.equals(n2));
    }
}

• 打印结果是： false

这是由于equals（）的默认行为是比较引用。所以除非自己在新类中覆盖equals（）方法。

---

7，逻辑操作符

逻辑操作符“与”（&&）、“或”（||）、“非”（！）能根据参数的逻辑关系，生成一个Boolean类型值（true或者false）。

public class test {
    public static void main(String[] args) {
        int a = 2;
        int b = 4;
        System.out.println("(a<10)&&(b<10) is " + ((a<10)&&(b<10)));
    }
}

• 打印结果为：(a<10)&&(b<10) is true

---

8，短路

短路就是一旦能够明确无误的确定整个表达式的值，就不再计算表达式剩余的部分。要注意的是短路现象是在使用逻辑操作符的时候出现的。

public static void main(String[] args) {
    boolean b = test1(0) && test2(2) && test3(2);
    System.out.println("expression is " + b);
}

static boolean test1(int val) {
    System.out.println("test1(" + val + ")");
    System.out.println("result: " + (val < 1));
    return val < 1;
}

static boolean test2(int val) {
    System.out.println("test1(" + val + ")");
    System.out.println("result: " + (val < 2));
    return val < 2;
}

static boolean test3(int val) {
    System.out.println("test1(" + val + ")");
    System.out.println("result: " + (val < 3));
    return val < 3;
}

• 输出结果为：
  test1(0)
  result : true
  test2(2)
  result : false
  expression is false

每个测试都会比较参数，并返回true和false。这些测试都适用于下面的表达式：

test1(0) && test2(2) && test3(2)

以上代码，第一个测试生成true，因此计算继续执行下去，但是第二个测试产生了一个false结果。就意味着整个表达式为false。短路一词源于此。

---

9，三元操作符 if-else

三元操作符也称为条件操作符，它有三个操作数；但它却是属于操作符的一种，因为它最后也会生成一个值。这个与普通的if-else语句是不同的。

boolean-exp ? value0 : value1

如果boolean-exp的结果为true，就计算value0，而且这个操作结果也是操作符最终产生的值。反之，如果boolean-exp的结果为false，就计算value1，同样，它的结果也就成为了操作符最终产生的值。

条件操作符与if-else的比较：

public class test {
    static int A(int a){
        return a<10 ? a*100 : a*10;
    }
    static int B(int b) {
        if(b<10)
            return b*100;
        else
            return b*10;
    }
    public static void main(String[] args) {
        System.out.println(A(9));
        System.out.println(A(10));
        System.out.println(B(9));
        System.out.println(B(10));
    }
}

• 运行结果为：
  900
  100
  900
  100

上面的A（）中代码与B（）中的不用三元操作符的代码相比较，显然更加紧凑。但是B（）中的代码更易理解。

---

10，提升

如果将一个float值与一个double值相乘，结果就是double；如果将一个int和一个long值相加，则结果为long。