动力节点——运算符（二）

一 ：运算符

1，定义：运算符就是连接变量或者常量组成表达式。

2，分类

算术运算符

赋值运算符

关系运算符（比较运算符）

位运算符（按二进制位运算）

逻辑运算符

三元运算符

二：运算符——算术运算符

1，基础的：+   -  *  /         注意：/    整数除法，两数相除取商。

2，扩展的：%（取模、取余）        注意：两数相除取余。

3，特殊的（重点、难点）

++    自增（每次运算自+1）

--      自减（每次运算自-1）

eg：

class  TestDemo2{

        public  static  void  main(String[]  args){

                int  x=4;//定义变量x并赋值为4；及初始化。

                int  y=5;//定义变量y并赋值为5；及初始化。

                System.out.println(x + y);//输出变量x+y的值，加法运算，结果为9。

                 System.out.println(x - y);//输出变量x-y的值，减法运算，结果为-1。

                 System.out.println(x * y);//输出变量x*y的值，乘法运算，结果为20。

                 System.out.println(x / y);//输出变量x/y的值，除法运算，结果为0。

                 System.out.println(x % y);//输出变量x%y的值，模运算，结果为4。

        }

}

4，

++自增运算符

--自减运算符

A：单独使用

只要使用自增或者自减运算符，不和其它运算符混合使用。

如果自增运算符是单独使用，则放变量之前和之后，结果没有区别。

eg：

class  TestDemo3{

        public  static  void  main(String[]  args){

                int  x=4;//定义变量 x 并赋值为4，及初始化。

                //x++；//把自增运算符放到了被它修饰的变量之后。

                ++x；//把自增运算符放到了被它修饰的变量之前。

                System.out.println("x="+x);//输出变量 x 的值为5。

        }

}

B：自增或自减运算符和其它运算符混合使用

B_1:如果自增或自减运算符放到了被它修饰的变量之后，则先计算其他运算符，再计算

自增或自减。

B_2:如果自增或自减运算符放到了被它修饰的变量之前，则计算自增或自减，再计算

其它运算符。

eg：

class  TestDemo4{

        public  static  void  main(String[]  args){

                //使用自增运算符和赋值运算符混合使用。

                //自增或自减运算符放后面。

                //int   x=4；//定义变量x并赋值为4；及初始化。

                //int  y=x++；//定义变量并赋x=4的值给y。因为计算自增运算符之前，把原值给y。

                //System.out.println("x="+x)；//输出变量x 的值为5.

                //赋值运算符运算完毕之后，再把x的本身值+1，所以x最终的值为5。

                //System.out.println("y="+y);//输出变量y 的值为4.

                //在计算自增运算符之前，先把x的原值给y，所以y 的值是4.

                //使用自增或自减运算符放前面

                int  x=4;//定义变量x并赋值为4；及初始化。

                int  y=++x;//定义变量并赋++x的值给y，其值是5，因为++x要先自增，所以返回的值是5。

                System.out.println("x="+x);//输出变量x 的值为5.

                //先计算自增运算符，所以x最终的值为5。

               

                 System.out.println("y="+y);//输出变量y 的值为5.

                //先计算自增，再计算赋值，所以最终y 的值为5。

        }

}

三 ： 自增运算符练习题

class  TestDemo5{

        public  static  void  main(String[]  args){

                //定义一个变量

                int  x=10；//定义 x 变量并赋值为10，及初始化。

                //计算一下算式有两个前提：

                // 1，一下算式的主运算符是加法。

                // 2，变量是开辟空间后，在运算过程中其值发生变化，不是在开辟空间。

                int  y=（x++   +1）（++x   +1）+10*x；定义  Y变量，计算结果之后再赋值。

                //            11                  12                x=12

                //            11                  13                10*x+24=144

                System.out.println("x="+x);输出变量  x  的值为12

                System.out.println("y="+y);输出变量   y  的值为144

        }

}

四：自增或自减的练习题

class  TestDemo6{

