精华内容
下载资源
问答
  • java 基本数据类型及自动类型提升

    千次阅读 2016-04-30 17:49:43
    1.Java的8种基本数据类型及其所占空间大小: boolean 8bit/1byte byte 8bit/1byte char 16bit/2byte short 16bit/2byte float 32bit/4byte int 32bit/4byte long 64bit/8...

    1.Java的8种基本数据类型及其所占空间大小:

      boolean  8bit/1byte
          byte      8bit/1byte
          char      16bit/2byte
          short     16bit/2byte
      float      32bit/4byte
          int        32bit/4byte
          long      64bit/8byte
          double  64bit/8byte
     

    2.Java自动类型转换

         1)两种类型是彼此兼容的
         2)转换的 目的类型占得空间范围一定要大于转化的 源类型

      正向过程:由低字节向高字节自动转换

        byte->short->int->long->float->double

      逆向过程:使用强制转换,可能丢失精度。

         int a=(int)3.14;

    3. Java数据类型自动提升(注意以下讨论的是二元操作符)

        Java定义了若干使用于表达式的类型提升规则: 
       1) 所有的byte型. short型和char型将被提升到int型(例外: final修饰的short, char变量相加后不会被自动提升。)
       2)如果一个操作数是long形 计算结果就是long型;
       3)如果一个操作数是float型,计算结果就是float型;
       4)如果一个操作数是double型,计算结果就是double型;

        另一种归纳方式(《Java核心技术卷I》P43):   
      如果两个操作数其中有一个是double类型,另一个操作就会转换为double类型。
      否则,如果其中一个操作数是float类型,另一个将会转换为float类型。
      否则,如果其中一个操作数是long类型,另一个会转换为long类型。
      否则,两个操作数都转换为int类型。

        eg 1:
     1     Promote.java class promote 
     2     {  
     3         public static void main (string args[]) 
     4         { 
     5             byte b = 50;
     6             char c = 'a';
     7             short s = 1024; 
     8             int i = 50000; 
     9             float f =5.67f; 
    10             double d =0.1234; 
    11             double result = (f * b) + (i / c) - (d * s);        
    12          } 
    13      } 
         讲解:
          第一个表达式f * b中,b被提升为float类型,该子表达式的结果也提升为float类型。 
          第二个表达式i / c中,变量c被提升为int类型,该子表达式的结果提升为int类型。
          第三个表达式d * s中,变量s被提升为double类型,该子表达式的结果提升为double型。
          最后,这三个结果类型分别是float,int和double类型,想减后该表达式的最后的结果就是double类型。

        5) 黙认浮点类型为double,float数据类型有一个后缀为" f "或" F "。

        6) long类型有一个后缀,为" l " 或者" L "。

     eg 2:

    1   byte a = 1;
    2 
    3   byte b = 2;
    4 
    5   a = a+b;      //编译出错自动类型提升成int
    6 
    7   a += b;       //自加没有自动类型提升问题

      把高字节转成低字节,需要作强制类型转换. byte c=(byte)a+b;

     

    eg 3:

    1 byte b1=1,b2=2,b3,b6; 
    2 final byte b4=4,b5=6; 
    3 b6=b4+b5; 
    4 b3=(b1+b2);   //会发生编译错误
    5 System.out.println(b3+b6);

     第三行中,如果 b4 + b5 的值超出byte的范围(-128~127),第三句也会报编译错误。第三句不会报错,是因为final修饰符,会在编译阶段就确定了b4和b5的值,所以 b4 + b5在编译阶段的值就已经确定了,在不超出byte范围的情况下,不会出错,反之,同样会报错。

      第四行中,没有final修饰的变量相加后会被自动提升为int型,与目标类型byte不相容,需要强制转换(向下转型)。

     

    4. Java强制类型转换

         格式:目标类型 变量=(目标类型)源类型变量/常量
         eg:
            int i=5;
            byte j=(int)i;
         注意:在强制类型转换中目标类型和源类型变量的类型始终没有发生改变
         易错点:
            byte b;
            b=3;
            b=(byte)b*3     //编译出错,因为(byte)的运算级别比*高,所以会先转换b后再*3
            b=(byte)(b*3)   //正确
     
    参考博文: 
    http://blog.csdn.net/liang5630/article/details/37935383
    http://blog.sina.com.cn/s/blog_66e7f79b0100ysd3.html

     

    展开全文
  • Java自动类型提升与强制类型转换机制【详解】

    千次阅读 多人点赞 2019-03-17 19:17:51
    在深入学习Java的底层机制的过程中,数据类型的相互转换的结果往往并符合预期。在网上查阅资料和博客时,整型部分的转换还有参考价值,但一旦涉及到浮点类型,许多博文往往一笔带过,或者语焉不详。所以笔者决心写一...

    在深入学习Java的底层机制的过程中,数据类型的相互转换的结果往往并符合预期。在网上查阅资料和博客时,整型部分的转换还有参考价值,但一旦涉及到浮点类型,许多博文往往一笔带过,或者语焉不详。所以笔者决心写一篇详解,说明数据类型转换时内存中究竟发生了什么,又为何会出现类型转换后与预期不符的情况。

    由于文章内容大部分都是笔者自己的理解,或是查阅资料和博客后的总结,多多少少会有错误,请各位dalao斧正。

    另外,文中对浮点数的一些基础知识,没有过多的解释,如果对浮点数机制有所疑惑,请参考笔者的另一篇文章:

    深入理解Java浮点数机制:https://blog.csdn.net/Return_head/article/details/88623060

     

    正文

    Java中,经常可以见到类型转换的场景,数据类型转换在Java编码过程中占据着及其重要的地位。对于Java来说,数据类型转换大致可以分为三种,它们分别是:

    1.基本数据类型之间的转换;

    2.字符串与基本数据类型的转换;

    3.引用数据类型之间的转换。

    本文主要探讨基本数据类型转换的原理和底层实现。

     

    基本数据类型之间的转换

    Java中,共有八种数据类型

    byte,short,int,long,char,float,double,boolean

    按表示数据类型分类,大致可划分为数值型、字符型和布尔类型。它们具有各自不同的表征范围和底层实现。

    如何实现它们的互相转换和正确存储,就成为了一个必须解决的问题。

    按照日常编程的习惯,我们可以将基本数据类型之间的转换分为以下三种情况:

    1.低级类型到高级类型的自动类型提升;

    2.高级类型到低级类型的强制类型转换;

    3.包装类的拆装箱。

    本文中先抛开包装类的拆装箱问题。主要讨论基本数据类型的自动类型提升和强制类型转换。

    在开始探讨类型转换之前,我们首先需要认识一个词语——符号扩展Sign Extension

     

    符号扩展

    在编程或者笔试题目中,常常可能遇到这样一种情况。对于一个int类型的数,将其转换为byte类型后,得到的究竟一个正数还是一个负数呢?反之,将一个byte的负数转换为int类型,我们又怎样从底层去判断它最终的符号呢?要理解这两点,我们首先需要了解计算机中数的表示,以及Java中数据的转换方式。

     

    计算机中数的表示

    计算机中的数都是以补码的形式存储的,最高位单独作为符号位。正数的补码、反码都等于其二进制原码。而负数的补码等于其原码除去符号位外,按位取反再加1。知道这一点后,我们便能很清楚Java中各种类型的整型数据的范围是怎么得到的了。

    举个栗子。我们都知道,Java中byte类型占一字节,8比特位。那么它的取值范围为什么是-128~127呢?

    首先,对于byte类型,首位需要作为符号位,若符号位为1,就代表整个数为负数,符号位为0,就代表整个数为正数。其余7位。各能表示0B000_0000~0B111_1111(0~127)这个范围内的128个数。但这就带来了一个问题:当符号位为1或0的时候,各有一个0,即+0和-0。对于数学运算来说,若0的表示有两种,就会使得运算规则复杂化。所以我们就将负0(补码1000 0000)作为一个新的负数,其表示的值,是在原来该类型所能表示的最小负数的基础上再-1所得到的值。对于byte来说,这个值为-128。

    至此,我们就得到了byte的取值范围—— -128~127。(以上的过程,适用于所有整型数的范围计算,由于浮点型数据采用了另一种标准,所以其表示范围会有很大差别。)

     

    有了以上的表示后,另一个问题接踵而至:如何在进行类型扩展的时候,保持括号和数字的值不变呢?

     

    Java中的符号扩展(Sign Extension)

    什么是符号扩展?

    符号扩展,用于在数值类型扩展时扩展二进制的长度,以保证转换后的数值和原数值的符号、以及数值大小相同,一般用于较窄的类型向较宽的类型转换。扩展二进制的长度是指,在原数值的二进制位左边补齐若干个符号位(正数补0,负数补1)。

    再举个栗子。

    byte a = 15;

    a == 0B0000_0111

    若将其扩展为int类型,那么需要在其高8位补上0。

    最后得到int a = 0B0000_0000_0000_0111

    对于负数

    byte b = -15;

    b == 0B1111_1001(补码)

    若将其扩展为int类型,那么需要在其高8位上补上1。

    最后得到int a = 0B1111_1111_1111_1001(补码)

    将其转化为原码后得

    a = 0B1000_0000_0000_0111(原码)

     

    由此可见,符号扩展前后数值的大小和符号都保持不变

     

    自动类型提升

    当数据范围小的(低级的)数据向数据范围大的(高级的)数据转换时,无需进行特殊转换。编译器将会进行自动类型提升。

    在本文中我们将其分为四个部分进行介绍。

    1.整型数据的自动类型提升;

    2.字符型数据向整型数据的自动类型提升;

    3.整型数据向浮点型数据的自动类型提升。

    4.浮点型数据的自动类型提升;

     

    首先我们先来介绍整型数据相互之间的自动类型提升

    例一:低位正整数提升为高位正整数

    byte b = 64; //二进制表示:0100 0000

    short s = b; //二进制表示:0000 0000 0100 0000

    从该例可以看出,低位正数转向高位正数时,s的高地址补0。

     

    例二:低位负整数提升为高位负整数

    byte b = -64; //二进制表示:1100 0000

    short s = b; //二进制表示:1000 0000 0100 0000

    注意。这里并不说明低位负数转向高位负数时,s的高地址补1。

    实际上,所有的二进制整数在计算机底层都是以补码储存的。所以不管是正整数的自动类型提升还是负整数的自动类型提升,都是在对应补码前补0。由于正数的正、反、补码都一致,所以可以直接在高位补0。而负数需要转化为原码才能被我们识别。

    以例二为例。

    byte b = -64; //二进制原码表示:1100 0000

    byte b = -64; //二进制反码表示:1011 1111 (原码除符号位外按位取反)

    byte b = -64; //二进制补码表示:1100 0000 (反码+1)

    short s = b; //二进制补码表示:1111 1111 1100 0000 (符号位不变高位补1)

    short s = b; //二进制反码表示:1111 1111 1011 1111 (补码-1)

    short s = b; //二进制反码表示:1000 0000 0100 0000 (反码除符号位外按位取反)

     

    综上,byte向short提升,byte/short向int提升,byte/short/int向long提升,都遵循如下规则。

    正负整型类型数据,进行自动类型提升时,对补码进行符号扩展

     

    例三:char类型向高位整型提升

    char c = 32767; //二进制:0111 1111 1111 1111

    int a = c; //二进制:0000 0000 0000 0000 0111 1111 1111 1111

    在计算机中,所有的字符在底层都存储为整型,每个具体数字通过一张码表映射为具体的字符。

    在Java中,char类型字符集为unicode编码,char占 2个字节16位,可以表示0~65535这个范围中的65536个字符。

    所以char是无符号的,16位都用来表示数值大小。

    char类型无论被提升为int还是long,都进行零扩展(即高位补0)。

     

    介绍完了整型和字符型的自动类型提升。我们再来看看整型向浮点型数据进行自动类型提升的原理。

    要理解整型向浮点型的转换。首先我们需要了解浮点数在计算机中的存储方式。由于篇幅限制,这里不再赘述,不清楚的同学可以跳转我之前的《深入理解Java浮点数机制》一文简单了解。

     

    例四:int类型向float进行自动类型提升

    int a = 2147483647;//二进制:0111 1111 1111 1111 1111 1111 1111 1111

    float f = a; //二进制:0 10011110 0000000000000000000

    (注:32位浮点数float的底层存储:第1位是数符S(表示底数的符号),2~9位为阶码E,最后23位为尾数M。)

    要将a存放在浮点型数据f中,我们只需要将a对应的二进制数进行正规化处理,得到

    +1.1111 1111 1111 1111 1111 1111 1111 111 * 2^30

    由于尾数部分超出float类型的范围,需要先依据浮点数的舍入规则进行舍入

    由于第24位为1,且其后数值不全为0,故需要向第23位进位。

    10.0000 0000 0000 0000 000 * 2^30

    规范化得

    1.0000 0000 0000 0000 000 * 2^31

    然后分别得到其符号位、阶码和尾数

    符号位S = 0

    阶码E = 阶数 + 移码 = 31 + 127 = 158 =10011110

    尾数M = 底数去除整数部分1 = 0000000000000000000

    得到f的二进制表示

    0 10011110 0000000000000000000

    实际应该得到2.147483648E9

    但由于float型只能精确表示8位数字,故在Java程序中实际输出的值为2.14748365E9

     

    若是再将这个数强转为long输出,将会得到2147483648,这验证了本文上述的计算。

     

    (注意不要强转为int,在同一个空间进行自动类型提升和强制类型转换,会因为编译期优化而输出原来int类型存放的数字,而不是实际存储在float中的值。)

     

    其他类型的整数向浮点数的转换也同上述过程。但需要说明的是,byte/short/char转换为浮点型时,是通过int为跳板进行转换,即先转换为对应的int类型,再进一步转化为目标浮点类型。

     

    通过例五我们完成了整型数据向浮点类型的转换过程的探讨。现在我们继续介绍浮点类型进行自动类型提升的过程。

     

    例五:低位浮点类型向高位浮点类型的自动类型提升

    float f = 1.6; //二进制:1.1001100110011001100110011001...

    double d = f;

    首先说明一下float向double的自动类型提升规则:

    符号位 S :直接复制

    阶码 E:直接复制阶数,但注意移码有所不同。应该原阶码-127+1023才是正确的阶码

    尾数 M:直接复制原尾数,但由于double类型尾数为52位,所以需要在原尾数后补上29个0

     

    首先我们对1.6进行正规化

    f = 1.6 = 1.1001100110011001100110011001...(按浮点数舍入规则进行舍入)

    =1.10011001100110011001101 * 2^23

    符号位 S = 0

    移码 E = 23 + 127 = 150 = 10010110

    尾数 M = 10011001100110011001101

    得f的二进制表示

    0 10010110 10011001100110011001101

    所以实际f保存的值应该是约1.6000000238418579

    但由于float的精度限制,精确到小数点后七位,故实际输出1.6

    当f赋值给double类型数d时,根据前文的规则,得

    符号位 S = 0

    移码 E = 150 - 127 +1023 = 10000010110

    尾数 M = 1001100110011001100110100000000000000000000000000000

    又由于double类型可以精确的表示小数点后15位,故实际输出1.600000023841858

    下面我们结合程序验证上述计算是否正确。

    由此可见,前文对浮点数自动类型提升的计算和推论是正确的。

     

    通过以上五个例子,我们详细的介绍了自动类型提升时数据的底层转变。下面给出一张自动类型提升的方向图。自动类型提升只能严格按照以下方向进行提升。否则将会出现编译错误。

    需要注意的是,boolean类型不能与任何数值型以及字符型数据类型相互转换。

    学习完了自动类型提升的底层原理。我们继续研究强制类型转换时底层产生的变化。

     

    强制类型转换

    当数据范围大的(高级的)数据向数据范围小的(低级的)数据进行转换时,常常会出现丢失精度或者溢出的问题。如果直接进行转换,例如将一个long型的数赋值给int类型的变量,将会出现编译错误。

    所以,如果我们需要进行类似这样的操作,就需要用到强制类型转换。

     

    在Java中,存在两种不同类型的强制类型转换。

    1.显式的强制类型转换。

    2.隐式的强制类型转换。

     

    显式的强制类型转换

    显式的强制类型转换遵循以下格式。

    TYPE a = (TYPE) B;

    根据平时编程和使用的经验,笔者将显式的类型转换大概划分为三种情况。

    1.高位整型、字符型向低位整型、字符型的强制类型转换;

    2.浮点型向整型的强制类型转换;

    3.高位浮点型向低位浮点型的强制类型转换。

     

    首先我们来探讨整型与字符之间的强制类型转换。

    例六:

    long l = 12345678910; //二进制:0000 0000 0000 0000 0000 0000 0000 0010 1101 1111 1101 1100 0001 1100 0011 1110

    int i = (int)l; //二进制:1101 1111 1101 1100 0001 1100 0011 1110 —— -539222978

    char c = (char)l; //二进制:0001 1100 0011 1110 —— 7230

    short s = (short)l; //二进制:0001 1100 0011 1110 —— 7230

    byte b = (byte)l; //二进制:0011 1110 —— 62

    通过具体代码实现,我们验证了猜测。

    通过上述转换不难发现,整型向字符型的转换规则是

    若目标类型的长度小于源类型的长度,则在源类型低位直接截取目标类型的长度的数据。

    但在实际运算时需要注意以下两点:

    1.注意计算机里存储的数据都是补码存储的,需要变为原码才能转换为十进制。

    如例六中的变量i,截取l的低32位,得到了一个符号位为1的数,负数需要-1再按位取反才能得到正确的原码。

    实际上i的原码应该为1010 0000 0010 0011 1110 0011 1100 0010,也即-539222978。

    2.整型转化为char类型时需要特别注意,因为char类型是无符号的,所以不可能出现强制类型转换后输出为负的情况。所以同一个数强制类型转换为short和char时,可能会出现结果不同的情况(因为一个是有符号的,一个是无符号的)。

     

    说完了整型、字符型的强制类型转换,下面我们探讨一下浮点型向整型的强制类型转换规则。

    例七:

    float f = 12345678910111213141516;

    long l = (long)f;

    int i = (int)f;

    char c = (char)f;

    short s = (short)f;

    byte b = (byte)f;

    由于浮点数转换为整型的规则并非计算得到,所以我们这里直接给出结果

    这样的结果可能乍一看难以理解,但我们将其转为二进制,就能看出一些端倪了。

    l //二进制:0111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111

    i //二进制:0111 1111 1111 1111 1111 1111 1111 1111

    c //二进制:1111 1111 1111 1111

    s //二进制:1111 1111 1111 1111

    b //二进制:1111 1111

    实际上浮点数强制类型转换为整型的规则就是

    若不超过long或int的最大值,就省略小数部分直接赋值。

    若超过long或int的最大值,那么强制类型转换的结果就是long或int对应的最大值。

     

    另外,浮点型转换为byte/char/short时,需要先以int为跳板,即先转换为int。再按整型的强制类型转换规则,按目标类型长度截取低位数值。

    这里我们通过例八来演示一下不超过目标整型类型最大值时的浮点型向整型的强制类型转换。

    例八:

    float f = 12345.125;

    int i = (int)f;

    首先需要将f进行正规化

    f = 891011.125

    = +1101 1001 1000 1000 0011 . 001

    = +1.10110011000100000110010 * 2^22

    符号位 S = 0

    阶码 E = 10010101

    尾数 M = 1011001100010000011001

    f的二进制为 0 10010101 1011001100010000 110010

    若要强转为int类型

    则先进行对阶,得到f的整数部分

    11011001100010000011

    然后从低位至高位取截取32位,不够则进行符号扩展。

    得到32位int类型二进制数

    0000 0000 0000 1101 1001 1000 1000 0011

    即891011

    下面结合具体程序验证推算结果

    由此可知,浮点型强制转换为整型时,若没有超出对应整型的范围,则直接截取浮点数的整数部分进行赋值。

     

    最后,我们继续研究double向float的强制转换

    这里分为两种情况

    1.double数值在float允许范围之内

    2.double数值超出float允许范围

    由于float和double所能表示的范围太大,这里不再进行编码实验。直接说明这两种情况的结果。

     

    对于第一种情况。float将会直接获取符号位、阶数(这里需要将原阶码-1023再+127,因为float和double的移码不相同),并根据浮点数的舍入规则,将double类型52位的尾数舍入为float类型的23位尾数。

     

    对于第二种情况。首先需要说明的是,出现第二种情况往往是因为阶码部分超出表示范围,尾数只决定精度,阶码才决定范围。若出现这种情况,最后的结果将会输出Infinity或-Infinity,也即正无穷和负无穷。但这并不是数据上的无穷,只是因为浮点数存储机制带来的一种结果。

     

    以上,是笔者对显式的强制类型转换机制的一些认识。接下来我们简单介绍一下Java中的隐式强制类型转换。

     

    隐式的强制类型转换

    隐式的强制类型转换常发生在复制表达式和有返回值的函数调用表达式中。

    在赋值表达式中,如果赋值符左右两侧的操作数类型不同,则将赋值符号右操作数强制转换为赋值符号左操作数的类型,然后进行赋值。

    在函数调用时,如果return后面的表达式的类型与函数返回值类型不同,则在返回值时将return后的表达式的数值强制转换为函数返回值所定义的类型,再将返回值进行返回。

    需要注意的是,上述的强制转换只能当两个类型可转时才能进行。

    具体转换原理同显式强制转换对应内容。

     

    展开全文
  • 转载自 Java中的基本数据类型转换(自动、强制、提升)   说基本数据类型转换之前,先了解下 Java...自动类型转换是指:数字表示范围小的数据类型可以自动转换成范围大的数据类型。 如: long l = 100; int ...

    转载自 Java中的基本数据类型转换(自动、强制、提升)

     

    说基本数据类型转换之前,先了解下 Java 中的 8 种基本数据类型,以及它们的占内存的容量大小和表示的范围,如下图所示。

    重新温故了下原始数据类型,现在来解释下它们之间的转换关系。

    自动类型转换

    自动类型转换是指:数字表示范围小的数据类型可以自动转换成范围大的数据类型。

    如:

    long l = 100;
    
    int i = 200;
    long ll = i;

    具体自动转换如如下图所示。

    实线表示自动转换时不会造成数据丢失,虚线则可能会出现数据丢失问题。

    自动转换也要小心数据溢出问题,看下面的例子。

    int count = 100000000;
    int price = 1999;
    long totalPrice = count * price;

    编译没任何问题,但结果却输出的是负数,这是因为两个 int 相乘得到的结果是 int, 相乘的结果超出了 int 的代表范围。这种情况,一般把第一个数据转换成范围大的数据类型再和其他的数据进行运算。

    int count = 100000000;
    int price = 1999;
    long totalPrice = (long) count * price;

    另外,向下转换时可以直接将 int 常量字面量赋值给 byte、short、char 等数据类型,而不需要强制转换,只要该常量值不超过该类型的表示范围都能自动转换。

    强制类型转换

    强制类型转换我们再清楚不过了,即强制显示的把一个数据类型转换为另外一种数据类型。

    如:

    short s = 199;
    int i = s;// 199
    
    double d = 10.24;
    long ll = (long) d;// 10

    以上的转换结果都在我们的预期之内,属于正常的转换和丢失精度的情况,下面的例子就一样属于数据溢出的情况。

    int ii = 300;
    byte b = (byte)ii;

    300 已经超出了 byte 类型表示的范围,所以会转换成一个毫无意义的数字。

    类型提升

    所谓类型提升就是指在多种不同数据类型的表达式中,类型会自动向范围表示大的值的数据类型提升。

    把上面的溢出的例子再改下。

    long count = 100000000;
    int price = 1999;
    long totalPrice = price * count;

    price 为 int 型,count 为 long 型,运算结果为 long 型,运算结果正常,没有出现溢出的情况。

     

     

    展开全文
  • 自动类型转换

    万次阅读 多人点赞 2019-02-01 19:51:57
    布尔类型boolean占有一个字节,由于其本身所代码的特殊含义,boolean类型与其他基本类型不能进行类型的转换(既不能进行自动类型提升,也不能强制类型转换), 否则,将编译出错。  java的所有数值型变量可以...

    (一)自动类型转换

         在java 程序中,不同的基本类型的值经常需要进行相互类型转换,类型转换分为自动类型转换和强制类型转换。布尔类型boolean占有一个字节,由于其本身所代码的特殊含义,boolean类型与其他基本类型不能进行类型的转换(既不能进行自动类型的提升,也不能强制类型转换), 否则,将编译出错。

        java的所有数值型变量可以进行相互转换,如果系统支持把某种基本类型的值直接赋值给另一种基本类型的变量,则这种方式成为自动类型转换。

         当把一个表数范围较小的数值或变量直接赋给另外一个表数范围比较大的变量时,系统将可以自动类型转换,否则需要强制转换。

        图中箭头左边的数值可以自动转换为右边的数值。

           (2)byte型可以转换为short、int、、long、float和double; 
      (3)short可转换为int、long、float和double; 
      (4)char可转换为int、long、float和double; 
      (5)int可转换为long、float和double; 
      (6)long可转换为float和double; 
      (7)float可转换为double; 

     

    (二)基本类型转换为字符串

    不仅如此,把任何基本类型的值和字符串进行连接运算时,基本类型的值将自动转换成为字符串类型,虽然字符串类型不是基本类型,而是引用类型。因此,如果想将基本类型的值转换为对应的字符串,可以把基本类型的值和一个空字符串进行连接。

     

       (三)强制类型转换

         强制类型转换,即强制显示的把一个数据类型转换为另外一种数据类型。

        如果希望图中箭头右边的类型转换为左边的类型,则必须进行强制类型转换,强制类型转换的格式:

      (targetValuevalue

        强制类型转换的运算符是圆括号,当进行强制类型转换的时候,类似把一个大瓶里的水倒入一个小瓶子,如果大瓶子里的水不多还好,如果大瓶子了的水很多,将会引起溢出,从而造成数据丢失这种转换也被称为缩小转换。

    (四)表达式的自动提升

       当一个算数表达式中包含多个基本类型的值的时候 ,整个算数表达式的数据类型将发生自动提升。java定义了如下的自动提升规则:     1 所有的byte类型,short类型和char类型将被提升到int类型。     2 整个算数表达式的数据类型自动提升到与表达式中最高等级操作数同样的类

    (五)总结

    1    java中整数类型默认是int类型,小数类型默认是double类型。

    2    char可以当做一种特殊的整数类型

    3    int无法转换为boolean

    4    小数类型转为整数类型,小数可能被舍弃,出现精度损失,所以需要强制转换。

    5    boolean 类型不能转换为其它数据类型。

     

     

    展开全文
  • long count = 100000000; int price = 1999; long totalPrice = price * count;
  • 整个算数表达式的数据类型自动提升到与表达式中最高等级操作数同样的类型。 例1: short val = 5;  val = val -2 ; 编译时将报错 "Type mismatch: cannot convert from int to short",表达式中右边的val自动...
  • 我们都知道基本数据类型之间的自动转换遵循“小范围到大范围”,那么大范围的就一定不能自动转向小范围吗?答案是:在一定情况下是可以的。而且在实验中还意外地发现,java在处理算术表达式时,将算术表达式的数据...
  • 面向对象语言中仅仅有基本数据类型是不够的的,只有基本数据类型无法对他们进行基本的操作。这就诞生了将基本数据类型包装成类的手段,可以通过这些包装类的各种方法对他们进行各种骚操作。 1. 八种基本数据类型 ...
  • 整型提升是C程序设计语言中的一项规定:在表达式计算时,各种整形首先要提升为int类型,如果int类型不足以表示则要提升为unsigned int类型;然后执行表达式的运算。 上面的官方描述可以概括如下两点: 1.一个...
  • 在Java中从小到大,可以隐式转换,数据类型自动提升。下面以int为例 这么写是ok的 int a = 2312; long b = a; 那么在Kotlin中 //隐式转换,编译器会报错 val anInt: Int = 5 val ccLong: Long = anInt //...
  • Java基本数据类型类型转换

    千次阅读 多人点赞 2019-12-10 23:39:00
    本文关键字:8种、基本数据类型、整数类型、浮点类型、字符类型、布尔类型
  • Java自动类型转换和强制类型转换

    千次阅读 2014-11-03 21:40:22
    1.容量小的数据类型可以自动...2.数据自动类型转换: cast:转型 long型可以自动转换成float但是可能丢失精度。 int型转换为char型需要强制转型。 但是char型转成int是不需要强制转换。 3.表达式中类型提升问题。
  • C语言运算中的数据类型自动转换原则

    万次阅读 多人点赞 2014-03-14 17:19:20
     2、赋值表达式中,右边表达式的值自动隐式转换为左边变量的类型,并赋值给他。  3、函数调用中参数传递时,系统隐式地将实参转换为形参的类型后,赋给形参。  4、函数有返回值时,系统将隐式地将返回表达式类型...
  • (后续会进一步学习,略…) 2 数据类型 2.1 基本类型介绍(八种) 变量要保存值,这个值是存在内存中的,所以就需要向内存申请存储空间 java是一个强类型的语言 为了方便内存管理系统根据变量类型更加合理的分配内存空间...
  • 一、 自动类型转换(隐式类型转换) 整型、实型(常量)、字符型数据可以混合运算。运算中,不同类型的数据先转化为同一类型,然后进行运算。 自动转换从低级到高级。 自动转换有以下规律: 1、小的类型自动转化为...
  • java自动类型转换与强制类型转换

    千次阅读 2018-02-03 16:41:40
    我们知道数据类型有很多种,大小也不一样,就像水桶似的,有1升的,2升的,4升的,自动类型转换就相当于把小的水桶里面的水装到大的里面去。比如  int a = 10;  double b = a;  输出b是10.0;没...
  • Java数据类型转换

    千次阅读 2016-08-30 20:33:38
    类型A转换到类型B,这需要类型B拥有类型A的相关性质,他们之间的转换需要准从一定规则,并不是可以任意转换的,最基本的转换思想:只有同类可转换,低级转高级可自动转换,基本数据类型中高级转低级需要强制转换,...
  • MongoDB数据类型

    千次阅读 2018-04-03 11:33:53
    上篇文章我们介绍了...简洁和清晰的层次结构使得JSON成为理想的数据交换语言,JSON易于阅读和编写,同时也易于机器解析和生成,并有效地提升网络传输效率,但是JSON也有它的局限性,比如它只有null、布尔、数字、字
  • Schema与数据类型优化

    千次阅读 2019-11-17 17:40:21
    选择合适的数据类型 简单的几个原则: 更小的更好: 一般情况下,应该尽量使用可以存储数据的最小数据类型。更小的数据类型通常更快,占用更少的磁盘、内存和CPU缓存。 schema设计之初,应该估算出字段的数据能...
  • BSON及mongoDB数据类型

    万次阅读 2016-09-26 11:48:07
    JSON是一种被广泛使用的轻量级的数据...而近几年崛起的mongDB则采用了类JSON的数据格式,在JSON之上进行了丰富和增强,使得mongoDB可以处理及报错更大的数据类型。本文就2者进行描述同时给出mongoDB支持的数据类型
  • 类型转换 Java 语言是一种强类型的语言。...运算时类型必须一致:参与运算的数据类型必须一致才能运算。 但是在实际的使用中,经常需要在不同类型的值之间进行操作,这就需要一种新的语法来适应这种
  • SQL数据库字段数据类型说明

    千次阅读 2018-03-15 23:23:47
    日期和时间数据类型MySQL数据类型含义date3字节,日期,格式:2014-09-18time3字节,时间,格式:08:42:30datetime8字节,日期时间,格式:2014-09-18 08:42:30timestamp4字节,自动存储记录修...
  • JAVA语言语法_数据类型(part1)

    千次阅读 2021-10-08 10:25:41
    文章目录JAVA语言语法一、数据类型1、标识符2、关键字3、常量、字面常量4、变量的声明、赋值、使用(重点)5、变量的内存(重点)6、变量的作用域7、基本数据类型之整数类型存储8、基本数据类型之整数类型变量9、...
  • java的自动类型转换和强制类型转换

    千次阅读 2015-05-18 19:08:46
    一、自动类型转换 在 Java 程序中,不同的基本数据类型的数据之间经常需要进行相互转换。例如: , 代码中 int 型变量 score1 可以直接为 double 型变量 score2 完成赋值操作,运行结果为: 82.0  ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 293,087
精华内容 117,234
关键字:

数据自动类型提升