[Java编程思想-学习笔记]第3章 操作符

学习编程语言的通许遇到的第一个程序无非打印"Hello, world"了，然而在Java中要写成

System.out.PRintln("Hello, world");

我们都会感觉太冗长了，能不能简单一些呢？静态导入可以省略掉System，就像这样

import static java.lang.System.*;public class Hello {    public static void main(String[] args) {        out.println("Hello, world");    }}

能不能再简单一些呢？像C语言那样？实际上，这里的System是类，out是System的一个PrintStream类型的静态成员，因为在System类中是这样写的

public final class System {    // ......    public final static PrintStream out = null;    // ......}

可以得到启发，自己也写一个类，然后静态导入此类，就可以像C语言那样直接输出内容了

package p1;import static java.lang.System.*;public class Print {    public static void println(String x) {        out.println(x);    }}

然后写一个Hello程序

import static p1.Print.*;public class Hello{    public static void main(String[] args) {        println("Hello,world");    }}

NOTE：大家可以将自己写的打印输出类打包成jar文件，使用命令jar cvf p1.jar p1/Print.class，其中p1是包名，Print是类名，然后放在jdk目录下的lib目录中，比如D:/jdk/lib/p1.jar，然后修改环境变量，在CLASSPATH中添加%JAVA_HOME%/lib/p1.jar，这样就可以一劳永逸了，只需要import static p1.Print.*;就可以直接使用println方法了。

这里提到操作符的副作用，这篇博文讲得很详细http://www.VEVb.com/lazycoding/archive/2011/04/27/side-effect.html

简单说，变量X在一个表达式的运算后，如果值未变，操作符没有副作用，如果值改变了，操作符产生副作用。

其实不需要刻意去记，因为万能的小括号( )可以减少错误，还使程序易于阅读。

赋值很简单，不外乎为一个变量赋值，比如

int x = 5;

初学者需要注意的是左值的问题，不能写成

int x = 5;2 = x;// 左值不能是直接量，常量x + 1 = 5;// 左值不能是表达式

算术操作符有 +(加)， -(减)，*(乘)，/(除)，%(取模)

int sum = 9 - 8 + 6 / 3 * 5 % 3;// sum = 2

这5个算术操作符只是数学的基本的运算符，自然会像数学那样先乘除取模，再加减。所以这个例子中，先是6 / 3 = 2，再2 * 5 = 10，再10 % 3 = 1，最后9 - 8 + 1 = 2

为了简化语句，可以使用C语言那样的简化操作符，如下

int a = 5;int b = 6;int c;int d = a += b -= c = 2;// d = 9

如优先级第 14 行所述，赋值和简化操作符都是从右至左地运算的，因此上面的程序先是c = 2，再是b -= c，得出b =4，接着是a += b，得出a = 9，最后是d = a，得出d = 9。

递增操作符分为前缀递增和后缀递增，递减操作符也分为前缀递增和后缀递减，分别是

x++ 和 ++x, x-- 和 --x

前缀递增 ++x 的意思是先对 x 加1，然后再使用 x；而后缀递增 x++ 的意思是先使用 x，再对 x 加1，递减操作符也是同样的道理，比如下面的程序

int a = 5;print(++a);// 6int b = 5;print(b++);// 5int c = 5;print(--c);// 4int d = 5;print(c--);// 5

再看复杂一点的程序

int x = 5;int y = x++ + x-- + ++x + --x;// x = 5, y = 22

上面的程序相当于

int x = 5;int y = x++;y = x--;y = ++x;y = --x;

注意，不能对同一个变量使用2个或2个以上的递增递减操作符，比如下面的程序

x++--;// 错误，不能对同一个变量同时使用2个递增递减操作符

关系操作符有<（小于），<=（小于或等于），>（大于），>=（大于或等于），==（等于）和!=（不等于），运算的结果是一个boolean值，如下所示

int x = 7;out.print(x < 8); // trueout.print(x <= 8);// trueout.print(x > 8); // falSEOut.print(x >= 8);// falseout.print(x == 8);// falseout.print(x != 8);// true

== 和 != 还可以用来比较对象，比如

public class Person {    private int age;    public Person(int newAge) {        age = newAge;    }    public static void main(String[] args) {        String s1 = "abc";        String s2 = "abc";        Person xiaoMing = new Person(18);        Person xiaoFu = new Person(18);        out.println(s1 == s2);// true        out.println(xiaoMing == xiaoFu);// false    }}

结果出乎意料了，第 11 行是true，可第 12 行却是false！这是因为，== 和 != 比较的是对象的地址，而非对象的内容。String类型的 s1 和 s2 引用的是同样一个字符串常量，因此相等，而Person类型的xiaoMing和xiaoFu虽然内容一样，但是属于两个不同的对象，就像同一班里有两个小明，虽然它们年龄相等，但是他们的基因不一样。

既然这样，那我们应该如何比较两个对象的内容呢？可以使用从根类Object继承下来的equals()方法

out.println(s1.equals(s2));// trueout.printlnl(xiaoMing.equals(xiaoFu));// false

结果又让人费解，为什么第 1 行的结果是true，而第 2 行的结果还是false？其实类String覆盖了类Object的equals()方法，而这个例子尚未覆盖它，实际上从类Object继承的equals()方法默认是这样的

public boolean equals(Object obj) {   return (this == obj);}

我们可以在类Person中重写（覆盖）equals()方法，然后比较两个对象，如下

public class Person {    private int age;    public Person(int newAge) {        age = newAge;    }    public boolean equals(Object obj) {        if (age == ((Person)obj).age)            return true;        else            return false;    }    public static void main(String[] args) {        Person xiaoMing = new Person(18);        Person xiaoFu = new Person(18);        out.println(xiaoMing.equals(xiaoFu));// true    }}

我们再来看看两个String对象的比较，如下

String s1 = "abc";String s2 = "abc";String s3 = new String("abc");String s4 = new String("abc");out.println(s1 == s2);// trueout.println(s2 == s3);// falseout.println(s3 == s4);// falseout.println(s2.equals(s3));// true

实际上，引用变量s1所指向的字符串常量"abc"是放在常量池的，当s2也要引用"abc"时，JVM并不会再开辟一个内存空间，而是让s2也引用已经存在的"abc"，因此s1会等于s2。s3和s4就不同了，它们所引用的对象是存在于堆中，而且是不同的对象，尽管它们的内容相同，所以两者是不相等的。由于类String实现了equals()方法，使之能比较两String对象的内容，而不是地址，所以第 8 行的结果是true。

逻辑操作符“与”(&&)、“或”(||)、“非”(!)能根据参数的逻辑关系，生成一个布尔值(true或false)。

值得注意的是，&& 和 || 是短路的，比如 p&&q，如果 p 为假，则不必再计算 q，如果 p 为真，则继续计算 q，比如 p||q，如果 p 为真，则不必计算 q，如果 p 为假，则继续计算 q。

public class Demo {    boolean flag;    public static void main(String[] args) {        boolean x = new Demo(false).flag && new Demo(true).flag             && new Demo(true).flag;// false         boolean y = new Demo(false).flag || new Demo(true).flag             || new Demo(true).flag;// false true     }    Demo(boolean newFlag) {        flag = newFlag;        print(flag + " ");    }}

上面的程序，因为短路，第 5 行的结果是false和空格，第7行的结果是false true和空格

直接引用《Java编程思想》的代码

public class Literals {        public static void main(String[] args) {        int i1 = 0x2f;//十六进制，小写        out.println("i1: " + Integer.toBinaryString(i1));        int i2 = 0X2F;//十六进制，大写        out.println("i2: " + Integer.toBinaryString(i2));        int i3 = 0177;//八进制，以0开始        out.println("i3: " + Integer.toBinaryString(i3));                char c = 0xffff;//十六进制，char类型的最大值        out.println("c: " + Integer.toBinaryString(c));        byte b = 0x7f;//十六进制，byte的最大值        out.println("b: " + Integer.toBinaryString(b));        short s = 0x7fff;//十六进制，short的最大值        out.println("s: " + Integer.toBinaryString(s));                long n1 = 200L;//long类型，后缀大L        long n2 = 200l;//long类型，后缀小l        long n3 = 200;//long类型，无后缀        float f1 = 1;//float类型，无后缀        float f2 = 1F;//float类型，后缀大F        float f3 = 1f;//float类型，后缀小f        double d1 = 1d;//double类型，后缀小d        double d2 = 1D;//double类型，后缀大D    }}/*输出结果i1: 101111i2: 101111i3: 1111111c: 1111111111111111b: 1111111s: 111111111111111*/

在C、C++或者Java中，二进制都没有直接常量的表示方法，不过用十六进制和八进制来表示二进制会更加直观、简洁和更易于阅读。

既然是直接常量，程序就休想修改它的值了，比如下面的代码不能编译

int x = ++5;

按位操作符用来操作整数基本数据类型中的单个“比特”(bit)，即补码的二进制位。按位操作符会对两个参数中对应的位执行布尔代数运算，并最终生成一个结果。

按位操作符有 按位与（&）、按位或（|）、按位异或（^）和按位非（~），它们的计算方式如下

实际应用如下：

十进制7的补码：00000111十进制9的补码：000010017 & 9，即 00000111 & 00001001 = 00000001（十进制1）7 | 9，即 00000111 | 00001001  = 00001111（十进制15）7 ^ 9，即 00000111 ^ 00001001 = 00001110（十进制14）~7，   即 ~00000111 = 11111000（十进制-8）

按位操作符和逻辑操作符都使用了同样的符号，因此我们能方便地记住它们的含义：由于位是非常“小”的，所以按位操作符仅使用了一个字符。

按位操作符可与等号(=)联合使用，以便合并运算和赋值：&=、|=、和^=都是合法的（由于~是一元操作符，所以不存在~=）

我们将布尔类型作为一种单bit值对待，因而它会有些独特。对于布尔值，用按位操作符的话，将不再短路。我们可以对布尔值进行&、|、^，但不能~（为了避免与!混淆），其中按位异或(^)使用如下

boolean p = true;boolean q = false;boolean r;r = p ^ p;// falser = p ^ q;// truer = q ^ p;// truer = q ^ q;// false

移位操作符有左移<<有符号右移>>，无符号右移>>>，它们的运算方式如下：

x<<n;   // 将x向左移动n位，在低位补0x>>n;   // 将x向右移动n位，若x是正数，则高位补0，若x是负数，则高位补1x>>>n; // 将x向右移动n位，无论如何，在高位补0// 无论对0怎么移动，结果都是0

如果对char、byte或者short类型的数值进行移位处理，那么在移位之前，它们先转换成int类型，并且得到的结果也是一个int类型的值。

“移位”可与“等号”（<<=或>>=或>>>=）组合使用

条件操作符的语法如下形式：

expression ? value1 : value2;

其实它相当于 if-else语句，如下

if (expression)    value1;else    value2;

如果expression为true，结果为value1，否则为value2。需要注意的是，条件操作符的结合性是从右至左的，比如

int x = 2 > 1 ? 10 : 100 > 99 ? 1000 : 10000;// x = 10

先执行100 > 99 ? 1000 : 10000;结果为1000，再执行2 > 1 ? 10 : 1000;所以结果为10

简单展示一下应用

String s1 = "Hello,";String s2 = "world";String s3 = s1 + s2;// s3 = "Hello,world"String s1 += s2;// s1 = "Hello,world"

学过C语言的应该都清楚类型转换是怎么回事。只要类型比int小（即byte、char或short），那么在运算之前，这些值会自动转换成int，这样一来，最终生成的结果就是int类型了。如果想 把结果赋值给较小的类型，就必须使用强制类型转换（既然把结果赋给了较小的类型，就可能出现信息丢失）。通常，表达式中出现的最大的数据类型决定了表达式 最终结果的数据类型。如果将一个float值与一个double值相乘，结果就是double；如果将一个int和一个long相加，结果为long

// 精确到小数点后3位double pi = 3.141592653;double x = (int) Math.round(pi * 1000) / 1000.0;// x = 3.142