Java运算符和数据类型转换(3.4-3.6)

Java

Publish Date: 2019-01-11

Word Count: 2.8k

Read Times: 11 Min

Read Count:

运算符及表达式、运算符的优先级、数据类型转换

3.4-3.6学习知识点
- 运算符及表达式
  - 算术运算符
  - 关系运算符
  - 逻辑运算符
  - 位运算符
  - 赋值运算符
  - 逻辑运算符
- 运算符的优先级
- 数据类型转换
  - 自动类型转换
  - 手动强制类型转换
  - 隐含强制类型转换

一、运算符及表达式

Java可以对各种类型的数据进行加工，这种加工过程称为运算。其中表示各种不同运算的符号称为运算符 ，参与运算的数据称为操作数 。操作数和运算符按一定语法形式组成的符号序列称为表达式。每个表达式经过运算后都会产生一个确定的值。

📒运算符按其功能分为七类：
1. 算术运算符 + 、-、 *、 /、%、 ++、 –
2. 关系运算符 > 、<、 >=、 <=、 ==、 !=
3. 逻辑运算符！、&&、||、&、|
4. 位运算符 >>、<<、>>>、&、|、^、~
5. 条件运算符？：
6. 赋值运算符 =、+=、-= 、*= 、/=
7. 其他：下标运算符[]

📒运算符按其要求的操作数个数分为三种：
1. 一元运算符如 ++、–
2. 二元运算符如 +、-、*、/、%(求模)
3. 三元运算符如？：

1.1 算术运算符

📒算术运算符中的单目运算符
如 +（一元加，取正值）、
-（一元减，取负值）、
++ （增1运算符）、-- （减1运算符）

增1运算符(++)和减1运算符(--)：
只能用于变量，而不能用于常量或表达式。增量运算符和减量运算符的功能是将操作数的值加1或减1.

(1)增1运算符（减1运算符）在操作数的前面，首先对操作数本身进行增减1运算，然后再参与其所在表达式的
运算。
例：如果变量a的值为5，求下列表达式及a的值
① ++a +10
表达式的值为16，a变为6
② --a +10
表达式的值为14，a变为4
(2)增1运算符（减1运算符）在操作数的后面，则首先让操作数参与计算整个表达式的值，然后再对操作数进行
增减运算
例：如果变量a的值为5，求下列表达式及a的值
① a++ +10
表达式的值为15，a变为6
② a-- +10
表达式的值为15，a变为4

练习题1：写出该程序的输出结果
class test
{
      public static void main(String args[])
     {
           int a=5;
           System.out.println(++a);
           System.out.println(--a);
           System.out.println(a++);
           System.out.println(a--);
} 
}                        
输出结果：
6
5
5
6

📒算术运算符中的双目运算符
如 +（加）、-（减）、*（乘）、/（除）、 % （取余数或取模）。
+，-，* 是通常意义的加、减、乘
如果整数相除，则结果取整。如 5/2 得到结果2。
如果浮点数相除，则是我们通常意义上的除法，如5.0/2.0结果为2.5。
%是取余，如 5%2结果为1
5.2%2结果为1.2
5.2%2.2结果为0.8
10%-4结果2； -10%-4结果-2

注意： 如果整数相除或取模第二个操作数为0 编译无错运行会出错抛出异常；
如果浮点数相除或取模第二个操作数为0 结果为NaN 。
注意：
1. 整数 int a=10/0 运行报错
int a=10%0 运行报错
2. 浮点数
double a=10.0/0 Infinity(正无穷大)
double a=-10.0/0 -Infinity（负无穷大）
double a=0.0/0 NaN
double a=0.0%0 NaN

思考：某个培训中心要为新到的学员安排房间，假设共有x个学员，每个房间可以住6人，让你用一个公式来计算他们要住的房间数？
答案： (x+5)/6
这也可以用于计算留言板的页数。

1.2 关系运算符

1.关系运算符有七种：== ，!= ，< ,<= , > ,>= , instanceof (对象运算符)
2.关系表达式的结果类型为布尔型
3.instanceof：用来确定一对象是否是某一指定类的对象

 class test
{    public static void main(String args[])
     {    test t1=new test();
          if(t1 instanceof test){ System.out.println("是");}    
     } }

📒关系表达式

1.3 逻辑运算符

例：分析下列程序的输出结果
class test{    
    public static void main(String args[]){ 
        boolean s;int i=100;
        s=(3>2)&&(i++==1);
        System.out.println(i);
        i=100;
        s=(3<2)&&(i++==1);
        System.out.println(i);
    }
} 
输出结果：
101
100

1.4 位运算符

例：分析下列程序的输出结果
int a=7, b=8, c;
    c = a & b;     //c=00000000000000000000000000000000=0
    c = a | b;     //c=00000000000000000000000000001111=15
    c = a ^ b;     //c=00000000000000000000000000001111=15
    c =~a;         //c=11111111111111111111111111111000=-8

例：分析下列程序的输出结果
    int a=7,c;     //a=00000000000000000000000000000111
    c = a>>3;      //c=00000000000000000000000000000000=0
    c = a << 3;    //c=00000000000000000000000000111000=56
    c = a >>> 3;   //c=00000000000000000000000000000000=0
int a =-8; 
System.out.println(a>>>1) //结果2147483644
int i=88>>32; System.out.println(i)  //结果88
//（在进行移位之前，java系统首先把移的位数与被移位数求余数，然后移动这个位数）

