java运算符、类型转换与流程控制语句

本文详细介绍了Java中的基本运算符,包括算术运算符、自增自减运算符、赋值运算符、复合赋值运算符、比较运算符、逻辑运算符、位运算符以及三目运算符,并解释了数据类型转换的概念。此外,还涵盖了Java中的表达式及流程控制语句,如if分支语句、switch语句和各种循环结构。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

《java运算符、类型转换与流程控制语句》

1.运算符

1.1  算术运算符

算术运算符:+,-,*,/,%(取余)

1.1.1          加运算(+)

1)  数字相加,与数学类似

2)  字符参与运算,先查出字符在码表中的值,再进行相加

3)  字符串参与运算,+号作为连接符

注:加运算结果超出定义数据类型的范围,就会产生数据类型的提升或转换。

数据类型转换又分为隐式转换和显式转换(后面详讲)两种方式。

1.1.2          减运算(-)

1) 数字相加,与数学类似

2) 字符参与运算,先查出字符在码表中的值,再进行相加

1.1.3          乘运算(*)

1)数字相乘,与数学类似

1.1.4          除运算(/)

1)  整数相除取商,没有小数

2)  除数与被除数只要有一个是小数,结果为小数

3)  除数不能是0,报错。违背除法规则

1.1.5          取余运算(%)

    1)%(取模/取余) 结果的正负由 左边的数据的正负决定

public static void main(String[] args) {
        // + 数字相加
        System.out.println(5+5); //10
        //+  数字与字符相加,先查出字符在码表中的值,再进行相加,
        //字符'a'是char类型,占16bit,2byte,5是int占32bit,4byte,这里有数据类型的提升
        System.out.println('a'+5);//102
        //+  数字与字符串相加,+号作为连接符
        System.out.println("I am is "+5);//I am is 5
       
        //- 减运算
        System.out.println(5-4); // 1
        //- 与字符做减运算,原理与加运算一样
        System.out.println('A'-5); // 60
      
        //* 乘运算
        System.out.println(5 * 4); //20
       
        // / 除运算整数相除取商,没有小数
        System.out.println(5/5); // 1
        System.out.println(5/2); // 2
        // 除数与被除数只要有一个是小数,结果为小数
        System.out.println(10/3); // 3
        System.out.println(10.0/3); // 3
        System.out.println(10/3.0); // 3
        System.out.println(6.6/2); // 3.3
        System.out.println(6/2.0); // 3.0
        // /除运算,除数不能是0,违背除法规则
        // System.out.println(5/0);  报错
       
        // %(取模/取余)结果的正负由左边的数据的正负决定
        System.out.println(10%3); // 1
        System.out.println(-10%3);// -1
        System.out.println(10.5%-2);// 0.5
        System.out.println(-10.5%5);// -0.5
}

1.2自增(++)和自减(--)

运算符:++,--

自增与自减运算符是单目(一个数据参与运算)运算符,可以放在操作数之前,也可以放在操作数之后。操作数必须是一个整型或浮点型变量。自增与自减的作用是使用操作数的值增1或减1。

1)放在操作数前面的自增、自减运算符,会先将变量的值加1(减1),然后再使该变量参与表达式的运算。

2)话在操作数后面的自增、自减运算符,会先使变量参与表达式的运算,然后再将该变量的值加1(减1)。

public static void main(String[] args) {
        int a = 5;
        int b;
        double c = 10.5d;
        double d;
        //运算符在前,先将变量加1(减1),再用变量参与表达式的计算
        b = ++ a; //变量+1,变量a=6,表达式为变量自增后的值 b=6
        System.out.println(a);//6
        System.out.println(b);//6
        d= --c;//变量-1,变量c=9.5,表达式为变量自减后的值 b=9.5
        System.out.println(c);//9.5
        System.out.println(d);//9.5
       
        System.out.println("********************************");
        int aa = 5;
        int bb;
        double cc = 10.5d;
        double dd;
        //运算符在后,先使用变量参与表达式的计算,再将变量加1(减1)
        bb = aa++;//表达式为变量自增前的值bb=5,再将变量+1,变量aa=6,
        System.out.println(aa);//6
        System.out.println(bb);//5
        dd= cc--; //表达式为变量自减前的值 b=10.5,再将变量-1,变量cc=9.5
        System.out.println(cc);//9.5
        System.out.println(dd);//10.5
}


1.3赋值运算符

赋值运算符以“=”表示,它是一个二目运算符(二个操作数)。功能是将其右方的操作数的值赋给左方的操作数。左方的操作数必须是一个变量,而右边的操作数可以是任何表达式,包括变量(a,b),常量(12,”123”),有效的表达式(如:4*5)。

“=”运算符处理结果时,要先获取其右方表达工计算后的值,所以当一个表达式中含有多个“=”运算符时,会从最右方的“=”开始处理。

