Java基础：第十讲 基本运算——运算符

 

基本运算

本次主要介绍如何使用Java 提供的各种运算符进行基本的运算。

主要内容：

n   算数运算符；

n   赋值运算符；

n   自增、自减运算符；

n   比较运算符；

n   逻辑运算符；

n   位运算符；

n   移位运算符；

n   条件运算符；

n   字符串连接运算符。

算术运算符

（1）用法

标准的算术运算符有：+ 、- 、* 、/ 和% 。分别表示加、减、乘、除和求余。另外“+ ”和“- ”也可以作为单目运算符，就像现实世界中的“正”和“负”。

【例1 】下面的程序演示了这几个运算符的用法。

// MathmeticsOperationTest.java

public class MathematicsOperatorTest {

 public static void main(String[] args) {

      // 定义整形变量a,b，分别赋值20和7

      int a=20;

      int b=7;

     

      // 进行加、减、乘、除和求余运算

      int sum = a+b;

      int sub = a-b;

      int mul = a*b;

      int div = a/b;

      int res = a%b;

     

      // 输出运算的结果

      System.out.println("a="+a+" b="+b);

      System.out.println("a+b="+sum);

      System.out.println("a-b="+sub);

      System.out.println("a*b="+mul);

      System.out.println("a/b="+div);

      System.out.println("a%b="+res);

 }

}

运行结果如下：

a=20 b=7

a+b=27

a-b=13

a*b=140

a/b=2

a%b=6

【注意】整数运算的结果仍然是整数，例如：12/8 = 1 ，而不是1.5 。

（2）类型转换

不同类型的数字进行运算的时候，系统会强制改变数据类型，例如下面的代码：

【例2 】

// TypeConvert.java

public class TypeConvert {

 public static void main(String[] args) {

      byte b1 = 3;

      byte b2 = 4;

      byte b3=b1+b2;

 }

}

在编译的时候会报下面的错误：

Exception in thread "main" java.lang.Error: Unresolved compilation problem:

 Type mismatch: cannot convert from int to byte

 at TypeConvert.main(TypeConvert.java:6)

原因在于执行b1+b2 的时候，系统会把b1 和b2 的类型都转换成int 类型然后计算，计算的结果也是int 类型，所以把int 类型赋值给byte 类型，这时候就产生错误了。

类型转换的基本规则如下：

①     操作数中如果有double 类型，则都会转换成double 类型。

②     如果有float 类型，则会转换成float 类型。

③     如果有long 类型，则会转换成long 类型。

④     其他的都会转换成int 类型。

如何解决上面的错误呢？可以参考下面的代码：

【例3 】

// TypeConvert2.java

public class TypeConvert2 {

 public static void main(String[] args) {

      byte b1 = 3;

      byte b2 = 4;

      // 对计算结果进行强制转换

      byte b3 = (byte)(b1+b2);

 }

}

赋值运算符

（1）基本赋值运算符

“= ”是赋值运算符，其实前面的很多例子都用到过。

用法：左边是变量，右边是表达式。

作用：把右边的表达式的值赋给左边的变量。

例：

int a = 5; // 直接赋值

a = a+3;    // 赋表达式

（2）复合赋值运算符

赋值运算符与其他运算符结合使用完成赋值的功能。看下面的示例：

【例4 】

// CompoundOperator.java

public class CompoundOperator {

 public static void main(String[] args) {

      // 使用复合赋值表达式计算a+3，并把结果赋值给a

      int a = 3;

      a += 3;

     

      // 不使用复合赋值表达式计算b+3，并把结果赋值给b

      int b = 3;

      b = b+3;

     

      // 分别输出a和b的值

      System.out.println("a = "+a);

      System.out.println("b = "+b);

 }

}

运行的结果如下 ：

a = 6

b = 6

①     基本格式

a X= b ;

“X ”表示其他的运算符，可以是各种运算符。

②     作用