        public  static  void  main(String[]  args){

                //定义一个变量。

                int  i=1;//定义  i  变量并赋值为1，及初始化。

                //计算如下代码的前提：

                //  1，赋值运算符

                //    赋值运算符的运算过程一定是先把右边计算出结果

                //    再把值赋给左边

                //    2，自增或自减运算符再运算过程中，会把变量的原有值做缓存

                //    可以把  i++或++i作为一个计算式（即看成一个计算整体）

                //    如果是  i++；则这个整体的计算结果是把缓存中的1返回    i=1

                //    如果是  ++i；则把这个整体的计算结果，即2返回。           i=2

                //i=i++；//这两个用其中一个测试就可以了。

                i=++i；//定义  i变量，计算出结果再赋值。

                System.out.println("i="+i);//输出变量  i 的值为2

                //System.out.println("i="+i);//输出变量  i 的值为1

        }

}

五 ：赋值运算符

1，分类

=：基础的，把右边的值赋给左边。

扩展的：

+=    -=    *=    /=    %=

+=:把左右两边做加法，结果给左边。

-=：把左右两边做减法，结果给左边。

*=：把左右两边做乘法，结果给左边。

/=：把左右两边做除法（两数相除取商），结果给左边。

%=：把左右两边做除法，把余数给左边。

class  TestDemo7{

        public  static  void  main(String[]  args){

                int  x=4;//定义  x  变量并赋值为4，及初始化

                int  y1=5;//定义  y1  变量并赋值为5，及初始化

                        y1+=x;//定义变量 y1+=x 的值为9

               

                 int  y2=6;//定义  y2  变量并赋值为6，及初始化

                        y2-=x;//定义变量 y2-=x 的值为2

                

                int  y3=7;//定义  y3  变量并赋值为7，及初始化

                        y3*=x;//定义变量 y3*=x 的值为28

                    

                int  y4=8;//定义  y4  变量并赋值为8，及初始化

                        y4/=x;//定义变量 y4/=x 的值为2

                

                int  y5=9;//定义  y5  变量并赋值为9，及初始化

                        y5%=x;//定义变量 y5%=x 的值为1

                

                System.out.println("y1="+y1);//输出变量y1的值为9

                 System.out.println("y2="+y2);//输出变量y1的值为2

                 System.out.println("y3="+y3);//输出变量y1的值为28

                 System.out.println("y4="+y4);//输出变量y1的值为2

                 System.out.println("y5="+y5);//输出变量y1的值为1

        }

}

六：赋值运算符练习题

所有的赋值运算符的扩展运算符都隐含了强制类型转换

class  TestDemo8{

        public  static  void  main(String[]  args){

                //定义一个short变量

                short  x1=1;//定义  x1变量并赋值为1，及初始化

                //short  x2=x1+1;//可能出现损失精度，因为整数默认是int型。

                //System.out.println("x2="+x2);

                short  x3=1;//定义  x3变量并赋值为1，及初始化

                        x3+=x1；//x3=（short）（x1+1）隐含了强制类型转换。

                        //定义变量x3+=x1的值为2.

                        System.out.println("x3="+x3);//输出变量x3的值为2。

        }

}

七： 关系运算符（比较运算符）

== 相等于                ！=不等于

>大于                        >=大于等于

< 小于                       <=小于等于

insanceof（判定某个对象是否是某个类的实例，面向对象讲解）

注意：

1，比较运算符的结果都是布尔型。

2，一定不能把“==”写成“=”。

3，如果想表示3<=x<=5,在java中是没有这样写的语法

class  TestDemo9{

        public  static  void  main(String[]  args){

                //定义两个整型变量。

                int  x=4；//定义 x 变量并赋值为4，及初始化

                int  y=5；//定义 y 变量并赋值为5，及初始化

                System.out.println(x==y);//输出变量x==y的值为布尔型false

             

                System.out.println(x != y);//输出变量x != y的值为布尔型true

                

                System.out.println(x>y);//输出变量x > y的值为布尔型false

                

                System.out.println(x>=y);//输出变量x >= y的值为布尔型false

                

                System.out.println(x < y);//输出变量x <  y的值为布尔型true

                

                System.out.println(x <= y);//输出变量x<=y的值为布尔型true

        }

}

八： 逻辑运算符