public static void main(String[] args) {
        int a,b;
        int c;int d;
        a = 15;       //右边是常量,直接赋值
        b = a +5;    //右边是表达式,先计算出表达式的值
        d = c =b+10;//一个表达式中含有多个“=”运算符时,从最右方的“=”开始处理
        System.out.println(a);//15
        System.out.println(b);//20
        System.out.println(c);//30
        System.out.println(d);//30
       
    }

 

1.4复合赋值运算符

复合赋值运算符 += ,-=, *=, /=, %=  中间不能有空格

例:a += 5;即a = a+5;

    a -= 5;即a = a-5; 其他同理。

public static void main(String[] args) {
        int a = 3;
        a+=5;//大致相当运算a=a+5;
        System.out.println(a);
    
        short b = 3;
        //此处5是int,b到运算去中要提升为int,b+5的结果是int,而b本身是short,放不进去。显式转换数据类型
        b=(short)(b+5);
        System.out.println(b);
       
    }


1.5比较运算符(关系运算符)

比较运算符:>,<,==,>=,<=,!=

比较运算符的结果都是boolean型,结果为true,否则为false.

注意:比较运算符“==”不要和赋值运算符“=”混淆。

public static void main(String[] args) {
       System.out.println(5>3);  //true
       System.out.println(5<3);  //false
       System.out.println(5==3); //false,不要和=混淆
       System.out.println(5>=3); //true
       System.out.println(5<=3); //false
       System.out.println(5!=3); //true
    }


1.6逻辑运算符(布尔运算符)

逻辑运算符:&(单与),&&(短路与),|(或),||(短路或),!(非)

1.      &两边是整数时执行的是位运算,而两边是boolean值时执行的才是逻辑运算。结果是一个boolean

2.      &&&区别,&逻辑运算时两边都会计算的,而&&则在左边为假时则直接返的是false不再计算右边(又称短路)。

所谓短路计算,是指系统从左至右进行逻辑表达式的计算,一旦出现计算结果已经确定的情况,则计算过程即被终止。在程序设计时使用&&||运算符,不建议使用&|运算符。

3.   计算规则:

&:左右两边同时为true时,表达式结果为true,其余为false;

&&:计算结果和&一样,但如果左边结果为false,就不再计算右边。

|:左右两边同时为false时,表达式结果为false,其余为true;

||:计算结果和|一样,但如果左边结果为true,就不再计算右边。

!:取反,truefalse,falsetrue;

public static void main(String[] args) {
        //& 单与
        System.out.println(true &true); //true
        System.out.println(true &false);//false
        System.out.println(false &true);//false
        System.out.println(false &false);//false
        System.out.println("**********************");
        //&& 双与
        System.out.println(true &&true);  //true
        System.out.println(true &&false); //false
        System.out.println(false &&true); //false
        System.out.println(false &&false);//false
        System.out.println("**********************");
        //| 单或
        System.out.println(true |true);//true
        System.out.println(true |false);//true
        System.out.println(false |true);//true
        System.out.println(false |false);//false
        System.out.println("**********************");
        //|| 双或
        System.out.println(true ||true); //true
        System.out.println(true ||false);//true
        System.out.println(false ||true);//true
        System.out.println(false ||false);//true
        System.out.println("**********************");
       
        //! 非
        System.out.println(!true);//false
        System.out.println(!false);//true
    }
 

 

1.7 位运算

1.7.1 定义:位运算是以二进制位为单位进行的运算,其操作数和运算结果都是整型值。
操作数不能是字符串也不能是小数。
1.7.2 运算符:位与'&',位或'|',位非'~',位异或'^',右移'>>',左移'<<'0填充的右移'>>>' 
1.7.3 位运算的位与'&',位或'|',位非'~',位异或'^'与逻辑运算的相应操作的真值表完全相同,其差别只是位运算操作的操作数和运算结果都是二进制整数,而逻辑运算相应操作的操作数和运算结果都是逻辑值boolean型。
1) 位与'&' 同时为1才为1,其余为
2)位或'|' 同时为0才为0,其余为1
3)位非'~' 逐位取返,1001
4)位异或'^',相同为0,相异为1
   任何位与0异或'^',是该位的本身
   任何位与1异或'^',是该位的取反
   任何位与自己异或'^',结果为0
5<< 左移位,在低位处(右边)0
6>> 右移位,若为正数则高位(左加)补0,若为负数则高位(左边)补1
7>>> 无符号右移位,无论正负都在高位补0