使用左值与右值进行基本的“X ”运算，然后把运算的结果赋值给左值，相当于下面的代码：

     a = aXb ;

大部分的运算符都可以和赋值运算符结合使用构成复合赋值运算符。

自增、自减运算符

自增运算符

（1 ）自增运算符的基本功能就是把自身增加1 ，假设操作数是x ，自增运算符可以有两种格式：

x++

++x

两种格式的效果是相同的，都是把x 的值增加了1 ，相当于：

x = x+1;

但是，当自增运算符和赋值运算符一起使用的时候，两种格式的效果是不一样的，例如：

y = x++; 与 y = ++x;

前者相当于：

y = x;

x = x+1;

后者相当于：

x = x+1;

y = x;

【例5 】

// AddOne.java

public class AddOne {

 public static void main(String[] args) {

      int x1=3;

      int x2=3;

      // ++在后面

      int y1 = x1++;

      // ++在前面

      int y2 = ++x2;

      System.out.println("y1="+y1+" y2="+y2);

 }

}

运行结果如下：

y1=3 y2=4

结论：操作数在前面先赋值；操作数在后面后赋值。

自减运算符

自减运算符的用法与自增运算符完全相同，进行自减操作。下面的实例是把例2-5 中的“++ ”改为“-- ”而形成的：

public class SubOne {

       public static void main(String[] args) {

              int x1=3;

              int x2=3;

              // -- 在后面

              int y1 = x1--;

              // -- 在前面

              int y2 = --x2;

              System.out.println("y1="+y1+" y2="+y2);

       }

}

请读者自行分析程序的运行结果。

结论：操作数在前面先赋值；操作数在后面后赋值。

比较运算符

比较（关系）运算符用于对两个值进行比较，其返回值为布尔类型。

关系运算符有：> 、>= 、< 、<= 、== 、!= ，分别表示大于、大于等于、小于、小于等于、等于、不等于。

基本用法 ：

 exp1 X ex2

其中，exp1 和exp2 是两个操作数，可以是表达式，X 表示其中的一种关系运算符，如果exp1 和exp2 具有“X ”关系，结果为true ，否则结果为false 。例如5>3 ，结果为true ，4!=6 结果为true 。

【例6 】

// CompareOperator.java

public class CompareOperator {

 public static void main(String[] args) {

      int a = 3;

      int b = 4;

      boolean bigger = a>b;

      boolean less = a

      boolean biggerEqual = a>=b;

      boolean lessEqual = a<=b;

      boolean equal = a==b;

      boolean notEqual = a!=b;

      System.out.println("a="+a+" b="+b);

      System.out.println("a>b:"+bigger);

      System.out.println("a

      System.out.println("a>=b:"+biggerEqual);

      System.out.println("a<=b:"+lessEqual);

      System.out.println("a==b:"+equal);

      System.out.println("a!=b:"+notEqual);

 }

}

运行结果如下：

a=3 b=4

a>b:false

a

a>=b:false

a<=b:true

a==b:false

a!=b:true

【注意】

①这些符号都是英文的，不能使用中文。

②“ == ”与“ = ”容易混淆，比较相等不能写成“ = ”

逻辑运算符

在Java 中，逻辑运算符只能对布尔类型数据进行操作，其返回值同样为布尔类型的值。

逻辑运算符有：&& 、|| 、! 、| 、& 、^ 。

运算规则如下：

①     “&& ”和“& ”是逻辑与，只有当两个操作数都为true 的时候，结果才为true 。

②     “|| ”和“| ”是逻辑或，只有当两个操作数都为false 的时候，结果才为false 。

③     “! ”是逻辑非，如果操作数为false ，结果为true ，如果操作数为true ，结果为false 。

④     “^ ”是逻辑异或，如果两个操作数不同，结果为true ，如果两个操作数相同，结果为false 。

【例7 】

// LogicOperator.java

public class LogicOperator {

