3.6 运算符
运算符就是在用变量或常量进行运算时，经常需要用到的运算符号，目前常用的总共有10种：算术运算符、关系运算符、逻辑运算符、位运算符、移位运算符、赋值运算符、三元运算符、逗号运算符、字符串运算符（将在第6章介绍）、转型运算符。下面将会对每种运算符结合实例进行详细的讲解。
3.6.1 算术运算符
在小学阶段就学过“加”“减”“乘”“除”“余”，其实这也是Java中的算术运算符（也被称为数学运算符）。下面来看一种情况：当一个浮点型数据加上一个整型数据，其结果是什么类型的数据呢？这涉及数字精度问题。在不同类型的数据之间进行运算时，为了使结果更加精确，系统会将结果自动转化为精度更高的数据类型。
【实例3-15】以上所述的定义有点复杂，通过下面的例子进行说明。
01 public class Var4 //定义一个Var4类
02 {
03 public static void main(String[] args) //主方法
04 {
05 int a=10; //这里的a是一个整型数据
06 float b=10f; //这里的b是一个浮点型数据
07 System.out.println("a+b="+(a+b)); //相加后为一个浮点型数据
08 }
09 }
【代码说明】第5行定义了整型变量a。第6行定义了浮点型变量b。第7行在控制台输出两个变量进行“加”运算后的结果。
【运行效果】
a+b=20.0
以上的程序代码中，变量a是整型，变量b是单精度浮点型，运算的结果是单精度浮点型。以上的实例说明了一点：为了保证经过算术运算后结果的数据精度，尽量让结果与运算数据中精度较高的类型相同。这个例子就是让结果与a、b中精度较高的单精度浮点型b变量的数据类型相同，所以结果类型就是单精度浮点数据类型。
如何将结果进行转换？转化有什么规律吗？笔者根据经验总结了以下几点。
当使用运算符把两个操作数结合到一起时，首先会将两个操作数转化成相同类型的数据。
两个操作数中如有一个是double型，那么另一个操作数一定先转化成double型，再进行运算。
两个操作数中如有一个是float型，那么另一个操作数一定先转化成float型，再进行运算。
两个操作数中如有一个是long型，那么另一个操作数一定会先转化成long型，再进行运算。
其他任何两个基本类型数据操作，两个操作数都会自动转化成int型。
明白了数据精度的问题，再回到算术运算符的应用。算术运算符的使用可参考表3-1。
表3-1 算术运算符
说明 表3-1中的++、--运算符的作用说明中的“=”是赋值运算符，把右边的值赋予左边的变量，左边原来的变量值被覆盖。
【实例3-16】下面通过程序段来熟悉这些运算符的用法。
01 //两个整型变量a、b通过算术运算符得出的结果
02 public class Data1 //定义一个Data1类
03 {
04 public static void main(String[] args) //主方法
05 {
06 int a=10; //这里的a是一个整型数据
07 int b=3; //这里的b是一个整型数据
08 System.out.println("a+b="+(a+b));
09 System.out.println("a-b="+(a-b));
10 System.out.println("a*b="+(a*b));
11 System.out.println("a/b="+(a/b));
12 System.out.println("a%b="+(a%b));
13 }
14 }
【代码说明】第6~7行先定义两个整型变量。然后通过第8~12行的加、减、乘、除和求余运算，在控制台输出计算结果。
【运行效果】
a+b=13 a-b=7 a*b=30 a/b=3 a%b=1
下面重点讨论自加和自减运算符的用法，它可以使一个变量自动加1和自动减1，得到的值再赋给这个变量。自加运算符又分为两种：一种是前自加，一种是后自加。
【实例3-17】下面通过一个程序段看看什么是前自加和后自加。
01 public class Data2 //定义一个Data2类
02 {
03 public static void main(String[] args) //主方法
04 {
05 int a=10; //定义整型变量a并赋值
06 System.out.println("a="+(a++)); //输出整型变量a后自加结果
07 }
08 }
【代码说明】上面的程序段介绍了后自加，其意义就是：先把a的值赋给a，然后，将a的值加1，存储到内存空间。于是，a输出的值就是10，而存储在内存中的a的值为11。
【运行效果】
a=10
【实例3-18】下面的程序代码演示了前自加功能。
01 public class Data3 //定义一个Data3类
02 {
03 public static void main(String[] args) //主方法
04 {
05 int a=10; //定义整型变量a并赋值
06 System.out.println("a="+(++a)); //输出整型变量a前自加结果
07 }
08 }
【代码说明】上面的程序段演示了前自加，其意义就是：先让a的值加1，然后再将这个加之后的值赋给a。于是，a的输出值当然就是11。
【运行效果】
a=11
【实例3-19】下面来看一个综合的实例。
01 public class Data4 //定义一个Data4类
02 {
03 public static void main(String[] args) //主方法
04 {
05 int a=10; //定义整型变量a并赋值
06 System.out.println("a="+(a++)); //输出整型变量a后自加结果
07 System.out.println("a="+(++a)); //输出整型变量a前自加结果
08 }
09 }
【代码说明】这个程序段首先将a的值赋值给a，然后再将a加1放到内存中，内存中的值为11，那么第一个打印语句的结果就是a=10，接下来，将内存中a的值加1再赋给a，那么a的值为12。
【运行效果】
a=10 a=12
同样自减运算符也有两种：一种是前自减，一种是后自减。
【实例3-20】先看下面的程序段。
01 public class Data5 //定义一个Data5类
02 {
03 public static void main(String[] args) //主方法
04 {
05 int a=10; //定义整型变量a并赋值
06 System.out.println("a="+(--a)); //输出整型变量a前自减结果
07 }
08 }
【代码说明】这个程序段介绍的是前自减，其意义是：先将a的值减1，然后赋值给a，于是a的结果就是9。
【运行效果】
a=9
【实例3-21】再来看看下面的程序段。
01 public class Data6 //定义一个Data6类
02 {
03 public static void main(String[] args) //主方法
04 {
05 int a=10; //定义整型变量a并赋值
06 System.out.println("a="+(a--)); //输出整型变量a后自减结果
07 }
08 }
【代码说明】这个程序段介绍的是后自减，其意义是：将a的值赋给a后，再将a的值自动减1，于是输出a是10。
【运行效果】
a=10
【实例3-22】下面再看一个综合实例。
01 public class Data7 //定义一个Data7类
02 {
03 public static void main(String[] args) //主方法
04 {
05 int a=10; //定义整型变量a并赋值
06 System.out.println("a="+(a--)); //输出整型变量a后自减结果
07 System.out.println("a="+(--a)); //输出整型变量a前自减结果
08 }
09 }
【代码说明】这个程序段首先将a的值赋值给a，然后再将a减1放到内存中，内存中的值为9。那么第一个打印语句的结果就是a=10。接下来，将内存中a的值减1再赋给a，那么a的值为8。
【运行效果】
a=10 a=8
【实例3-23】在现实的编程中，可能会遇到更加复杂的程序段，下面继续看一个综合实例。
01 public class Data8 //定义一个Data8类
02 {
03 public static void main(String[] args) //主方法
04 {
05 int a=10; //定义整型变量a并赋值
06 System.out.println("a="+(a--)); //输出整型变量a后自减结果
07 System.out.println("a="+(--a)); //输出整型变量a前自减结果
08 System.out.println("a="+(a++)); //输出整型变量a后自加结果
09 System.out.println("a="+(++a)); //输出整型变量a前自加结果
10 }
11 }
【代码说明】首先将a的值赋给a，然后将a自动减1放到内存中，此时内存中值为9，所以第一个打印语句输出的值为10。接着，将内存的值先减1再赋给a，a就为8。随后，将a的值先赋给a，再将a的值加1放到内存中，所以内存中a为9。最后将内存中的值加1再赋给a，a的值为10。
【运行效果】
a=10 a=8 a=8 a=10
为了能方便地记忆自加和自减运算符的用法，总结如下：
++x：因为++在前，所以可以记忆为先加后用。
x++：因为++在后，所以可以记忆为先用后加。
--x：因为--在前，所以可以记忆为先减后用。
x--：因为--在后，所以可以记忆为先用后减。
3.6.2 关系运算符
关系运算符就是指两个操作数之间的关系，它包括了“>”、“<”等。算术运算符的结果都是数字，而关系运算符的结果则是布尔型数据，这一点一定要注意。关系运算符的使用可参考表3-2。
表3-2 关系运算符
注意 1）区别关系运算符“==”和赋值运算符“=”，前者是比较符号左右两边的数据是否相等，而后者是把符号右边的数据赋予左边的变量。
2）“==”、“！=”可以用于对象的比较，而对象的比较通常不是很简单的通过对象名字比较或对象类型比较，而是有自己的equal()函数，有些情况下两个对象是否相等的函数需要程序员自己编写，这里读者需要知道该知识点，在深入学习了面向对象技术后会有切身的理解。
在实际开发中，经常使用关系运算符来作为判断的条件：如果条件是真，会如何处理；如果条件是假，又该如何处理。
【实例3-24】下面看一个简单的例子，看看关系运算符的输出是什么样子。
01 //关系运算符的应用
02 public class Data9 //定义一个Data9类
03 {
04 public static void main(String[] args) //主方法
05 {
06 int a=10; //定义整型变量a并赋值
07 int b=21; //定义整型变量b并赋值
08 System.out.println("说a>b,对吗？"+(a>b)); //>运算符使用
09 System.out.println("说a>=b,对吗？"+(a>=b)); //>=运算符使用
10 System.out.println("说a<b,对吗？"+(a<b)); //<运算符使用
11 System.out.println("说a<=b,对吗？"+(a<=b)); //<=运算符使用
12 System.out.println("说a==b,对吗？"+(a==b)); //==运算符使用
13 System.out.println("说a!=b,对吗？"+(a!=b)); //!=运算符使用
14 }
15 }
【代码说明】第6~7行首先定义了两个变量a和b。第8~13行通过比较两个变量的大小，来输出关系运算的结果。
【运行效果】
说a>b,对吗？false 说a>=b,对吗？false 说a<b,对吗？true 说a<=b,对吗？true 说a==b,对吗？false 说a!=b,对吗？true
说明 从以上的程序段可以看出，关系运算符的结果是布尔型数据。
3.6.3 逻辑运算符
常用的逻辑运算符有3种：“非”“和”“或”。逻辑运算符一般与关系运算符结合起来使用，下面将详细地介绍这3个逻辑运算符。
1．NOT运算符
NOT运算符就是一个否定的意思，因为英文中“NOT”就是“不”的意思，在Java中，NOT用符号“！”表示。
【实例3-25】下面看一个简单的例子。
01 //非逻辑运算符的应用
02 public class Data10 //定义一个Data10类
03 {
04 public static void main(String[] args) //主方法
05 {
06 int a=10; //定义整型变量a并赋值
07 int b=21; //定义整型变量b并赋值
08 System.out.println("说a>b,对吗？"+!(a>b)); //!运算符使用
09 }
10 }
【代码说明】在程序中，“a>b”是假的，即“false”，但是前面有个“!”否定运算符，将“false”变成了“true”。
【运行效果】
说a>b,对吗？true
2．AND运算符
根据英文“AND”的意思，就知道此运算符是“与”的意思。使用它必须要满足AND前后两个条件。AND运算符在Java中用符号“&&”表示。
【实例3-26】下面看一个简单的实例。
01 //与逻辑运算符的应用
02 public class Data11 //定义一个Data11类
03 {
04 public static void main(String[] args) //主方法
05 {
06 int a=10; //定义整型变量a并赋值
07 int b=21; //定义整型变量b并赋值
08 System.out.println("认为既a>b又a<b,对吗？"+((a>b)&&(a<b))); //&&运算符使用
09 }
10 }
【代码说明】“a<b”这个关系运算得出的结果是“true”，而“a>b”这个关系运算得出的结果是“false”。两者用AND这个逻辑运算符连接后，得出的结果是“false”。
【运行效果】
认为既a>b又a<b,对吗？false
为什么会这样呢？下面是AND运算符的原理：两个操作数只要有一个是“false”，那么结果就是“false”，如果两个操作数都是“true”，那么结果才是“true”。
3．OR运算符
根据英文“OR”的意思，就知道此运算符是“或”的意思，使用它只要满足OR前后两个条件中任意一个条件。OR运算符在Java中用符号“||”表示，其原理如下：
两个操作数只要有一个是“true”，那么结果就是“true”，否则结果就是“false”。
【实例3-27】下面看一个简单的例子。
01 public class Data12 //定义一个Data12类
02 {
03 public static void main(String[] args) //主方法
04 {
05 int a=10; //定义整型变量a并赋值
06 int b=21; //定义整型变量b并赋值
07 int c=10; //定义整型变量c并赋值
08 System.out.println("认为既a>b又a<b,对吗？"+((a>=b)||(a==b))); //||运算符使用
09 System.out.println("认为既a>b又a=c,对吗？"+((a<b)||(a==c))); //||运算符使用
10 }
11 }
【代码说明】上面的程序段中，“a>=b”和“a＝＝b”两个操作数的结果都是“false”，所以“或”的结果就是“false”；而“a<b”的结果是“true”，“a＝＝c”的结果是“true”，所以结果就是“true”。
【运行效果】
认为既a>b又a<b,对吗？false 认为既a>b又a=c,对吗？true
逻辑运算符主要用于判断条件，例如后面要讲解的判断语句、循环语句的条件判断等。
表3-3给出了所有逻辑运算符。
表3-3 逻辑运算符
说明 读者或许发现“&&”与“&”，“|”与“||”的计算结果相同，但是二者之间还是有区别的，对于“&&”和“||”只要计算完左边的值可以确定整个表达式的值，则不必再进行计算，但是对于“&”和“|”必须把左右两边的结果都计算完后才可以计算结果值。
3.6.4 位运算符
位运算符主要针对二进制进行运算，它包括了“与”“非”“或”“异或”。从表面上看有点像逻辑运算符，但逻辑运算符是针对两个关系表达式来进行逻辑运算，而位运算符主要针对两个二进制数的位进行运算。下面详细介绍每个位运算符。
1．与运算符
与运算符用符号“&”表示，其使用规律如下：两个操作数中位都为1的情况下，结果才为1，否则结果为0。
【实例3-28】例如下面的程序段。
01 public class Data13 //定义一个Data13类
02 {
03 public static void main(String[] args) //主方法
04 {
05 int a=129; //定义整型变量a并赋值
06 int b=128; //定义整型变量b并赋值
07 System.out.println("a和b与的结果是："+(a&b)); //&运算符使用
08 }
09 }
【代码说明】a的值是129，转换成二进制就是10000001，而b的值是128，转换成二进制就是10000000。根据与运算符的运算规律，只有两个位都是1，结果才是1，可以知道上述结果就是10000000，即128。
【运行效果】
a和b与的结果是：128
2．或运算符
或运算符用符号“|”表示，其运算规律如下：两个位只要有一个为1，那么结果就是1，否则就为0。
【实例3-29】下面看一个简单的例子。
01 public class Data14 //定义一个Data14类
02 {
03 public static void main(String[] args) //主方法
04 {
05 int a=129; //定义整型变量a并赋值
06 int b=128; //定义整型变量b并赋值
07 System.out.println("a和b或的结果是："+(a|b)); //|运算符使用
08 }
09 }
【代码说明】a的值是129，转换成二进制就是10000001，而b的值是128，转换成二进制就是10000000，根据或运算符的运算规律，两个位中有一个是1，结果就是1，可以知道上述结果就是10000001，即129。
【运行效果】
a和b或的结果是：129
3．非运算符
非运算符用符号“~”表示，其运算规律如下：如果位为0，结果是1；如果位为1，结果是0。
【实例3-30】下面看一个简单例子。
01 public class Data15 //定义一个Data15类
02 {
03 public static void main(String[] args) //主方法
04 {
05 int a=2; //定义整型变量a并赋值
06 System.out.println("a非的结果是："+(~a)); //~运算符使用
07 }
08 }
【代码说明】a的值是2，转换成二进制就是0010，因为非运算就是取相反的位值，而且取反是针对二进制的所有位而言，因为二进制中最高位是1表示负数，所以最终转换为十进制就是-3。
注意 本章中所计算的一些二进制，计算方法都没有那么复杂，如int类型占4字节，每个字节是8位，则对于数值2来说，标准的二进制应该是00000000000000000000000000000010，一共是32位。但为了简化说法，我们并不把多余的零写出来。上述二进制进行非运算后是11111111111111111111111111111101。对于计算机基础学得好的读者，可能还会知道负数的二进制，其实是它绝对值的二进制取反再加1。上述非运算后的结果是00000000000000000000000000000011这个二进制取反加1的结果，而这个值转换为十进制就是3，因为最高位是1表示负数，所以结果为-3。如果读者还不明白这些内容，可以参考一些数据结构和汇编语言的专业书籍。
【运行效果】
a非的结果是：-3
4．异或运算符
异或运算符是用符号“^”表示的，其运算规律是：两个操作数的位中，相同则结果为0，不同则结果为1。
【实例3-31】下面看一个简单的例子。
01 public class Data16 //定义一个Data16类
02 {
03 public static void main(String[] args) //主方法
04 {
05 int a=15; //定义整型变量a并赋值
06 int b=2; //定义整型变量b并赋值
07 System.out.println("a与b异或的结果是："+(a^b)); //^运算符使用
08 }
09 }
【代码说明】a的值是15，转换成二进制为1111，而b的值是2，转换成二进制为0010，根据异或的运算规律，可以得出其结果为1101，即13。
【运行效果】
a与b异或的结果是：13
3.6.5 移位运算符
移位运算符也是针对二进制的“位”，它主要包括：左移运算符（<<）、右移运算符（>>）、无符号右移运算符（>>>）。
1．左移运算符
左移运算符用“<<”表示，是将运算符左边的对象向左移动运算符右边指定的位数，并且在低位补0。其实，向左移n位，就相当于乘上2的n次方。
【实例3-32】例如下面的例子。
01 public class Data17 //定义一个Data17类
02 {
03 public static void main(String[] args) //主方法
04 {
05 int a=2; //定义整型变量a并赋值
06 int b=2; //定义整型变量b并赋值
07 System.out.println("a移位的结果是："+(a<<b)); //<<运算符使用
08 }
09 }
【代码说明】首先从本质上分析，2的二进制是00000010，它向左移动2位，就变成了00001000，即8。如果从另一个角度来分析，它向左移动2位，其实就是乘上2的2次方，结果还是8。
【运行效果】
a移位的结果是：8
2．带符号右移运算符
带符号右移运算符用符号“>>”表示，是将运算符左边的运算对象向右移动运算符右边指定的位数。如果是正数，在高位补0，如果是负数，则在高位补1。
【实例3-33】先看下面一个简单的例子。
01 public class Data19 //定义一个Data19类
02 {
03 public static void main(String[] args) //主方法
04 {
05 int a=16; //定义整型变量a并赋值
06 int c=-16; //定义整型变量c并赋值
07 int b=2; //定义整型变量b并赋值
08 int d=2; //定义整型变量d并赋值
09 System.out.println("a的移位结果："+(a>>b)); //>>运算符使用
10 System.out.println("c的移位结果："+(c>>d)); //>>运算符使用
11 }
12 }
【代码说明】a的值是16，转换成二进制是00010000，让它右移两位就变成00000100，即4。c的值是-16，转换成二进制是11101111，让它右移一位是11111011，即-4。
【运行效果】
a的移位结果：4 c的移位结果：-4
3．无符号右移运算符
无符号右移运算符用符号“>>>”表示，是将运算符左边的对象向右移动运算符右边指定的位数，并且在高位补0。其实右移n位，就相当于除上2的n次方。
【实例3-34】来看下面的例子。
01 public class Data18 //定义一个Data18类
02 {
03 public static void main(String[] args) //主方法
04 {
05 int a=16; //定义整型变量a并赋值
06 int b=2; //定义整型变量b并赋值
07 System.out.println("a移位的结果是："+(a>>>b)); //>>>运算符使用
08 }
09 }
【代码说明】从本质上来分析，16的二进制是00010000，它向右移动2位，就变成了00000100，即4。如果从另一个角度来分析，它向右移动2位，其实就是除以2的2次方，结果还是4。
【运行效果】
a移位的结果是：4
现在再来总结一下移位运算符的运算规则：首先把运算对象转化成二进制位，如把20转换为二进制则表达为00010100。
1）左移运算规则：把数据对象的二进制位依次左移n位，右边空出的位置补0，如20<<2，计算结果为01010000，十进制值为80。
2）无符号右移运算规则：把数据对象的二进制位依次向右移动n位左边空出的位置补0，如20>>>2，计算结果为00000101，十进制为5。
3）带符号右移运算规则：把数据对象的二进制位依次右移n位，移出的数补到左边。如20>>2，计算结果为00000101，十进制为5。这里恰巧和无符号右移运算结果相同。再举例如15>>2，15的二进制位表达为00001111，15>>2的计算结果为11000011，十进制为195；而15>>>2的计算结果为00000011，十进制为3。显然带符号右移与无符号右移有明显区别。
注意 如果读者仔细分析可以看出左移n位运算相当于把十进制数乘以2的n次方，无符号右移n位运算相当于把十进制数除以2的n次方。如前面计算规则中的例子，20<<2=20×22=80，20>>>2=20/22=5。
表3-4描述了移位运算符的用法。
表3-4 移位运算符
3.6.6 赋值运算符
赋值就是将数值赋给变量，而赋值运算符就充当了这个赋值的任务，其实最简单的赋值运算符就是“＝”。
当然除了“＝”外，还有很多其他赋值运算符，有“+=”“－=”“*=”“/=”“%=”“>>=”“>>>=”“<<=”“&=”“|=”“^=”。
【实例3-35】下面给出一个简单的例子。
01 public class Data20 //定义一个Data20类
02 {
03 public static void main(String[] args) //主方法
04 {
05 int a=5; //定义整型变量a并赋值
06 int b=2; //定义整型变量b并赋值
07 System.out.println("a+=b的值："+(a+=b)); //+=运算符使用
08 System.out.println("a-=b的值："+(a-=b)); //－=运算符使用
09 System.out.println("a*=b的值："+(a*=b)); //*=运算符使用
10 System.out.println("a/=b的值："+(a/=b)); ///=运算符使用
11 System.out.println("a%=b的值："+(a%=b)); //%=运算符使用
12 System.out.println("a>>=b的值："+(a>>=b)); //>>=运算符使用
13 System.out.println("a>>>=b的值："+(a>>>=b)); //>>>=运算符使用
14 System.out.println("a<<=b的值："+(a<<=b)); //<<=运算符使用
15 System.out.println("a&=b的值："+(a&=b)); //&=运算符使用
16 System.out.println("a|=b的值："+(a|=b)); //|=运算符使用
17 System.out.println("a^=b的值："+(a^=b)); //^=运算符使用
18 }
19 }
【代码说明】第7行的“a+=b”就是a=a+b。第8行的“a-=b”就是a=a-b。第17行的“a^=b”就是a=a^b。
【运行效果】
a+=b的值：7 a-=b的值：5 a*=b的值：10 a/=b的值：5 a%=b的值：1 a>>=b的值：0 a>>>=b的值：0 a<<=b的值：0 a&=b的值：0 a|=b的值：2 a^=b的值：0
3.6.7 三元运算符
三元运算符一般用得很少，因为它在程序段中的可读性很差，所以不建议经常使用三元运算符，但很少使用并不代表不使用，所以还是要掌握它的用法。三元运算符的表达形式如下：
布尔表达式？值0:值1
它的运算过程是：如果布尔表达式的结果是true，就返回值0；如果布尔表达式的结果是false，就返回值1。
【实例3-36】例如下面的程序段。
01 public class Data21 //定义一个Data21类
02 {
03 public static void main(String[] args) //主方法
04 {
05 int a=10; //定义整型变量a并赋值
06 int b=20; //定义整型变量b并赋值
07 System.out.println("此三元运算式结果是："+((a>b)?'A':'B')); //三元运算符应用
08 }
09 }
【代码说明】因为“a”小于“b”，所以“a>b”这个关系运算符的结果是“false”，既然是“false”，那么选择值1，即这个三元运算符的结果是“B”。
【运行效果】
此三元运算式结果是：B
3.6.8 逗号运算符
在Java程序设计中，逗号运算符一般是用来将几个数值彼此分开，例如数组中的每个元素都是使用逗号与其他元素分开的。这个运算符太简单了，这里不再给出实例。
3.6.9 转型运算符
转型运算符的用处是将一种类型的对象或数据，经过强制转换而转变为另一种类型的数据。它的格式是在需要转型的数据前加上“()”，然后在括号内加入需要转化的数据类型。
【实例3-37】有的数据经过转型运算后，精度会丢失，而有的会更加精确，下面的例子可以说明这个问题。
01 public class Data22 //定义一个Data22类
02 {
03 public static void main(String[] args) //主方法
04 {
05 int x; //定义整型变量x
06 double y; //定义双精度浮点数变量y
07 x=(int)34.56+(int)11.2; //强制转换
08 y=(double)x+(double)11; //强制转换
09 System.out.println("x="+x);
10 System.out.println("y="+y);
11 }
12 }
【代码说明】第7行中，由于在34.56前有一个int的强制类型转化，所以34.56就变成了34。同样，11.2就变成了11，所以x的结果就是45。第8行中，在x前有一个double类型的强制转换，所以x的值变为45.0，而数值11也被强制转换成double类型，所以也变成11.0，所以最后y的值变为56.0。
【运行效果】
x=45 y=56.0
3.6.10 运算符的优先级别
当多个运算符出现在一个表达式中，谁先谁后呢？这就涉及运算符的优先级别。在一个多运算符的表达式中，运算符优先级不同会导致最后的结果差别甚大，例如(1+3)＋(3+2)*2，这个表达式如果按加号最优先计算，答案就是18，如果按照乘号最优先计算，答案则是14。
下面将详细介绍在Java程序设计中，各个运算符的优先级别，如表3-5所示。
如表3-5 运算符的优先级别
