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

发表于 更新于 分类于 阅读次数： Valine：
本文字数： 5.8k 阅读时长 ≈ 5 分钟

 
 

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

 
 

一、 运算符及表达式

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

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

📒运算符按其要求的操作数个数分为三种：

  1. 一元运算符 如 ++、–
  2. 二元运算符 如 +、-、*、/、%(求模)
  3. 三元运算符 如 ？：

&emsp;

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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
练习题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
这也可以用于计算留言板的页数。

&emsp;
&emsp;

1.2 关系运算符

**1.关系运算符有七种：**== ，!= ，< ,<= , > ,>= , instanceof (对象运算符) **2.关系表达式的结果类型为布尔型** **3.instanceof：**用来确定一对象是否是某一指定类的对象 
1
2
3
4
5
 class test
{    public static void main(String args[])
     {    test t1=new test();
          if(t1 instanceof test){ System.out.println("是");}    
     } }

&emsp;
📒关系表达式

1.png

&emsp;
&emsp;

1.3 逻辑运算符

2.png 3.png

1
2
3
4
5
6
7
8
9
10
11
12
13
14
例：分析下列程序的输出结果
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

&emsp;
&emsp;

1.4 位运算符

4.png5.png

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
例：分析下列程序的输出结果
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位

&emsp;
&emsp;

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. 其他七种类型如果能自动转换则可直接赋值，否则要进行强制类型转换。

&emsp;
&emsp;

1.6 条件运算符

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
例:  条件运算
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

&emsp;
&emsp;

二、 运算符的优先级

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

6.png

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

表达式写法的习惯：

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

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

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

&emsp;
&emsp;

三、 数据类型转换

3.1 自动类型转换

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

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

7.png

1
2
3
4
5
6
7
8
9
10
下列代码会编译出错，提示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

&emsp;
&emsp;

3.2 手动强制类型转换

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

注意：

  1. 强制类型转换可能造成信息的丢失；
  2. 布尔型与其它基本类型之间不能转换。
1
2
3
4
5
6
7
8
加上强制类型转换，下列代码编译通过。
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）参与运算的两个数据如果类型不一样，会先把低级的数据转换成高级的类型的数据后再作运算，结果是高 级的类型。

&emsp;
&emsp;

3.3 隐含强制类型转换

Java中允许把int类型的常量赋给byte、short变量时不需要强制类型转换
byte b=123;//合法
short s=123;//合法
b=b+3; //不合法
&emsp;
但是把int类型的变量赋给byte、short类型的变量时必须强制转换，否则会出错
int i=123;
byte b=i; //正确的做法是byte b=(byte)i;
byte a = 1; byte c = (byte)(a + b);

练习
设x,y,a分别为float,double,byte型变量，x=3.3,y=2.9,a=5, 则表达式x+ (int)y/ 3*a的值为多少？值的类型是什么？

&emsp;
&emsp;
&emsp;
&emsp;