精华内容
下载资源
问答
  • Java中的隐式类型转换和显式类型转换
    千次阅读
    2021-03-10 10:32:34

    一、隐式类型转换

    隐式类型转换也叫做自动类型转换
    1、规则:
    从存储范围小的类型到存储范围大的类型。

    2、转换方向:
    byte→short(char)→int→long→float→double(这里指的是只有前面的数据类型能随便转换成后面的)
    —实际开发中这样的类型转换很多,但没有为这种转换提供专门的语法,都是由虚拟机自动完成。

    3、例子:
    byte b = 10;short sh = b;这里在赋值时,JVM首先将b的值转换为short类型,然后再赋值给sh。

    二、显式类型转换

    显式类型转换也叫做强制类型转换
    1、规则:
    从存储范围大的类型到存储范围小的类型。

    2、转换方向:
    double→float→long→int→short(char)→byte
    强制类型转换通常都会存储精度的损失,所以使用时需要谨慎。
    —需要在被转换值的前面添加个括号,括号里面写的是希望得到的数据类型。

    3、例子:
    int m = 1234;
    byte b = (byte)m;//-46
    解析:
    整数强制转换为整数时取数字的低位,例如int类型的变量转换为byte类型时,则只取int类型的低8位(也就是最后一个字节)的值。
    则m的值还是12345,而b的值为-10。b1的计算方法如下:m的值转换为二进制是10011010010,取该数字低8位的值作为b的值,则b
    的二进制值是11010010,按照机器数的规定,最高位是符号位,1代表负数,在计算机中负数存储的是补码,则该负数的原码是10101110,
    该值就是十进制的-46。

    附:
    补码算得原码:—百度百科
    算法1: 补码=原码取反再加1的逆运算
    10010110是补码,应先减去1变为反码,得10010101;
    由反码取得源码即除符号位外其他为按位取反,得11101010,即十进制数的-106

    算法2:负数补码速算法,由最低位(右)向高位(左)查找到第一个1与符号位之间的所有数字按位取反的逆运算
    10010110是补码,符号位与最后一个1之间的所有数字按位取反,得11101010

    注意:
    +=具有强转效果(short s = 1;s = s + 1;s += 1;前面的s=s+1会报错,因为s+1会先转换成int类型,然后再赋值给short类型,这样可能数据丢失;s+=1具有强转效果,相当于s = (short)(s+1),所以正确)

    更多相关内容
  • 显示类型转换和隐式类型转换

    千次阅读 2019-04-28 17:26:37
    显示类型转换 1.Number():函数把对象的值转换为数字,如果对象的值无法转换为数字,那么 Number() 函数返回 NaN。 var a = 'true'; console.log(typeof(Number(a)) + '-' + Number(a)); // number-NaN var ...

    显示类型转换

    1.Number():函数把对象的值转换为数字,如果对象的值无法转换为数字,那么 Number() 函数返回 NaN。

            var a = 'true';
            console.log(typeof(Number(a)) + '-' + Number(a)); // number-NaN
            var a = '1a';
            console.log(typeof(Number(a)) + '-' + Number(a)); // number-NaN
            var a = undefined;
            console.log(typeof(Number(a)) + '-' + Number(a)); // number-NaN
            var a = null;
            console.log(typeof(Number(a)) + '-' + Number(a)); // number-0
            var a = '123';
            console.log(typeof(Number(a)) + '-' + Number(a)); //number-123
            var a = true;
            console.log(typeof(Number(a)) + '-' + Number(a)); //number-1
    

    2.parseInt():函数可解析一个字符串,并返回一个整数

            var a = '3.14';
            console.log(typeof(parseInt(a)) + '-' + parseInt(a));//number-3
            var a = true;
            console.log(typeof(parseInt(a)) + '-' + parseInt(a));//number-NaN
            var a = null;//undefined,NaN
            console.log(typeof(parseInt(a)) + '-' + parseInt(a));//number-NaN
            var a='10';
            console.log(parseInt(a,16));//16
            var a='b';
            console.log(parseInt('abc123'));//NAN
            var a='b';
            console.log(parseInt('123abc'));//123 
    

    3.parseFloat():函数可解析一个字符串,并返回一个浮点数

    	    var a = 'b';
            console.log(parseFloat('3.1415')); //3.1415
            var num = parseFloat('3.1415')
            console.log(num.toFixed(2));//3.14  四舍五入
    

    4.String():函数把需要转换的值转换为字符串,并返回。

            console.log(typeof(String(123))); //string
            console.log(typeof(123 + '')); //string
    

    5.toString()

            var str = '3.14';
            console.log(str.toString()); //3.14
            var str = undefined; //null也没有toString()
            console.log(str.toString()); //报错
            var str = '100';
            console.log(parseInt(str, 2));//二进制100变十进制  4
            console.log(parseInt(str, 2).toString(16));//4
    

    6.Boolean()

            console.log(Boolean(1));//true
            console.log(Boolean(null));//false  NAN 空字符串 0 undefined null
    

    隐式类型转换

    +运算符内部会隐式调用String()

         var a = 'a' + 1; //String(1) 'a'+'1'=a1
         console.log(a) //a1
    

    运算符内部(-,*,/,%)会隐式调用Number()

         var a = '3' * 2; //* / - % str-->Number转换为数字
         console.log(a); //6
         var a = '1' > 2; //转换成Number >=<
         console.log(a); //false
         //转换成ASCII var a='a'>'b';
         var a=1=='1';
         console.log(a);//true
         var a=1==='1';//不进行隐式转换
         var a=NaN==NaN;//false
    

    内部会隐式调用Bollean()

         var a1=2>1>3;
         var a2=2>1==1;
         console.log(a1);//false
         console.log(a2);//true
         var a=undefined>0;//undefined和null既不大于0也不小于0 也不等于0
         var a=null==0;//false
         var a=undefined==null;//true
         var a=undefined===null;//false
         console.log(a)//false
    

    运算符内部(++/–,正负)会隐式调用Number()

         var a = '123';
         a++;
         console.log(a); //124
         var num='123';
         console.log(typeof(+num));//number
         var num='abc';
         console.log(typeof(-num)+':'+-num);//number:NaN
    

    isNaN() 需要经过Number()处理

         console.log(isNaN(NaN));//true
         console.log(isNaN(undefined))//true
         console.log(isNaN(null));//false
         console.log(isNaN('ab'));//true
         console.log(isNaN('null'));//true
         console.log(isNaN(1));//false
    

    经典面试题

    1.if(typeof(a) &&(-true) +(+undefined)+ ' '){
       //"undefined" && "NaN "  (-1+NaN+' ')
       console.log('通过了')
      }else{
       console.log('没通过')
      }
       console.log(a);
       //通过了
       //a is not defined
    

    未被定义的变量直接console.log会报引用错误,但是放在typeof里面不会出错。

    2.console.log(!!' '+!!''-!!false || '未通过');
    //1
    

    或运算符遇到一个条件为真就直接输出运算结果,遇到条件为假的情况就继续判断。
    分析:前面的’ ‘中是一个空格,空格是true,在两次!之后还是true,遇到+运算符转换为数字1,后面的’'是一个空字符串,它是false,两次!!后还是false,转换为数字0,由此可知,或运算符前面的计算结果是1,所以结果为1。

    3.window.a || (window.a = '1');
      console.log(window.a);
     //'1'
    

    分析:括号的面的优先级是最高的,先看括号里面的内容。

    4.var =???
      if(a == 1 && a == 2 && a == 3){
      console.log("1");
      }
    

    分析:与运算符条件条件全部为真才会输出运算结果。上述题中,a需要满足三个条件,此时应该想到复杂数据类型转换。
    复杂数据类型转number顺序如下:
    1.先使用valueOf()方法获取其原始值,如果原始值不是number类型,则使用 toString()方法转成string
    2.再将string转成number运算
    对象的valueOf()方法是可以重写的。

    var a = {
    i : 0,//声明一个属性i
    valueOf:function ( ) {
    return ++a.i;//每调用一次,让对象a的i属性自增一次并且返回
    }
    }
    if (a == 1 && a == 2 && a == 3){//每一次运算时都会调用一次a的valueOf()方法
    
    展开全文
  • java中显示类型转换和隐式类型转换

    千次阅读 2015-09-06 22:11:13
    在定义变量时,有许多要注意的问题,一不小心就会出现损失精度或者不兼容类型等问题。 例如:  1.定义长整型数据时,必须加后缀l或L  long l =123456789012345L  2.定义单精度类型时(7-8位有效数字),必须...

    在定义变量时,有许多要注意的问题,一不小心就会出现损失精度或者不兼容类型等问题。

    例如:

        1.定义长整型数据时,必须加后缀lL

                  long l =123456789012345L

        2.定义单精度类型时(7-8位有效数字),必须加后缀 f F

                  float f = 12.5F

              3. boolean类型不可以转换为其它的数据类型。

    这其中,我们常常会遇到数据类型的转换问题,最为常见的要属隐式转换和强制转换了,我们来分析一下。

    隐式转换

    特征:

    从小到大,可以隐式转换,数据类型将自动提升。

    byteshortchar -->int  -->long -->float -->double

    注意:long8个字节,float4个字节。

    long是整数,float是浮点型,整数和浮点数的存储规则不一样,记住一点long的范围是小于float的。

    :

    byte a=10;

    int b=a;

    当编译intb=a 时,  a隐式转换为int类型。

    强制转换

    特征:

         从大到小(如果你明确知道数据是可以用该数据类型来表示的,可以用强制转换)

    格式:

        (转换后的数据类型)变量或者值。

    注:一般情况下,根本不推荐使用强制类型转换。

               例1 :

    int a=10;

    byte b=(byte)a;

    当编译 byte b=(byte)a时, a被强制转换为byte类型。

    例2:

    1. class QiangZhiDemo  
    2. {  
    3.     public static void main(String[] args)  
    4.     {  
    5.         byte b=(byte)130;  
    6.         System.out.println(b);  //打印结果-126  
    7.     }     
    8. }  

    解析:

    数据130默认的是int类型的十进制数据,

    第一步:十进制130转换成二进制数据。

      10000010

    第二步:130在内存中的表示形式如下

    原码:0000000000000000 00000000 10000010

    第三步:求int130的补码

    因为130是正数,所以,反码和补码都和原码一致。

    补码:0000000000000000 00000000 10000010

    第四步:对补码进行截取,只剩下最后8位。

    (byte)130 的补码为:10000010

    第五步:把该补码转化为原码。

    由于符号位(第一位)是1,故该数为负数,

    反码:10000001     (补码-1)

    原码:11111110     (符号位不变,数据位取反)

    转化为十进制为 -126,所以最终打印-126

         3 :

    shorts = 1;

    s= s +1;                

    shorts = 1;

    s+=1;                        

    有问题吗?为什么呢?

         解析

    第一程序会报错:错误:不兼容的类型:从int转换到short可能会有损失

              

    原因:s=s+1;s+1会隐式转换为int类型,当把一个int类型赋值给short类型是,可能会损失。

    第二个程序可以编译运行。

             

    原因:s+=1,虽然可以看做s=s+1,但是还是有区别的,s+=1中有一个强制转换,s=(short)(s+1),会把s+1的值强制转换为short类型,故不会报错。

    小结:

    数据类型转换的问题如果发生在一些小程序上,我们或许能够一眼看出,可是当编写一个庞大的系统时,拥有庞大数据量时,这些小小的问题可能导致系统出错甚至崩溃,所以前期代码编写的严谨性就得靠我们自己把握了。



    展开全文
  • C++迭代器和显示类型转换

    千次阅读 2018-11-12 16:19:28
    前三个类型的转换是在编译的时候进行类型转换,最后一个则是在运行的时候进行类型转换,并可返回转换成功与否的标志。 2.1 reinterpret_cast **reinterpret_cast类型转换函数将一个类型的指针转换为另一个类型的...
    1. 迭代器
      其实迭代器很简单,没有我们想象中的那么复杂。以前要读写数据结构中的数据,一般是通过移动指针来进行的,但是在编写指针的过程中难免会出现野指针等情况出现,而且指针用起来也相对复杂。这时候,神奇的迭代器出现了。
      迭代器是指针的一个泛化,在容器和算法之间充当桥梁的作用。区别于指针,迭代器本身重载的“++”和“–”操作符,能够直接指向前驱和后继节点。
    2. 显式类型转换
      将一种类型转换成另一种类型,在程序中很常见,转换后的类型变量,它的内部存储方式一般也随之改变。C++提供了四种显式的类型转换操作函数reinterpret_cast、const_cast、static_cast和dynamic_cast。前三个类型的转换是在编译的时候进行类型转换,最后一个则是在运行的时候进行类型转换,并可返回转换成功与否的标志。
      2.1 reinterpret_cast
      **reinterpret_cast类型转换函数将一个类型的指针转换为另一个类型的指针。**这种转换不用修改指针变量值数据存放格式(不改变指针变量的值),也不能把const指针转换成void*指针,只需在编译时重新解释指针的类型就行。
    double d = 9.3;
        double *pd = &d;
        int *pi = reinterpret_cast<int* >(pd);  //相当于隐式转换int *pi = (int*)pd;
        class A{};
        class B{};
        A *pa = new A;
        B *pb = reinterpret_cast<B* >(pa);        //相当于隐式转换B* pb = (B* )pa;
        long j = reinterpret_cast<long>(pi);      //相当于long j = (long)pi;
    

    2.2const_cast
    const_cast用于去除指针变量的常量属性,将它转换为一个对应指针类型的普通变量,反过来也成立。

        const int* pci =0;
        int *pj = const_cast<int *>(pci);    //相当于int* pj = (int*)pci;
        const A* pca = new A;
        A* pa = const_cast<A*>(pca);    //相当于A* pa = (A*)pca;
    

    const_cast只是针对于指针操作,无法将非指针的常变量转换为普通变量。

        int* pi = 0;
        const int* pcj = const_cast<const int* >(pi);//将普通指针转换为常量指针
        int i=0;
        const int cj = const_cast<const int>(i);//非指针转换为const指针,不能通过编译!
        const int ck = (const int)i;//隐式转换,可通过编译
    

    2.3 static_cast
    static_cast一般用于基本类型之间和具有继承关系之间的类型转换,这种转换一般会更改变量的内部表示方式。一般不用于指针类型转换。

        int i = 0;
        double d = static_cast<double>(i);//将i的int型转换为double型然后赋值给d;
        int j = static_cast<int>(j); //将double型转换为int 型然后赋值给j;
        class Base{};
        class Derived:Base{};
        Derived d;
        Base b = static_cast<Base>(d);//将子类对象d转换为父类然后赋值给b;
    

    2.4 dynamic_cast
    与上面三个不同,dynamic_cast是在运行的时候进行转换分析的,上面三个是在编译时进行。
    dynamic_cast只能在继承类对象的指针之间或引用之间进行类型转换。进行转换时,会根据当前运行对象的运行时类型信息,判断类型对象之间是否转换合法。dynamic_cast的指针转换失败,可通过是否为null指针检测;引用转换失败则抛出一个bad_cast异常。

    #include <QCoreApplication>
    #include <iostream>
    #include<stdio.h>
    #include<typeinfo.h>
    using namespace std;
    int main(int argc, char *argv[])
    {
        QCoreApplication a(argc, argv);
        class Base{};
        class Derived:public Base{};
        //子类指针pd转化为父类指针pb
        Derived* pd = new Derived;
        Base* pb = dynamic_cast<Base* >(pd);
        if(!pb)
        {
            cout << "类型转换失败" << endl;
        }
        else
        {
            cout << "类型转换成功" << endl;
        }
        //子类引用转化为父类引用
        Derived d;
        Base& b = dynamic_cast<Base& >(d);
        //没有继承关系,但被转化的类有虚函数
        class A{
            virtual ~A(){}
        };
        class B{};
        A* pa = new A;
        B* pc = dynamic_cast<B* >(pa);//有虚函数的对象指针,可以转化
        if(!pc)
        {
            cout << "类型转换成功" << endl;
        }
        else
        {
            cout << "类型转换失败" << endl;
        }
        return a.exec();
    }
    

    运行结果:
    在这里插入图片描述
    dynamic_cast不只是应用于类型转换,**通常利用它做运行时对象类型检查的特性,在程序中检测当前内存对象的类型信息,**以决定下一步操作,使程序更灵活机动。

    展开全文
  • implicit/explicit cast (隐式/显示类型转换) TypeScript中可以显示表明对象的类型 . 转换一个类型到其它类型时可以使用符号, 如 <T>value . any类型可以转换成任意对象类型,反之亦然 . 看下面代码说明class A{ run...
  • 1.背景 在Java中,之所以需要强制类型转换是为了防止程序员在不知情的情况下把A类型数据错当成B类型的数据。将一种类型的值赋给另一个类型的变量是很常见的,如果这两种是兼容的,那么Java将执行自动转换,例如int...
  • 导入excell数据到Access,有一字段是文本,可是excel的文本导入却显示类型转换错误
  • 文章目录1 概述2 显式转换2.1 to_char2.2 to_date2.3 to_number3 隐式转换 1 概述 #mermaid-svg-fwPpwf4wV1eBbxmS .label{font-family:'trebuchet ms', verdana, arial;font-family:var(--mermaid-font-family);fill...
  • 显示转换(强制转换)与隐式转换

    万次阅读 2018-08-04 20:37:21
    在定义变量时,有许多要注意的问题,一不小心就会出现损失精度或者不兼容类型等问题。 例如:  1.定义长整型数据时,必须加后缀l或L  long l =123456789012345L  2.定义单精度类型时(7-8位有效数字),必须...
  • C#基础_操作符(T)x详解_类型转换

    千次阅读 2020-08-04 16:13:41
    C#基础_类型转换隐式(implicit)类型转换不丢失精度的转换子类向父类的转换装箱显式(explicit)类型转换有可能丢失精度(甚至发生错误)的转换 cast拆箱使用Convert类ToString方法与各数据类型的Parse / TryParse方法...
  • C#的隐式和显示类型转换

    万次阅读 多人点赞 2012-04-24 17:02:58
    一般常用到的场合,一种是写运算表达式的时候,要保持整体的数据类型一致和计算准确,比如有一个变量a是int型,但是它是通过加减乘除得到的,那么在运算中就要考虑用显示转换,除的运算需要转换成float或double,再...
  • C++显示类型转换

    千次阅读 2010-11-12 11:59:00
    reinterpret_cast,static_cast,const_cast,dynamic_cast等C++显示转换运算符
  • 自动类型转换

    万次阅读 多人点赞 2019-02-01 19:51:57
     在java 程序中,不同的基本类型的值经常需要进行相互类型转换类型转换分为自动类型转换和强制类型转换。布尔类型boolean占有一个字节,由于其本身所代码的特殊含义,boolean类型与其他基本类型不能进行类型的...
  • Oracle DB 隐式和显示数据类型转换

    千次阅读 2013-10-17 09:22:44
    但是,Oracle Server 会在内部将这些数据类型转换为Oracle 数据类型。 在某些情况下,Oracle Server 会收到数据类型与预期的数据类型不同的数据。发生这种情况时,Oracle Server 可自动将该数据转
  • 隐式类型转换,也称自动类型转换,是指不需要书写代码,由系统自动完成的类型转换。由于实际开发中这样的类型转换很多,所以Java语言在设计时,没有为该操作设计语法,而是由JVM自动完成。 1.2、转换规则 从存储范围...
  • 当两个数据类型不同进行算数运算时,会默认把存储空间小的数据类型转换成存储空间大的数据类型。 作用:为了更加精确数据类型。 实例:   #include int main() { printf("整型输出:%d\n', 1 + 2.0)...
  • C#中的数据类型转换总结

    万次阅读 多人点赞 2018-01-06 15:46:53
    初学c#经常为这几种数据类型转换方式而迷茫,为了彻底搞清它们之间的区别和优缺点,结合网上前辈总结的资料和自己的动手验证,在此写出来,一方面,为那些跟我有过相似经历的朋友们搜索资料的时候能提供一点微小的...
  • JAVA中显式类型转换和隐式类型转换

    千次阅读 2018-07-27 16:00:05
    自动类型转换(隐式类型转换),由系统自动完成的类型转换。从存储范围小的类型到存储范围大的类型。由于实际开发中这样的类型转换很多,所以Java语言在设计时,没有为该操作设计语法,而是由JVM自动完成。 转换...
  • C#中自定义类型转换

    千次阅读 2018-01-19 18:55:58
    类型转换
  • 不同数据类型之间的转换

    千次阅读 2022-01-20 20:46:21
    数据类型转换之隐式转换、显示转换 一、隐式类型转换(标准转换) 1、算术转换 在混合类型的表达式中,以最宽的数据类型为目标转换类型,如: int a = 3; double b = 1.12; //表达式 a+b a被转换为double类型 2、...
  • 8.智能指针、类型转换、转换函数等

    万次阅读 2020-03-23 23:20:32
    智能指针3.c++类型转换4.宏定义中#和##的作用5.static变量6.new和定位new运算符7. 类继承、虚函数以及运算符重载;v![在这里插入图片描述]...
  • mysql之类型转换函数

    万次阅读 2019-04-08 14:32:02
    类型转换函数 类型转换函数和case函数 1.隐式类型转换和显式类型转换的概念 隐式类型装换: 两个值进行运算或者比较,首先要求数据类型必须一致。如果发现两个数据类型不一致时就会发生隐式类型转换。例如,把字符串...
  • error C4576: 后跟初始值设定项列表的带圆括号类型是一个非标准的显式类型转换语法 解决方案: 在调用该函数的文件开始加上以下代码: char av_error[AV_ERROR_MAX_STRING_SIZE] = { 0 }; #define av_err2str...
  • typeof(数据)/ typeof 数据 判断数据的数据类型,typeof返回的都是字符串 输出结果类型有:number、string、boolean、 undefined、object、funct...
  • 基于最新Spring 5.x,详细介绍了Spring的类型转换机制,包括三种最常见的数据类型转换器PropertyEditor、Formatter、Converter、HttpMessageConverter、ConversionService等核心类。
  • 【golang】类型转换和类型断言

    千次阅读 2018-06-20 16:37:28
    【golang】类型转换和类型断言 类型断言是什么,类型断言和类型转换有什么区别,这个问题以前我也常常分不清楚。为了帮助和我有一样疑问的人,我决定得写一篇关于这方面的博文,介绍一下golang中的类型断言和类型...
  • ORACLE SQL数据类型转换

    千次阅读 2019-04-07 22:35:53
    ORACLE SQL数据类型转换 开发工具与关键技术:Oracle sql*plus PLSQL Developer 作者:张启翔 撰写时间:2019年3月25日 下面要说的是,如何将不同类型的数据进行转换处理 这里主要包括有三个函数 时间转换:...
  • Java之强制类型转换

    万次阅读 多人点赞 2019-01-04 18:58:24
    在之前的文章中介绍过,将一个类型强制转换为另一个数据类型的过程称为强制类型转换。本文即将介绍的是继承过程中发生的引用类型转换。  引用类型转换是指对象引用的强制类型转换,在了解对象引用的强制类型转换...
  • 数据类型-转换-隐式转换和显式转换

    千次阅读 热门讨论 2021-01-05 10:00:16
    数据类型转换分为隐式转换和显式转换,根据不同的转换对象,来确定是那种类型的转换。 隐式转换:就是系统默认的、不需要加以声明就可以进行转换。 首先来说在程序语言中默认的类型,一般整数是int类型 ,浮点数...
  • C#第二节(类型转换、变量、常量)

    千次阅读 2018-04-28 15:10:17
    一、C#类型转换 含义:把数据从一种类型转换为另一种类型(也...显示类型转换;即强制类型转换,其需要强制转换运算符,并且会造成数据丢失; 下面的demo 展示了显示类型转换: double d = 1265.66; int i; ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 962,711
精华内容 385,084
关键字:

显示类型转换

友情链接: cfw.rar