1. Toy模板网首页
  2. > Toy博客

JavaSE-02【类型转换和运算符】

8月前 作者：AlluzeYu 分类：Toy博客 阅读(45) 违法举报

这篇具有很好参考价值的文章主要介绍了JavaSE-02【类型转换和运算符】。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

JavaSE-02【类型转换和运算符】

第一章：数据类型转换

Java程序中要求参与计算的数据，必须要保证数据类型的一致，
如果数据类型不一致则发生类型的转换

1.1 自动转换

  • 自动转换：将取值范围小的类型自动提升为取回范围大的类型
自动类型转换原理：

一个int变量和一个byte变量进行加法运算，结果会是什么数据类型？
运算结果：变量的类型将是int类型，这就出现了数据类型的转换
如下代码：

JavaSE-02【类型转换和运算符】

  • 案例：Demo01_DataType
/**
 * 当数据类型不一致时，将会发生数据类型转换
 *  自动类型转换：隐式
 *      1、代码不需要进行特殊处理，自动完成
 *      2、数据范围从小到大
 *  强制类型转换：显示
 *
 */
public class Demo01_DataType {
    public static void main(String[] args) {
        System.out.println(1000);   //输出一个整数，默认是int类型
        System.out.println(3.14);   //输出一个小数，默认是double类型


        //int--->long
        /*
            左边是：long类型，右边默认是int类型，左右不一样
            一个等号代表赋值，将右边的int常量100，交给左边long类型的变量进行存储
            int ---> long：符合数据范围从小到大的要求
            这一行代码发生了数据类型转换：由int转向long
         */
        //long num1 =100L;
        //System.out.println(num1);
        long num2 =100;
        System.out.println(num2);//100

        //float--->double
        /*
            左边是double类型，右边是float类型，左右不一样
            float---> double，符合从小到大的规则
            也发生了自动类型转换
         */
        double num3 = 3.3F;
        System.out.println(num3);//

        //long-->float
        /*
            左边是float类型，右边是long类型，左右不一样
            long-->float,范围是float更大些，符合从小打到的规则
            发生了自动类型转换
         */
        float num4 = 60L;
        System.out.println(num4);//60.0
    }
}

1.2 强制转换

  • 强制类型转换：将取值范围大的类型，强制转换成取值范围小的类型
强制类型转换原理:
	将1.55赋值给int类型的变量会发生什么？出现编译失败，无法赋值
	即：int a = 1.55;//编译失败

	double类型内存为8字节，int类型内存为4字节，
	1.55是double类型，取值范围大于int。

	可以理解为double是8L的水壶，int是4L的水壶，
	不能把大水壶中的水直接放在小水壶中去，

	想要赋值成功，只有通过强制类型转换，
	将double类型强制转换成int类型才能赋值，
  • 转换格式：
数据类型 变量名称 = (数据类型) 被转数据值;
  • 案例：
/**
 * 强制类型转换：
 *      特点：代码需要进行特殊格式的处理，不能自动完成
 *      格式：范围小的类型 范围小的变量名 = (范围小的类型) 原本范围大的数据;
 *
 *  注意事项：
 *      1、强制类型转换一般不推荐使用，因为有可能发生精度丢失、数据溢出
 *      2、byte/short/char这三种类型都可以发生数学运算，例如加法"+"
 *      3、byte/short/char这三种类型在运算的时候，都会被首先提升为int类型，然后再计算
 *      4、boolean类型不能发生数据类型转换
 */
public class Demo02_DataType {
    public static void main(String[] args) {
        //long--->int
        //左边是int类型，右边是long类型,不一样
        //不能发生自动类型转换:int num1 = 100L;
        //格式：范围小的类型 范围小的类型名 = (范围小的类型) 原本范围大的数据
        int num1 = (int)300000000L;
        System.out.println(num1);//300000000

        //double--->int 强制类型转换
        int num2 = (int) 3.88;
        System.out.println(num2);//3 注意：不是四舍五入，而是所有的小数都会被舍弃掉

        //char和int运算
        char c1 = 'a';//字符型变量c1，存放字符a
        System.out.println(c1+1);//98 小写字母a被当做97进行运算，
        //计算机的底层会使用二进制数字表示一个字符
        //一旦char类型参与运算，那么字符就会按照一定的规则翻译成一个数字

        //byte与byte执行加法运算，byte会先自动转化成int，再进行运算操作
        byte num3 = 60;//注意右侧的数据不能超过左侧数据类型的取值范围
        byte num4 = 30;
        //byte num5 = num3+num4;//编译会报错
        // byte+byte ---> int+int=int
        int num6 = num3+num4;
        System.out.println(num6);

        //short与byte的相加运算，byte和short都会转换成int类型之后，再参与运算
        short num8 = 40;
        byte num9 = 30;
        int num10 = num8+num9;
        short num11 = (short) (num8+num9);//num8+num9 先默认执行自动转型成int。然后再强制转换成short
    }
}
  • 注意事项