public static void main(String[] args) {
       /*
        * 位与'&'同时为1才为1,其余为0
        *   0000 0110  6
        *                &
        *   0000 0011  3
        * -------------------
        *   0000 0010  2
        *
        */
       System.out.println( 6 & 3);//2
      
       /*
        * 位或'|'同时为0才为0,其余为1
        *   0000 0110  6
        *                |
        *   0000 0011  3
        * -------------------
        *   0000 0111  7
        *
        */
       System.out.println( 6 | 3);//7
      
       /*
        * 位非'~'逐位取返,1变0,0变1
        *   0000 0110  6(补码)
        *   1111 1001  ~6(补码)
        *  
        *   1111 1001  ~6(补码)
        *   1111 1000  ~6(反码)
        *   1000 0111  -7(原码)
        *
        */
       System.out.println(~6); // -7
      
      
       /*
        * 位异或'^',相同为0,相异为1
        *   0000 0110  6
        *                 ^
        *   0000 0011  3
        * -------------------
        *   0000 0101  5
        *
        */
       System.out.println( 6 ^ 3);//5
      
       /*
        * 任何位与0异或'^',是该位的本身
        */
        System.out.println(0 ^ 0);//0
        System.out.println(1 ^ 0);//1
        System.out.println(6 ^ 0);//6
        /*
         * 任何位与1异或'^',是该位的取反
         */
        System.out.println(0 ^ 1);//1
        System.out.println(1 ^ 1);//0
        System.out.println(6 ^ 1);//7
        /*
         * 任何位与自己异或'^',结果为0
         */
        System.out.println(0 ^ 0);//0
        System.out.println(1 ^ 1);//0
        System.out.println(6 ^ 6);//0
       
        /*
         *  << 左移位,在低位处(右边)补0
         *  0000 0011    3
         *  ---- ----    << 1
         *  00000 0110   6
         *   ---- ----
         *  
         *  0000 0011    3
         *  ---- ----    << 2
         *  00000 01100  12
         *    ---- ----
         * 
         */
        System.out.println(3<<1); //6,3*2*1
        System.out.println(3<<2); //12,3*2*2
       
       
        /*
         *  >> 右移位,若为正数则高位(左加)补0,若为负数则高位(左边)补1
         *  0000 0011    3
         *  ---- ----    >> 1
         *  0000 0001 1  1
         *  ---- ----
         *  
         *  0000 0011      3
         *  ---- ----      >> 2
         *  0000 0000 11  0
         *  ---- ----
         * 
         * 
         *  1000 0011    -3(原码)
         *  1111 1100    -3(反码)
         *  1111 1101    -3(补码)
         *  ---- ----    >> 1
         *  1111 1110 1  补码
         *  ---- ----
         *  1111 1101    反码
         *  ---------
         *  1000 0010   -2原码
         * 
         * 
         */
        System.out.println(3>>1); //1,3/(2*1)
        System.out.println(3>>2); //0,3/(2*2)
        System.out.println(-3>>1);//-2
       
        /*
         * >>> 无符号右移位,无论正负都在高位补0
         *  0000 0011    3
         *  ---- ----    >>> 1
         *  00000 0011   1
         *  ---- ----
         */
        System.out.println(3>>>1);//1

  }


 
1.7.4 位运算的应用:
根据位运算异或'^'的原理,我们可以来交换两个数的值,不借助第三方变量。

public static void main(String[] args) {
       //根据位运算异或'^'的原理,我们可以来交换两个数的值,不借助第三方变量
        int a= 5;
        int b= 10;
       //1.借助第三方变量
        int temp;
        System.out.println("交换前a的值:"+a+",b的值为:"+b);
        ////交换前a的值:5,b的值为:10
        temp = a;
        a = b;
        b=temp;
        System.out.println("交换前后的值:"+a+",b的值为:"+b);
        //交换前后的值:10,b的值为:5
       
       
        // 不借助第三方变量,使用位运算异或'^'
        int c= 10;
        int d= 20;
        System.out.println("交换前c的值:"+c+",d的值为:"+d);
        //交换前c的值:10,d的值为:20
        c = c^d;
        d = c^d;  // ===> (c^d)^d ===> c 任何位与自己异或'^',结果为0,任何位与0异或'^',是该位的本身
        c = c^d;  // ===> (c^d)^((c^d)^d) ===> d
        System.out.println("交换后c的值:"+c+",d的值为:"+d);
        //交换后c的值:20,d的值为:10
}


1.8三目运算符(三元运算符)

定义:条件运算符是唯一有3个操作数的运算符

格式:<表达式1>?<表达式2>:<表达式3>; 

       "?"运算符的含义是:先求表达式1的值,如果为真,则执行表达式2,并返回表达式2的结果 ; 如果表达式1的值为假,则执行表达式3,并返回表达式3的结果。

public static void main(String[] args) {
       System.out.println(true?"表达式二":"表达式三");//表达式二
       System.out.println(false?"表达式二":"表达式三");//表达式三
      
       System.out.println(20>10?true:false);//true
       System.out.println(20<10?true:false);//false
    }

 