 public static void main(String[] args) {

      // 定义布尔类型的变量b1和b2，并分别赋值

      boolean b1 = true;

      boolean b2 = false;

     

      // 进行各种布尔运行，并输出结果

      System.out.println("b1="+b1+" b2="+b2);

      System.out.println("b1&&b2="+(b1&&b2));

      System.out.println("b1&b2="+(b1&b2));

      System.out.println("b1||b2="+(b1||b2));

      System.out.println("b1|b2="+(b1|b2));

      System.out.println("!b1="+(!b1));

      System.out.println("b1^b2="+(b1^b2));

 }

}

运行结果为 ：

b1=true b2=false

b1&&b2=false

b1&b2=false

b1||b2=true

b1|b2=true

!b1=false

b1^b2=true

“&& ”和“& ”从运行结果来看是相同的，但是运行的过程不一样。看下面的例子：

【例8 】

// FastLogicOperator.java

public class FastLogicOperator {

 public static void main(String[] args) {

      int a = 5 ;

      int b = 6;

      int c = 6;

     

      // &&进行逻辑运算

      System.out.println((a>b) && (a>(b--)) );

      // 使用&进行逻辑运算

      System.out.println((a>c) & (a>(c--)) );

     

      System.out.println("b="+b);

      System.out.println("c="+c);

 }

}

运行结果为：

false

false

b=6

c=5

从这个结果可以看出，“&& ”和“& ”的运算结果相同，但是b 和c 的值不同。使用“&& ”的时候，后面的表达式没有计算，所以b 的值没有发生变化；使用“& ”的时候，后面的表达式进行计算了，所以c 的值发生了变化。而实际上，进行与运算只要前面的表达式是false ，结果就是false ，所以后面就不用计算了，“&& ”运算符正是使用了这个特性。

“|| ”和“| ”的区别也是这样。

结论：“&& ”和“|| ”是快速运算符，但是不能保证后面的表达式执行。

位运算符

计算机中数字都是以二进制的形式存储的，位运算符用来对二进制数位进行逻辑运算，操作数只能为整型或字符型数据，结果也是整型数。

位运算符有：& 、| 、~ 、^ ，分别表示按位与、按位或、按位非和按位异或。

对两个操作数的每位进行单独的运算，把运算后的每一位重新组合成数字。

例：15&3

15 表示成二进制为：

0000 0000 0000 1111

3 表示成二进制为：

0000 0000 0000 0011

进行按位与，得到：

0000 0000 0000 0011

结果就是3 。

下面的例子包含了4 个位运算附。

【例9 】

// BitOperator.java

public class BitOperator {

 public static void main(String[] args) {

      int a = 15;

      int b = 3;

      // 按位与，并输出结果

      System.out.println("a&b="+(a&b));

      // 按位或，并输出结果

      System.out.println("a|b="+(a|b));

      // 按位进行异或，并输出结果

      System.out.println("a^b="+(a^b));

      // 按位取反，并输出结果

      System.out.println("!a="+(~a));

 }

}

运行结果如下：

a&b=3

a|b=15

a^b=12

!a=-16

移位运算符

移位运算符同样是对二进制位进行操作。

移位运算符有3 个：

<<                  左移

>>                  右移

>>>                无符号右移

①     左移

基本格式：

x<

其中x 是要移位的数，y 是要移动的位数。

结果相当于x 乘于2 的y 次方，例如5<<2 相当于5*2 ² ，结果为20 。

②     右移

基本格式：

x>>y

其中x 是要移位的数，y 是要移动的位数。移位之后，如果是整数，高位补0 ，如果是负数，高位补1 。

结果相当于x 除于2 的y 次方，例如5>>2 相当于5/2 ² ，结果为1 。

③     无符号右移

基本格式：

x>>>y

其中x 是要移位的数，y 是要移动的位数。移位之后，高位补0 。

所以，如果是正数，结果与有符号右移的结果相同。

如果是负数，移位之后会变成整数，因为高位补0 ，高位0 就是正数。

④     例子

【例10 】