1、强制类型转换一般不推荐使用，因为有可能发生精度丢失、数据溢出
2、byte/short/char这三种类型都可以发生数学运算，例如加法"+"
3、byte/short/char这三种类型在运算时，都会被提升为int类型再计算
4、boolean类型不能发生数据类型转换

1.3 基本数据类型之间的关系图

JavaSE-02【类型转换和运算符】

第二章：运算符

2.1 算术运算符

JavaSE-02【类型转换和运算符】

  • 1、算术运算符----四则与取模运算
四则运算：加 减 乘 除
运算步骤：首先计算得到表达式的结果，然后再打印输出这个结果
除法运算：除法运算使用的是整除，
		 整数除以整数，结果仍然是整数，只看商值，不看余数
取模运算：即求余数。使用符号%。（取模只对于整数运算存在意义）
注意事项：运算中出现不同类型的数据，结果将是数据类型范围大的

public class Demo04_Operator {
    public static void main(String[] args) {
        //两个常量之间进行数学运算
        System.out.println(20+29);//49

        //两个变量之间进行数学运算
        int a = 22;
        int b = 33;
        System.out.println(a+b);//55

        //变量和常量之间混合进行数学运算
        int c = 50;
        System.out.println(c+50);//100

        //整数除法运算
        int d = 31;
        int e = 2;
        int result1 = d/e;
        System.out.println(result1);//商值：15

        //取模运算
        int result2 = d%e;
        System.out.println(result2);//余数：1

        //不同类型运算，结果会是数据类型大的那种
        double result3 = d+2.5;
        System.out.println(result3);//33.5
    }
}
  • 2、算术运算符----加号的多种用法
  1、对于数值来说，+号就是加法
  2、对于字符char类型:
  		在计算之前，char会被提升为int，然后再进行计算  
        char类型字符和int类型数字之间的关系表：ASCII和Unicode
  3、对于字符串来说，加号代表字符串连接操作，
  		任何数据与字符串连接，结果都会变成字符串
  4、优先级：括号的优先级最高，先运算括号中的内容
  • 3、案例
public class Demo05_Operator {
    public static void main(String[] args) {
        //字符串类型的变量使用格式
        //格式：字符串类型 字符串变量 = 数据值;
        String str1 = "qiaodan";
        System.out.println(str1);//qiaodan

        //字符串相加。即字符的连接
        System.out.println("Hello"+"World");//HelloWorld

        //String + int = String
        String str2 = "hello";
        int num1 = 22;
        System.out.println(str2+num1);//hello22

        //优先级:括号的优先级大于其他
        String str3 = "James";
        System.out.println(str3+10+10);//James1010
        System.out.println(str3+(10+20));//James30
    }
}
  • 3、算术运算符----自增自减运算
1、自增符号：++
2、自减符号：--
3、基本含义：让一个变量增长一个数字1，让一个变量减少一个数字1 
4、使用格式：写在变量之前，或写在变量之后；++a,a++,b--.--b
5、使用方式：  
   1)、单独使用：不和其他任何操作混合，自己独立成为一个步骤 
   2)、混合使用：和其他操作混合
6、使用区别： 
   1)、在单独使用的时候，前++和后++没有什么区别，
   	   也就是 ++a,a++是一样的 
   2)、在混合使用的时候，区别如下：    
       区别1：如果++在前，变量会立刻加1.拿着结果进行运算。
       		 【先自增后运算】 
       区别2：如果++在后，变量首先使用本值参与运算，然后变量再加1。
             【先运算后自增】
7、注意事项：只有变量才能自增，自减运算符，常量不可以