2. 表达式

  2.1  是指用运算符连接起来的,符合java语法的式子。

  2.2  Java表达式的分类:

         算数表达式:20+10

         关系表达式:20>10

         逻辑表达式:20>10 && 10>5

         赋值表达式:a = 10

 2.3  条件表达式

          结果是boolean类型的表达式,结果要么是true,要么是false;

3.    数据类型的转换

Java 语言是一种强类型的语言。强类型的语言有以下几个要求:

1) 变量或常量必须有类型:要求声明变量或常量时必须声明类型,而且只能在声明以后才能使用。

2) 赋值时类型必须一致:值的类型必须和变量或常量的类型完全一致。

3)运算时类型必须一致:参与运算的数据类型必须一致才能运算。

但是在实际的使用中,经常需要在不同类型的值之间进行操作,这就需要一种新的语法来适应这种需要,这个语法就是数据类型转换。


在数值处理这部分,计算机和现实的逻辑不太一样,对于现实来说,1和 1.0 没有什么区别,但是对于计算机来说,1 是整数类型,而 1.0 是小数类型,其在内存中的存储方式以及占用的空间都不一样,所以类型转换在计算机内部是必须的。

在Java应用程序中,有时候需要对数据类型进行转换。这个转换包括显示转换与隐式转换。

(1)      隐式转换(自动转换):编译器自动完成类型转换,不需要在程序中编写代码; 
规则:从存储范围小的类型到存储范围大的类型。不会丢失数据精度 
具体规则:byte→short(char)→int→long→float→double. 

(2)      显示转换(强制转换):强制编译器进行类型转换,必须在程序中编写代码。

规则:从存储范围大的类型到存储范围小的类型。 该类型转换很可能存在精度的损失。 
具体规则:double→float→long→int→short(char)→byte. 

格式:(要转换的数据类型)被转换的值  如:(int)3.14

public static void main(String[] args) {
        //隐示转换
        short s = 250;
        int i = 520;
        float f;
        double d;
        f = s;
        d = i;
        System.out.println(s); //250
        System.out.println(i); //520
        System.out.println(f); //250.0
        System.out.println(d); //520.0
       
        // 显示转换(强制转换)
        double pi=3.1415;
        int num = (int)pi;
        System.out.println(num); //3 存在精度的损失
}

4流程控制语句

定义:控制语句即用来实现对程序流程的选择、循环、转向和返回等进行控制。控制语句用于控制程序的流程,以实现程序的各种结构方式。

4.1分支语句-if






 

4.2分支语句-switch






4.3循环结构-while


 


 


4.4循环结构-do-while

       


 


4.5  循环结构-for

 

 


4.6循环结构-循环嵌套

 
   
 

 

 

 

 

 
   
 
         

4.7 循环补充

 


4.8 break和continue

1. break 命令可以终止循环的运行,然后继续执行循环之后的代码(如果循环之后有代码的话)。在多层循环中,一个break语句只向外跳一层。

2. continue:是结束本次循环,进行下次循环.

3. breakcontinue不能单独使用,只能在循环中。switchcase里,只能用break,而不能用continue

4.break后面可以跟标签名,指定向哪个位置跳(用于多层循环跳出)。

public static void main(String[] args) {
        /*
         * break 或 continue
         */
        for (int i = 0; i < 5; i++) {
            if(i == 2){
                break; //结束循环
            }
            System.out.println(i+",");//0,1,
        }
       
        for (int i = 0; i < 5; i++) {
            if(i == 2){
                continue; //结束本次循环,执行下一次循环
            }
            System.out.println(i+",");//0,1,3,4,
        }
       
    }


从内层循环直接跳出外层循环的两种方式:

1)通过在外层循环外设置标签,内层循环直接break到标签位置处。

标签格式:标识符”:”(标识符+冒号)

2)使用boolean变量值进行条件控件。

public static void main(String[] args) {
        /*
         * 从内层循环直接跳出外层循环方式一
         */
        ok:
        for(int i=0;i<10;i++){
            System.out.println("********i=:"+i);
            for(int j=0;j<10;j++){
               System.out.println("********j=:"+j);
               if(j == 3)
               break ok;
            }
        }   
       
      System.out.println("****************");
     
      /*
       * 从内层循环直接跳出外层循环方式二
       * 使用boolean变量值进行条件控件
       */
      boolean f = false;
      for(int i = 0 ;i<5&&!f;i++){
          System.out.println("********i=:"+i);
          for(int j = 0 ;j<5;j++){
              if(j==3){
                  f=true;
                  break;
              }
              System.out.println("********j=:"+j);
          }
      }
    }


 

评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值