      int a,b,c;

      a = 15;

      b = -15;

      c = 2;

      System.out.println("----------左移运算符-----------");

      System.out.println("a="+a+" b="+b+" c="+c);

      System.out.println("a<

      System.out.println("b<

     

      a = 15;

      b = -15;

      System.out.println("----------右移运算符-----------");

      System.out.println("a="+a+" b="+b+" c="+c);

      System.out.println("a>>c= "+(a>>c));

      System.out.println("b>>c= "+(b>>c));

     

      a = 15;

      b = -15;

      System.out.println("----------无符号右移运算符-----------");

      System.out.println("a="+a+" b="+b+" c="+c);

      System.out.println("a>>>c= "+(a>>>c));

      System.out.println("b>>>c= "+(b>>>c));

运行结果为：

----------左移运算符-----------

a=15 b=-15 c=2

a<

b<

----------右移运算符-----------

a=15 b=-15 c=2

a>>c= 3

b>>c= -4

----------无符号右移运算符-----------

a=15 b=-15 c=2

a>>>c= 3

b>>>c= 1073741820

【注意】

①     无符号右移的结果都是正数，不管操作数是正数还是负数。

②     左移和右移，对于正数和负数移位的结果可能是不相同的，符号不变。示例中15 右移2 位得到的结果是3 ，-15 右移2 位得到的结果为-4 ，这样的结果与正数和负数在计算机中表示的方式相关。

条件运算符

根据不同的逻辑结果，可以得到不同的值。

基本格式 ：

op1?op2:op3;

op1 的结果应该为布尔类型，如果op1 的值为true ，则表达式最终的结果为op2 ，如果op1 的值为false ，则表达式最后的结果是op3 。

【例11 】下面的代码完成了求a 和b 的最大值的功能。

// TernaryOperator.java

public class TernaryOperator {

 public static void main(String[] args) {

      int a=10;

      int b=7;

      int c;

     

      // 如果a>b，把a赋值给c，如果不是a>b，把b赋值给c

      c = a>b?a:b;

      System.out.println(a+"和"+b+"的最大值为："+c);

 }

}

运行结果为 ：

10和7的最大值为：10

字符串连接运算符

“+ ”，用于连接字符串，实际上在前面的例子中已经使用了。

基本格式：

op1+op2

要求op1 和op2 中至少要有1 个是字符串，另外一个可以是各种类型，包括前面介绍的8 种基本数据类型以及各种类的对象。

【例12 】

// StringJoin.java

public class StringJoin {

 public static void main(String[] args) {

      byte b = 3;

      short s = 4;

      int i=10;

      long l = 11;

      float f = 3f;

      double d2 = 23.5;

      char c = 's';

      boolean bool = false;

      java.util.Date d = new java.util.Date();

     

      // 使用字符串与各种类型的数据进行连接

      System.out.println("byte类型:"+b);     

      System.out.println("short类型:"+s);    

      System.out.println("int类型:"+i);      

      System.out.println("long类型:"+l);     

      System.out.println("float类型:"+f);    

      System.out.println("double类型:"+d2);      

      System.out.println("char类型:"+c);     

      System.out.println("boolean类型:"+bool);

      System.out.println("其他类的对象："+d);

 }

}

运行结果为 ：

byte类型:3

short类型:4

int类型:10

long类型:11

float类型:3.0

double类型:23.5

char类型:s

boolean类型:false

其他类的对象：Sun Dec 10 09:19:34 CST 2006

 

上一讲：第九讲基本信息表示

下一讲：第十一讲 选择结构

 

李绪成 CSDN Blog ： http://blog.csdn.net/javaeeteacher

邀请您为好友： http://student.csdn.net/invite.php?u=124362&c=7be8ba2b6f3b6cc5