public class Demo06_Operator {
    public static void main(String[] args) {
        //单独使用
        int num1 = 100;
        System.out.println(num1);//100
        ++num1;// ++在前
        System.out.println(num1);//101
        num1++;// ++在后
        System.out.println(num1);//102

        System.out.println("-----------------------------");

        //混合使用 ++在前
        int num2 = 200;
        //变量先+1,然后打印结果
        System.out.println(++num2);//201
        System.out.println(num2);//201

        System.out.println("-----------------------------");

        //混合使用 ++在后
        int num3 = 300;
        //变量选运算，//运算结束后在+1
        System.out.println(num3++);//300
        System.out.println(num3);//301

        System.out.println("-----------------------------");

        //混合运算--和赋值相结合1
        int num4 = 40;
        //前--。变量立刻-1.编程39.再赋值给result1
        int result1 = --num4;
        System.out.println(result1);//39
        System.out.println(num4);//39

        System.out.println("-----------------------------");

        //混合运算--和赋值相结合2
        int num5 = 50;
        //后--，变量先把原来的值50赋值给result2.然后-1，变成49
        int result2 = num5--;
        System.out.println(result2);//50
        System.out.println(num5);//49

        System.out.println("-----------------------------");

        //++ . --混合
        int x = 22;
        int y = 33;
        int result3 = x++ + --y;
        System.out.println(result3);//54
        System.out.println(x);//23
        System.out.println(y);//32
    }
}

2.2 赋值运算符

  • 赋值运算符
概念：就是将符号右边的值，赋值给符号左边的变量

JavaSE-02【类型转换和运算符】

 赋值运算符：
   基本赋值运算符：单个“=”，代表将右侧的数据交给左侧的变量保存。如：int a = 10;
   复合赋值运算符：
       +=  a+=1    等价于     a=a+1
       -=  b-=2    等价于     b=b-2
       *=  c*=3    等价于     c=c*3
       /=  d/=4    等价于     d=d/4
       %=  e%=5    等价于     e=e%5
  注意事项：
   	1、只有变量才能使用赋值运算符，常量不能进行赋值
   	2、复合运算符其中隐含了一个强制类型转换

    public static void main(String[] args) {
        int a = 5;
        a+=5;//即：a=a+5,也就是变量a先加5，再赋值给变量a
        System.out.println(a);//输出结果是10
    }
  • 练习 Demo07_Operator
/**
 * 赋值运算符：
 *  基本赋值运算符：单个“=”，代表将右侧的数据交给左侧的变量保存。如：int a = 10;
 *  复合赋值运算符：
 *      +=  a+=1    等价于     a=a+1
 *      -=  b-=2    等价于     b=b-2
 *      *=  c*=3    等价于     c=c*3
 *      /=  d/=4    等价于     d=d/4
 *      %=  e%=5    等价于     e=e%5
 * 注意事项：
 *  1、只有变量才能使用赋值运算符，常量不能进行赋值
 *  2、符合运算符其中隐含了一个强制类型转换
 */

public class Demo07_Operator {
    public static void main(String[] args) {
        // +=练习
        int a = 10;
        a+=5;//a = a + 5  a=15
        System.out.println(a);//15

        // -= *= /+同上

        //%=练习
        int b = 11;
        b%=3;//b = b % 3  b=2
        System.out.println(b);//2

        //隐含强制类型转换
        byte c = 5;
        //byte c = c + 5
        //byte c = byte + int
        //byte c = int + int
        //byte c = int
        //byte c = (byte) int
        c+=5;
        System.out.println(c);//10
    }
}

2.3 比较运算符

  • 比较运算符
概念：两个数据之间进行比较的运算，运算结果都是布尔值，
     即true或者false

JavaSE-02【类型转换和运算符】

  • 注意事项
  1、两个等号== 表示比较符号两边数据是否相等，单个 = 表示复制
  2、比较运算符的结果一定是boolean值，成立是true，否则是false     
  3、如果进行多次判断不能连着写

  • 练习 Demo08_Operator

    public class Demo08_Operator {
    public static void main(String[] args) {
        //常量比较
        System.out.println(10 > 5);//true
        System.out.println(5.5 < 1.5);//false

        //变量比较
        int num1 = 10;
        int num2 = 20;
        System.out.println(num1 > num2);//false

        //混合使用
        System.out.println(num1 >= 10);//true
        System.out.println(num1 <= 10);//true
        System.out.println(num2 == 20);//true
        System.out.println(num2 != 30);//true

        //多次判断不能连着写
        int num3 = 30;
        //System.out.println(20<num3<40);//编译错误
    }
}

2.4 逻辑运算符

与 && 全部是true，才是true，否则是false
或 || 至少一个是true，就是true，全部是false，才是false
非 ！ 本来是true，变成false。本来是false，变成true 
逻辑运算符：
   与 （并且） &&  全为true，才是true。否则为false
   或 （或者） || 至少一个为true，即为true。全false。才false
   反  (取反) !  原本是true，取反为false，原本是false，取反为true
 
   注意事项：
       &&且 、||或，具有短路效果，
       即：如果左边可以判断得到最终结果，
       	   那么右边的代码将不再执行，从而提高性能
  • 练习 Demo09_Operator