注意：
（1）右移n位后的结果与除以2的n次方效果相同
（2）左移n位后的结果与乘以2的n次方效果相同
（3）无符号右移要慎重

思考：如何用一个表达式计算2的X次方？
答案： 1<<x
将1左移x位

1.5 赋值运算符

(1)简单赋值运算符 =
将等号右边的表达式的值赋给等号左边的变量
例如： int c,d;
c=1;
d=c+10;
(2)复合赋值运算符 +=、-=、*=、/=、%= 等
一般形式为：变量 op= 表达式
等价于: 变量 =变量 op 表达式
c += a; //c = c +a;
c -= a; //c = c -a;
c = a; //c = c a;

例：int a=1;
double x=2;
a+=2; // 就是a=a+2, 结果使a的值为3
x=x+3; // 就是x=x(x+3), 结果使x的值为10.0
int a=b=c=d=12;
int a=(b=(c=(d=12))); //赋值运算符有返回值，返回值是=右边的值

注意：
1. boolean型的只能赋给boolean型；
2. 其他七种类型如果能自动转换则可直接赋值，否则要进行强制类型转换。

1.6 条件运算符

Java 中唯一的三元运算符，其格式如下：
变量 = <布尔表达式> ? <表达式1> : <表达式2>
含义是：当<布尔表达式>为真时，变量的值为<表达式1>的值，否则为<表达式2>的值。

例:  条件运算
public class max 
{
       public static void main(String args[]) 
      {
            int x=20,y=30,max;
            max = (x>y) ? x : y;      
            System.out.println(“max=”+max);
     }
}
输出结果：max=30

练习题2:
public class max 
{
       public static void main(String args[]) 
      {
      int a=3,b=4,c;
      c=a>b? ++a:b++;
      System.out.println(a+"、"+b+"、"+c);    
     }
}
输出结果：
3、5、4

二、运算符的优先级

表达式的运算次序取决于表达式中各种运算符的优先级。
（1）优先级高的先运算，优先级低的后运算。
（2）括号( )的优先级最高。
（3）优先级相同的情况下要考虑结合性，即从左向右运算还是从右向左运算。
Java语言规定的运算符的优先级如下表所示

运算符的优先级与结合性的一些规律：
1. 优先级
() > 单目运算符 > 双目运算符 > 三目运算符 > 赋值运算符
双目：算术>关系>逻辑。
2. 结合性
大多数运算符结合性为从左至右
赋值运算符的结合性为从右至左
int a,b=3,c=5;
a = b = c; //结果：a、b、c均为 5

表达式写法的习惯：

(1) 除非是简单的直观运算，应该尽量使用括号
(2)另外，尽量不要写太长的表达式，过长的表达式容易引起对求值次序的误解。

例：
    (1) a + b * c
    (2) a = b || c
    (3) a + b < c && d==e
    (4) a=8 – 2 * 3 <4 && 5 < 2     结果：false

表达式写法的习惯：
(1) 除非是简单的直观运算，应该尽量使用括号
(2)另外，尽量不要写太长的表达式，过长的表达式容易引起对求值次序的误解。

三、数据类型转换

3.1 自动类型转换

(1) Java中整型、实型、字符型数据可以混合运算。
运算过程中，Java自动把精度较低的类型转换为另一种精度较高的类型。
(2) 低精度的值赋给高精度的变量可以自动转换,不出现编译错误；相反会出现编译错误,需要强制转换。
例如: float x=(float)5.0;long x=2;

注意： 如果byte、short、char在一起运算时，会先将这些值转换为int型。再进行运算，结果为int型。如表达式中一个变量是int型，另一个是long型，则先将int型转为long型，再进行计算。最后结果为long型。

下列代码会编译出错，提示c = (a + b);有精度损失
class test
{
      public static void main(String args[])
     {
        byte a = 1;
        byte b = 1;
        byte c = (a + b);
      } 
}

练习题3:
下列表达式结果是什么类型？
‘A’+2+2.5
double

3.2 手动强制类型转换

在Java中直接将高精度的值赋给低精度的变量会导致编译出错。这时可用强制类型转换来解决。
形式为：
(类型名)表达式
例如：
int i; byte b,c;
b=(byte)345; //上机测试知b得到89
c=(byte)356; //上机测试知c得到100
i=(int)(3.8+6); //强制转换后小数部分被截去，i得到9，不会四舍五入

注意：
1. 强制类型转换可能造成信息的丢失；
2. 布尔型与其它基本类型之间不能转换。

加上强制类型转换，下列代码编译通过。
class test
{     public static void main(String args[])
     {
        byte a = 1;
        byte b = 1;
        byte c = (byte)(a + b);
      } }

运算时注意（一般的运算都有类型提升功能）：
（1）在运算过程中，运算的结果至少是int型，即如果参与运算的两个数级别比int型低或是int型，则结果为
int型；
（2）参与运算的数据如果有一个级别比int型高，则运算结果的类型与类型级别高的数相同；
（3）参与运算的两个数据如果类型不一样，会先把低级的数据转换成高级的类型的数据后再作运算，结果是高
级的类型。

3.3 隐含强制类型转换

Java中允许把int类型的常量赋给byte、short变量时不需要强制类型转换
byte b=123;//合法
short s=123;//合法
b=b+3; //不合法

但是把int类型的变量赋给byte、short类型的变量时必须强制转换，否则会出错
int i=123;
byte b=i; //正确的做法是byte b=(byte)i;
byte a = 1; byte c = (byte)(a + b);