1，分类

&  逻辑与（并且）        有false则false

|    逻辑或（或者）        有true则true

!    逻辑非（取反）        有true则false，有false则true

^异或                     有相同则false，不同则true

&&    短路与

||        短路或

2，每个逻辑运算符的运算因子都必须是布尔值。

3，逻辑运算符的结果必须是布尔值。

class  DemoTest{

        public  static  void  main(String[]  args){

                //定义四个整型变量

                int  x=4；//定义 x 变量并赋值为4；及初始化

                int  y=5；//定义 y 变量并赋值为5；及初始化

                int  m=6；//定义 m 变量并赋值为6；及初始化

                int  n=7；//定义 n 变量并赋值为7；及初始化

                //逻辑与

                System.out.println((x>y)&(m>n));//输出布尔值false

                 System.out.println((x>y)&(m<n));//输出布尔值false

                 System.out.println((x<y)&(m>n));//输出布尔值false

                 System.out.println((x<y)&(m<n));//输出布尔值true

                //逻辑或

                 System.out.println((x>y) | (m>n));//输出布尔值false

                 System.out.println((x>y) | (m<n));//输出布尔值true

                 System.out.println((x<y) | (m>n));//输出布尔值true

                 System.out.println((x<y) | (m<n));//输出布尔值true

                //逻辑非

                 System.out.println(！(x>y) );//输出布尔值false          取反true

                 System.out.println(！（x<y）);//输出布尔值true        取反false

                //逻辑异或

                 System.out.println((x>y)^ (m>n));//输出布尔值false

                 System.out.println((x>y) ^ (m<n));//输出布尔值true

                 System.out.println((x<y) ^ (m>n));//输出布尔值true

                 System.out.println((x<y) ^ (m<n));//输出布尔值fals 

        }

}

4,短路逻辑运算的规则：

&& 短路与

左边的运算因子如果是false，则右边的运算因子不再运算，结果是false。

如果左边的运算因子结果为true，则需要继续运算右边的运算因子。

逻辑与是肯定两边的计算因子都需要计算结果。

||  短路或

左边的运算因子如果是true，则右边的运算因子不再运算，结果是true。

如果左边的运算因子结果为false，则需要继续运算右边的运算因子。

逻辑或是肯定两边的计算因子都需要计算结果。

class  DemoTest2{

        public  static  void  main(String[]  args){

                //定义两个变量

                int  x=4；//定义  x  变量并赋值为4；及初始化

                int  y=5；//定义  y  变量并赋值为5；及初始化

                

                //执行短路与

                boolean  m=（（++x==4）&&（++y==5））；

                //使用逻辑运算符比较x和y的值并返回一个布尔型值false。

                

                System.out.println("x="+x);//输出变量 x 的值为5

                System.out.println("y="+y);//输出变量 y 的值为5

                System.out.println("m="+m);//输出一个布尔值为false

                //执行短路或

                 boolean  m=（（++x==4）||（++y==5））；

                //使用逻辑运算符比较x和y的值并返回一个布尔型值false。

                

                System.out.println("x="+x);//输出变量 x 的值为5

                System.out.println("y="+y);//输出变量 y 的值为6

                System.out.println("m="+m);//输出一个布尔值为false

        }

}

九： 三元运算符

1，三元：就是这个运算符如果计算，则参与运算的因子必须是三个。

2，语法：

（比较表达式）？表达式1：表达式2

语法解释：

A，比较表达式的值必须是一个布尔值。

B，如果在1中是true，计算表达式1，则这个三元运算符就运算完毕

C，如果在1中是false，计算表达式2，则这个三元运算符就运算完毕

calss DemoTest4{

        public  static  void  main(String[]  args){

                //需求：

                //给两个整型变量，求这两个变量的最大值

                //按照需求定义两个int类变量并赋值及初始化

              

                  int  a=9；//定义 a 变量并赋值为9 ，及初始化

                int  b=5；//定义 b 变量并赋值为5 ，及初始化

                //使用三元运算符计算a和b的最大值，并把最值给c

                int  c=（a>=5）?a:b;

                //输出 c 的值

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

        }

}