public class Demo09_Operator {
    public static void main(String[] args) {
        //&&且
        System.out.println(true && true);//true
        System.out.println(true && false);//false
        System.out.println(false && false);//false

        //||或
        System.out.println(true || true);//true
        System.out.println(true || false);//true
        System.out.println(false || false);//false

        //取反
        System.out.println( !false);//true
        System.out.println( !true);//false

        //短路效果
        int a = 10;
        System.out.println(1 > 2 && ++a < 100);//false
        System.out.println(a);//10

        int b = 20;
        System.out.println(1 < 2 || ++b < 100);//true
        System.out.println(b);//20
    }
}

2.5 三元运算符

   一元运算符：只需要一个数据就可以操作的运算符。如：自增 自减
   二元运算符：需要两个数据才能操作的运算符。如：加法
   三元运算符：需要三个数据才能操作的运算符。
 
   三元运算符：
       格式：数据类型 变量名称 = 条件判断 ? 表达式A : 表达式B
       流程：首先判断条件是否成立：二选一
               条件成立为true，取表达式A的值赋值给左侧变量
               条件不成立为false。取表达式B的值赋值给左侧变量
 
   注意事项：
       1、必须同时保证表达式A和表达式B都符合左侧数据类型的要求
       2、三元运算符的结果必须被使用

练习 Demo10_Operator文章来源地址https://www.toymoban.com/news/detail-477334.html

public class Demo10_Operator {
    public static void main(String[] args) {
        int a = 30;
        int b = 40;
        //如果a>b为true。则将表达式a赋值给变量c。并输出
        int c = a > b ? a : b;
        System.out.println(c);//40

        //简化写法
        System.out.println(a < b ? a : b);//30
    }
}

2.6 运算符注意事项

  • byte、short、char的使用注意事项
1、对于byte、short、char三种类型来说，
   如果右侧赋值的数值没有超过范围，
   那么javac编译器将会自动隐含的为我们补上一个(byte)(short)(char)

2、如果右侧超过了范围，那么编译器就会报错

3、编译器的常量优化
   如果右侧的表达式中都是常量，没有任何变量参与运算
​   short result = 2+3; //等号右边全部是常量，没有任何变量参与运算
​   在代码编译之后等到的.class文件的结果是：
		short result = 5;(注意此时代码还没有运行)
​   这被称为是“编译器的常量优化”
   但是一旦表达式中出现变量参与运算，就不存在此种优化
  • 案例 Demo12_Notice
public class Demo12_Notice {
    public static void main(String[] args) {
        //1、右侧数据值没有超过左侧的范围
        //等号右侧确实是int类型，但是数据值没有超过左侧的范围，就是正确的
        //右侧的数据值不是int--转byte。不是自动类型转换
        byte num1 = /*(byte)*/33;//右侧数据值没有超过左侧的范围，编译器会自动隐含的补充一个(byte)
        System.out.println(num1);//33

        //2、右侧数据值超过了左侧的范围
        // byte num2 = 130;//编译报错

        //3、char
        // 右侧的数据值不是int--转char。不是自动类型转换，没有超出范围
        //编译器将会自动补充上一个隐含的(char)
        char c1 = /*(char)*/97;
        System.out.println(c1);//a

        //4、short
        short a = 1;
        short b = 2;
        short result1 = (short) (a+b);//变量相加，short会自动转为int，进行运算。左侧需要是int，或者强转
        short result2 = 1+2;// 数值相加，在编译期间就已计算完毕，即short result2 = 3;
    }
}

到了这里，关于JavaSE-02【类型转换和运算符】的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • javaSE___语法基础（关键字、标识符、数据类型、字符、字符串、运算符）

    javaSE___语法基础（关键字、标识符、数据类型、字符、字符串、运算符）

    一、的概述和使用 A:什么是 被Java语言赋予特定含义的单词 B:的特点 组成的字母全部小写 C:常见 public static void class等 D:的注意事项 goto和const作为保留字存在,目前并不使用,类似Editplus这样的高级记事本,针对有特殊的颜色标记，非

    2024年02月09日
    浏览(40)
  • 第02章_变量与运算符(关键字,标识符,变量,基本数据类型,进制,运算符,字符集)

    第02章_变量与运算符(关键字,标识符,变量,基本数据类型,进制,运算符,字符集)

    定义： 被Java语言赋予了特殊含义，用做专门用途的字符串（或单词） HelloWorld案例中，出现的有 class 、 public 、 static 、 void 等，这些单词已经被Java定义好了。 特点：全部都是 小写字母 。 比较多，不需要死记硬背，学到哪里记到哪里即可。 官方地址：

    2024年01月22日
    浏览(50)

  • 8大基本类型的转换和运算符

       ​       byte----short----int----long----float----double    ​       char----      - 自动/隐式类型转换：小类型到大类型      - 强制类型转换：大类型到小类型        ​    语法：(要转换成为的数据类型)变量        ​    强转有可能溢出或丢失精度      - 两点规则：  

    2024年02月02日
    浏览(42)
  • 【JAVA】数据类型，类型转换与提升，运算符，标识符命名规则

    【JAVA】数据类型，类型转换与提升，运算符，标识符命名规则

    🍉内容专 栏：【JAVA从0到入门】 🍉本文脉络：数据类型，类型转换与提升，运算符，标识符命名规则 🍉本文作者：Melon_西西 🍉发布时间 ：2023.7.12 目录  1. 字面常量 2. 数据类型:四类八种  3.类型转换 3.1 自动类型转换(隐式) 自动类型转换： 3.2 强制类型转换(显式) 强制类

    2024年02月15日
    浏览(43)
  • 〔002〕Java 基础之语法、数据类型、进制转换、运算符

    〔002〕Java 基础之语法、数据类型、进制转换、运算符

    注释： 是写在程序中对代码进行解释说明的文字，方便自己和其他人查看，以便理解程序的 注释分为 单行注释 和 多行注释 ，注释的内容并不会被编译，所以 不会影响 代码的运行 单行注释通过 // 进行标注，只能注释一行 多行注释通过 /* 注释内容 */ 进行标注，可以注释多

    2024年02月05日
    浏览(73)

  • C++的类型转换运算符：dynamic_cast

    顾名思义，与静态类型转换相反，动态类型转换在运行阶段（即应用程序运行时）执行类型转换。 可检查 dynamic_cast 操作的结果，以判断类型转换是否成功。使用 dynamic_cast 运算符的典型语法如下： 例如： 如上述代码所示，给定一个指向基类对象的指针，程序员可使用 dyna

    2024年02月15日
    浏览(39)
  • Python学习笔记(2)--字面量,注释,变量,数据类型,数据类型转换,标识符,运算符

    Python学习笔记(2)--字面量,注释,变量,数据类型,数据类型转换,标识符,运算符

    传送门==B站黑马python入门教程 1.字面量 字面量 : 代码中被固定写的值 python常用的6种数据类型为 数字,字符串,列表,元组,集合,字典 目前基础部分学习 字符串,整数,浮点数 即可 字符串 :(文本),由任意数量的 字符 (示例:中文/英文/各类符号/数组)组成; 在 python 中,字符串需要用双

    2024年02月11日
    浏览(51)

  • C++ operator关键字的使用（重载运算符、仿函数、类型转换操作符）

    C++ operator的使用（重载运算符、仿函数、类型转换操作符） C++11实用技术（一）auto与decltype的使用 C++11实用技术（二）std::function和bind绑定器 C++11实用技术（三）std::future、std::promise、std::packaged_task、async C++11 中，operator 是一个，用于重载运算符。通过重载运算符

    2024年02月14日
    浏览(41)
  • 【JAVASE】带你了解运算符奥秘（Java全部运算符）

    【JAVASE】带你了解运算符奥秘（Java全部运算符）

    ✅作者简介：大家好，我是橘橙黄又青，一个想要与大家共同进步的男人😉😉 🍎个人主页：橘橙黄又青-CSDN博客 目标： 熟练掌握各种运算符 废话不多说，我们直接开始。 基本四则运算符：加减乘除模 (+ - * / %) qt和c语言一样，但是取模运算符一点不同。 说明什么， 取模运

    2024年04月17日
    浏览(59)
  • 【JAVASE】运算符

    【JAVASE】运算符

    ⭐ 作者：小胡_不糊涂 🌱 作者主页：小胡_不糊涂的个人主页 📀 收录专栏：浅谈Java 💖 持续更文，关注博主少走弯路，谢谢大家支持 💖 计算机的最基本的用途之一就是执行数学运算，比如： 上述 + 和 等就是运算符，即：对操作数进行操作时的符号，不同运算符操作的含

    2024年02月15日
    浏览(34)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包