类型转换_类型转换异常 - CSDN
  • java基本数据类型之间的转换

    万次阅读 2019-01-23 13:35:29
    1、数据类型的分类     2、比较数据类型之间的字节大小 ...3、转换中的知识点 ...*java中整数类型默认的int类型;...字符串在转化成char类型是不能像int、float那样使用封装类的parseXXX方法等,但它可以转换成c...

     

    1、数据类型的分类

     

     

    2、比较数据类型之间的字节大小

                1字节=8位

    3、转换中的知识点

    *java中整数类型默认的int类型;小数类型默认的double;

    *String的字符串转化为char类型时,只能用char类型的数组来接收;字符串在转化成char类型是不能像int、float那样使用封装类的parseXXX方法等,但它可以转换成char类型的数组;
     自己心得:byte de=(byte) 128;System.out.println(de); 结果:-128
    //如果数字溢出当前的数字类型,有两种方法可以阻止其出错,一种是直接强转成 当前数据类型,另一种是转成其他的数据类型(较大的)

    //在进行数据类型转换时,两个char类型的数字相加强转成char时,会对应成字符编码里面的,但大多都会
     //出现乱码,一个char类型的数字,一个字符如‘a’相加,最后结果会对应字符编码里面的,并输出相对应的字符;
    //如果是提升为int类型时,不论是两个char类型的数字相加,还是一个char类型的字符和一个数字最后的结果都是数字 
     
    例如:  

    char c=12;
    char c1=12;
    char c4='a';
    char c5=28;
    char sa='a';
    char sa1='b';
    
    int c3=c+c1;
    int c7=c4+c5;
    
    char c2=(char) (c+c1); 
    
    char c6=(char) (c4+c5); 
    
    char sa3=(char) (sa+sa1);   
    
    System.out.println("**********");    
    System.out.println(c2);
    System.out.println(c6);
    System.out.println(sa3);
    System.out.println("**********");
    
    System.out.println(c3);
    
    System.out.println(c7);

    结果:

    *String的字符串进行类型转换时,如果字符串中包含long整形的字符大写L或者小写l时,在转换成字符串时,会出现错误

    例如:    String str="123L";
                  long str1=Long.parseLong(str); 
                  System.out.println(str1);//结果:错误

    *String的字符串是float、double浮点型时,字符串可以加f、F、D、d等,在进行基本类型转换时不会出错

     例如:   String f1="12.34f";

                  float f2=Float.parseFloat(f1); 

                  System.out.println(f2);//结果:12.34,;d、D也一样

        

    4、转换

    *自动类型转换(也叫隐式类型转换) ,其实就是小范围的数据类型向大范围的数据类型转换,例如int类型转long

    *强制类型转换(也叫显式类型转换) int b = (int)(i + j);

    *强制类型转换在某种情况下会丢失精度      

    *表达式的数据类型自动提升

    5进行四则运算时

    a、所有的byte型、short型和char的值将被提升到int型

    b、如果一个操作数是long型,计算结果就是long型

    c、如果一个操作数是float型,计算结果就是float型

    d、如果一个操作数是double型,计算结果就是double型

    e、如果一个操作数是String型,计算结果就是String型

    *面试陷阱

    byte b1 = 10;
    byte b2 = 20;
    //错误: 不兼容的类型: 从int转换到byte可能会有损失
    //否则,两个操作数都将转换为int类型。
    byte b3 = b1 + b2 //错误,b1+b2是int类型,java的整数默认类型为int,b3是byte类型,二者类型不同,所以出错
    byte b3 = (byte)(b1 + b2); //正确

    *面试陷阱2:

    short s1 = 10; 
    s1 = s1 + 12; //错误: 不兼容的类型: 从int转换到short可能会有损失
    
    short s2 = 10; 
    s2 += 12; // 等同于short s2 = (short)(s2 + (short)1); //正确
    展开全文
  • 在我们学习c语言的时候,就知道强制类型转换和隐式类型转换,但是在类型转换的过程中,很有可能一个不注意,容易出问题,这无疑是加大了,程序员的工作量,而且还检查很不好检查。 所以在c++ 中就对类型转换做...

    在我们学习c语言的时候,就知道强制类型转换和隐式类型的转换,但是在类型转换的过程中,很有可能一个不注意,容易出问题,这无疑是加大了,程序员的工作量,而且还检查很不好检查。

    所以在c++ 中就对类型的转换做了一定的限制,但是实际中大多数人,是在学习了c 语言后才学习 c++ 语言所以就用了 c 语言中的类型转换方式,那么今天我们介绍一下 c++ 中类型转换的方式,他们都是通过类模板的方式实现

    const_cast 把const强转成非const修饰

    在 c 语言中强转是可以把一个不想关的类型都可以强转,但是这样就很容易出问题,如果我们用了const_cast 如果要把两个两个不相关的类型的const转到非const是不行的。这样就限制了出错的概率,,增强了代码的可读性,但是实际中,大多数还是喜欢采用c语言,但是我们必须得知道。

        const int i = 10;//在c++中这样编译器会优化为寄存器变量用volatile
        int* j = const_cast<int*>(&i); // const 与非 const 转换

    static_cast 隐式类型转换

    什么是隐式类型的转换,隐式类型转换,就像c语言中我们可以把一个整型 int 赋值给一个 float 这就是隐式类型的转换。
    我们简单的写一个例子

    void test()
    {
        int i = 10;
        float j = i; // 在c语言中的隐式类型的转换
    
        // 用static_cast转换
        float j = static_cast<float>(i); 
    }

    这样写增强了代码的可读性

    reinterpret_cast 不相关类型转换

    这强制类型转换是就像 c语言中的强转。
    我们举一个例子:

    typedef void (* FUNC)();
    int DoSomething (int i)
    {
    cout<<"DoSomething" <<endl;
    return 0;
    }
    void Test ()
    {
    //
    // reinterpret_cast可以编译器以FUNC的定义方式去看待 DoSomething函// C++不保证所有的函数指针都被一样的使用,所以这样用有时会产生不
    确定的结果
    //
    FUNC f = reinterpret_cast< FUNC>(DoSomething );
    f(); 
    }

    这样我们就把一个函数赋值,还可以调用。

    dynamic_cast虚函数中的父类赋给子类的转化

    dynamic_cast用于将一个父类对象的指针转换为子类对象的指针或引用(动态
    转换)
    向上转型:子类对象指针->父类指针/引用(不需要转换)
    向下转型:父类对象指针->子类指针/引用(用dynamic_cast转型是安全的)

    这里用这种强转必须要虚函数的类,用dynamic_cast来转换父类付给子类的时候,有时候可以,有时候不行,这样用dynamic_cast 强转就会在转变的过程中去判断,如果可以把父类给子类就强转,如果不行就返回0.

    class A
    {
        public :
        virtual void f(){}
    };
    class B : public A
    {};
    void fun (A* pa)
    {
        // dynamic_cast会先检查是否能转换成功,能成功则转换,不能则返回
        B* pb1 = static_cast<B*>(pa);
        B* pb2 = dynamic_cast<B*>(pa);
        cout<<"pb1:" <<pb1<< endl;
        cout<<"pb2:" <<pb2<< endl;
    }
    int main ()
    {
        A a;
        B b;
        fun(&a);
        fun(&b);
        return 0;
    }

    强转
    红色标记的是强转失败,因为把父类赋给子类失败。强转就会判断是否成功。
    如果用c语言中强转可以成功,但是如果强转后,去访问有可能会访问越界。

    explicit关键字

    在强转中,对于单参数的构造函数,支持隐式类型的转换,所以当我们不需要隐式类型的转换的时候,我们就可以加上explicit关键字来防止,在构造函数的时候发生隐式类型的转换。
    单参数的类构造函数的隐式类型转换。

    class A
    {
    public :
        explicit A (int a)
        {
        cout<<"A(int a)" <<endl;
        }
        A(const A& a)
        {
        cout<<"A(const A& a)" <<endl;
        }
    private :
        int _a ;
    };
    int main ()
    {
        A a1 (1);
        // 隐式转换-> A tmp(1); A a2(tmp);
        A a2 = 1; // 这是因为单参数支持隐式类型转换
    }

    我们加上关键字后,用 = 来进行隐式类型转换,是编译不能通过的。
    编译不通过
    如果我们不加就可以通过。

    展开全文
  • 1.背景 在Java中,之所以需要强制类型转换是为了防止程序员在不知情的情况下把A类型数据错当成B类型的数据。将一种类型的值赋给另一个类型的变量是很常见的,如果这两种是兼容的,那么Java将执行自动转换,例如int...

    https://blog.csdn.net/czengze/article/details/52976820

    1.背景

          在Java中,之所以需要强制类型转换是为了防止程序员在不知情的情况下把A类型数据错当成B类型的数据。将一种类型的值赋给另一个类型的变量是很常见的,如果这两种是兼容的,那么Java将执行自动转换,例如int和long,将int类型赋值给long类型的变量,总是可行的。但不是所有的类型都兼容。例如,没有将double类型转换为byte型的定义。但是不兼容的类型之间的转换仍然是可能的。达到这个目的,就需要使用强制类型转换。完成两个不兼容类型的强制转换。

    2.自动类型转换和强制类型转换

          在Java中由于继承和向上转型,子类可以非常自然地转换成父类,但是父类转换成子类则需要强制转换。因为子类拥有比父类更多的属性、更强的功能,所以父类转换为子类需要强制。

          当我们用一个类型的构造器构造出一个对象时,这个对象的类型就已经确定的,也就说它的本质是不会再发生变化了。在Java中我们可以通过继承、向上转型的关系使用父类类型来引用它,这个时候我们是使用功能较弱的类型引用功能较强的对象,这是可行的。但是将功能较弱的类型强制转功能较强的对象时,就不一定可以行了。

    [java] view plain copy
    1. Father father = new Son();  
    2. Son son = (Son)father;  
    3. //编译出错,ClassCastException  
    4. Father father = new Father();  
    5. Son son = (Son) father;  
          在第一个例子中,father被指向一个子类对象,子类也可以指向子类对象。而第二个例子中,father被传给一个父类对象,子类引用不能指向父类对象。即很重要的概念是:父类引用指向子类对象。将父类转换为子类之前,应该用instanceof检查。
    [java] view plain copy
    1. static class One {  
    2.     public void foo() {  
    3.         System.out.println("One");  
    4.     }  
    5. }  
    6. static class Two extends One {  
    7.     public void foo() {  
    8.         System.out.println("Two");  
    9.     }  
    10.     public void dosth(){  
    11.         System.out.println("Two again");  
    12.     }  
    13. }  
    14. public static void main(String[] args) throws Exception{  
    15.     One t = new Two(); //向上转型,即父类引用指向子类对象,此时子类对象的类型为父类的类型  
    16.     t.foo();  
    17.     t.dosth();//编译错误  
    18.     t = (Two)t;   
    19.     t.dosth();//编译错误   
    20.     ((Two) t).dosth();//编译成功  
    21. }  

    向上转型是安全的,但是会有些子类特性会丢失,向下转型可以成功。

          总结:父类引用可以指向子类对象,子类引用不能指向父类对象。把子类对象直接赋给父类引用叫做向上转型,向上转型不用强制转型,如Father f1=new Son(),把指向子类对象的父类引用赋给子类引用叫做向下转型,要强制转型,如Son s1 = (Son)f1。向上转型会丢失子类特有的方法,但是子类overriding父类的方法,子类方法有效。 

          将一种类型的数据赋给另外一种类型变量时,满足下列两种要求将执行自动类型转换:1.两种类型是兼容的;2.目的类型的范围比来源类型大。   

          数据值类型按照范围从小到大为:byte,short,char,int,long,float,double

          例如int类型比所有byte合法类型大,因此不要求显式强制类型转换。对于数字类型,整型和浮点型都是彼此兼容的,但是数字类型和字符类型和布尔类型是不兼容的,字符类型和布尔类型也不是互相兼容的。

          自动类型转换不能满足所有的转换需求,比如int型变量赋值给byte型变量,这种转换不会自动进行,因为byte型比int型范围小。为了完成两种不兼容类型转换,需要用到强制类型转换。

          目标类型指定了要转换成为的类型。例如果将int型转为byte型,int型取值范围大于byte型,它的值将堆byte型范围进行取模。而把浮点型赋值给整数型,就会出现截断,截取掉小数部分。从其他数值类型转换为char类型时,必须进行强制转换。将char类型转换为其他数值类型时,除了byte、short必须强制转换之外,int、long、float、double都不用强制转换。

    [java] view plain copy
    1. byte b;  
    2. int i = 257;  
    3. double d = 32.13;  
    4. b = (byte) i;  
    5. System.out.println("i and b = " + i + " " + b);  
    6. i = (int)d;  
    7. System.out.println("d and i = " + d + " " + i);  
    8. b = (byte)d;  
    9. System.out.println("d and b = " + d + " " + b);  
    10. byte e=(byte)130;   
    11. System.out.println(e);  
    12.    
    13.    
    14. /* 
    15. * output 
    16. i and b = 257 1 
    17. d and i = 32.13 32 
    18. d and b = 32.13 32 
    19. -126 
    20. */  
           当257要转换为byte时,byte的范围是256,所以取模的结果是1。浮点值赋给整数型,截断了小数部分。
    [java] view plain copy
    1. short s = 1;  
    2. s= s + 1;//编译错误  
    3. short s1 = 1;  
    4. s1 += 1;  
          上述陷阱是s = s + 1,s + 1会隐式转换为int型,把int型号赋给short,会造成类型缺失。而s1 += 1相当于s1 = (short)(s1 + 1)会把s1 + 1强制转换为short类型,就不会报错。涉及到写代码的严谨性。

          对于自动装箱和自动拆箱,将一个基本数据类型转换为对应的引用类型时,不必强制转换。将一个基本数据类型的引用类型转换为基本数据类型时,也不必要强制转换。

    [java] view plain copy
    1. int i1 = 10;  
    2. Integer iObj1 = i1;  
    3. Integer iObj2 = new Integer(10);  
    4. int i2 = iObj2;  
         在三目运算符中,会按照算术类型中的提升原则将两端操作提升至统一类型,如果两端有一个操作数是引用类型,则整个表达式结果用Object型表示。

    [java] view plain copy
    1. byte b = 10;   
    2. short s = 20;   
    3. int i = (b == 10) ? b : s;   
    4. int i1 = 10;   
    5. String str = "Hello";   
    6. Object obj = (i1 == 10) ? i1 : str;  // 在这里变量i进行了自动装箱操作  
         int和String互相之间的转换,首先是int转String,有两种方法
    [java] view plain copy
    1. int i = 12345;  
    2. String s = "";  
    3. s = i + "";  
    4. s = String.valueOf(i);  
        第一种方法,s = i + "";会产生两个String对象, s = String.valueOf(i);直接使用String的静态方法。

    [java] view plain copy
    1. String s = "12345";  
    2. int i ;  
    3. i=Integer.parseInt(s);  
    4. i=Integer.valueOf(s).intValue();  
        第一种方法直接使用静态方法,不会产生多余的对象,但会抛出异常。第二种方法相当于new Integer(Integer.parseInt(s))也会抛出异常,但是会多产生一个对象。

          valueOf返回的是原对象,toString()返回的是字符串。

    3.instanceof

          instanceof是Java二元操作符,测试左边对象是否是右边类的实例,返回boolean类型的数据,作用上可以避免强制类型转换失败。

    4.JVM级别原理

          对于强制类型转换,且是引用类型,如果是父类向子类转换,这种只牵扯到引用名义类型的转换,具体的内存没有什么变化。

          而基本类型转换不同,数据发生了变化。但是基本数据类型不是对象,如果涉及到自动装箱和拆箱,实际上是调用类似Integer.parseInt()和Integer.valueOf()实现。

          父类向子类强制转换,如果成功不会有任何数据丢失,如果不是子类,那么会报错。基本类型之间的转换,如果是大范围向小范围的转换,有可能发生数据丢失或者精确丢失。

    展开全文
  • 类型转换

    2020-08-30 15:19:00
    文章目录自动类型转换int 转 longlong 转 floatfloat 转 double强制类型转换int 转 byte类型相互转换Byte 转 Stringint转Integerint转StringLong 转 StringDouble 转 StringInteger 转 intInteger 转 StringString ...

    自动类型转换

    byte,short,char->int->long->float->double
    
    byte,short,char三者之间不相互转换,再运算的时候,都把自己提升为int去操作
    

    int 转 long

    int i = 6;
    
    long l = i;
    

    long 转 float

    long l = 6;
    
    float f = l;
    

    float 转 double

    float f = 6;
    
    double d = f;
    

    强制类型转换

    double->flost->long->int
    
    把范围大的数据类型,强制转换为范围小的数据类型
    注:会损失精度
    

    int 转 byte

    int a = 2;
    byte b = 3;
    
    //(a+b):在括号中先运算 
    //(byte): 指运算后要转换后的类型
    int c = (byte)(a + b);
    

    类型相互转换

    Byte 转 String

    Byte b = 6;
    String s = String.valueOf(b);
    

    int转Integer

    int i = 10;
    Integer integer = new Integer(i);
    

    int转String

    int i = 10;
    
    //第一种
    String s =String.valueOf(i);
    
    //第二种
    String s =Ingeger.toString(i);
    
    //第三种
    String s = "" +i;
    

    Long 转 String

    Long l = 8L;
    String s = String.valueOf(l);
    

    Double 转 String

    Double dou = 1.9;
    String s = String.valueOf(d);
    

    Integer 转 int

    Integer integer = new Integer(10);
    
    int k = integer.intValue();
    

    Integer 转 String

    Integer integer = new Integer(10);
    
    //第一种
    String str = integer.toString();
    
    //第二种
    String str = integer + "";
    
    //第三种
    String.valueOf(integer);
    

    String 转 Byte

    String str = "6";
    
    //第一种
    byte b = Byte.parseByte(str);
    
    //第二种
    Byte b = Byte.valueOf(str);
    

    String 转 int

    String str ="10"; 
    
    //先把string转成Integer
    Integer integer = newInterger(str); 
    
    //再把Integer转成int
    int i = integer.intValue(); 
    

    String 转 Integer

    String str = "10";
    
    //第一种
    Integer integer =Integer.valueOf(str);
    
    //第二种
    Integer integer = Integer.parseInt(str);
    

    String 转 Double

    String str = "2.9";
    Double d = Double.valueOf(str);
    

    String 转 Long

    String str = "6";
    
    //第一种
    Long l = Long.valueOf(str);
    
    //第二种
    long l = Long.parseLong(str);
    

    String 转 BigDecimal

    String str = "10";
    
    BigDecimal bigDecimal = new BigDecimal(str);
    

    String 转 Date

    String string = "2020-08-30";
    DateFormat format = new SimpleDateFormat("yyyy-MM-dd");
    Date parse = format.parse(string);
    

    String日期 转 Timestamp

    String s = "9999-12-30 00:00:00";
    Timestamp timestamp = Timestamp.valueOf(s);
    

    BigDecimal 转 String

    BigDecimal bigDecimal = new BigDecimal("1000000");
    String string = bigDecimal.toString();
    

    Date 转 String

    Date date = new Date();
    SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
    String format = simpleDateFormat.format(date);
    

    Date 转 Timestamp

    Timestamp timestamp = new Timestamp(date.getTime());
    

    Timestamp 转 String

    Timestamp timestamp = new Timestamp(System.currentTimeMillis());
    
    //第一种
    SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    String format = simpleDateFormat.format(timestamp);
    
    //第二种
    String string = timestamp.toString();
    

    Timestamp 转 Date

    Timestamp timestamp = new Timestamp(System.currentTimeMillis());
    Date date = new Date();
    date = timestamp;
    
    展开全文
  • 自动类型转换

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

    2019-04-24 17:23:30
    不同类型的数据运算时,取数值范围较大的数据类型 int number; float total,aver; aver=total/number;//浮点数除法,只要除数或者被除数之间有一个浮点数,那么执行的就是浮点数除法运算。 如果15/2那么aver=7....
  • c++类型转换

    千次阅读 2019-05-29 19:45:08
    c 风格的转换的格式很简单(TYPE) EXPRESSION,但是 c 风格的类型转换有不少的缺点,有的时候用 c 风格的转换是不合 适的,因为它可以在任意类型之间转换,比如你可以把一个指向 const 对象的指针转换 成指向非 ...
  • Android Studio 开发app时, findViewById 输入后多数情况下要强制转换,以下有个快捷的方法: 在输入 分号; 前, Alt + Enter 注意,如果在 输入 分号之后再按快捷键, 将没有效果。这时需要将光标退回至分号前...
  • JS数据类型转换

    万次阅读 2019-06-24 23:15:26
    首先我们要知道,在 JS 中类型转换只有三种情况,分别是: 转换为布尔值 转换为数字 转换为字符串 我们先来看一个类型转换表格,然后再进入正题 转Boolean 在条件判断时,除了 undefined, null, false, NaN, ...
  • c++ 隐式类型转换

    千次阅读 2018-12-25 17:14:32
    文章目录谈谈c++隐式类型转换列举一些隐式类型转换的例子有时候隐式类型转换并不好explic关键词的用法总结 谈谈c++隐式类型转换 什么是c++隐式类型转换?这是指c++自动将一种类型转换成另一种类型,是编译器的一种...
  • 类型转换类型转换函数

    千次阅读 2018-02-03 21:39:46
    所以类型转换,就是为了告诉编译器这部分内存,应该用什么方式去解释它,如何组织这段内存。 1、C风格类型转换 c语言比较熟悉,指针类型转换很常见。通过圆括号和标识符组成(type) expression。允许任何类型...
  • golang中的类型类型转换指南

    千次阅读 2018-12-07 15:51:41
    在这篇文章中,我们将研究golang中使用的不同数据类型,以及如何在不同数据类型间进行转换。在我们研究类型转换的不同方法之前,让我们先来讨论一下golang中一些最常用的数据类型。 golang中的数据类型 下面是您将在...
  • 数据类型转换,分为自动转换和强制转换。 自动转换: 程序在执行过程中“悄然”进行的转换,不需要用户提前声明,一般是从位数低的类型向位数高的类型转换(低精度-&amp;gt;高精度 转换)。 强制类型转换: 则...
  • C++ 强制类型转换和赋值中的类型转换

    万次阅读 多人点赞 2017-02-02 12:11:40
    强制类型转换原C语言的形式:(类型名)(表达式)比如:(double)a //把a转换为double类型 (int)(a+b) //把a+b的值转换为整型需要注意的是:如果强制类型转换的对象是一个变量,那么该变量不需要用括号括起来;但是如果...
  • Java之强制类型转换

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

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

    千次阅读 2019-04-08 14:32:02
    类型转换函数 类型转换函数和case函数 1.隐式类型转换和显式类型转换的概念 隐式类型装换: 两个值进行运算或者比较,首先要求数据类型必须一致。如果发现两个数据类型不一致时就会发生隐式类型转换。例如,把字符串...
  • js面试题大坑——隐式类型转换

    万次阅读 多人点赞 2018-09-28 17:50:17
    · 1.1 隐式转换介绍 · 1.2 隐式转换规则 · 1.3 坑一:字符串连接符与算术运算符隐式转换规则混淆 · 1.4 坑二:关系运算符:会把其他数据类型转换成number之后再比较关系 · 1.5 坑三:复杂数据类型在隐式...
  • SpringMVC日期类型转换问题三大处理方法归纳

    万次阅读 多人点赞 2015-04-22 09:20:22
    前言  我们在SpringMVC开发中,可能遇到比较多的问题就是前台与后台...会发现是日期类型转换失败“映射”不到对应的持久类的日期属性上造成的,由此我还特意写过一篇博文:SpringMVC中出现" 400 Bad Request "错
  • Java中如何将int 类型转换为 Long类型

    万次阅读 2018-10-28 12:05:44
    很多同学可能会用上面的方法将int类型转换为Long类型,但事实上这样是不可行的。因为Long是包装类,而int是值类型数据,两者是不能这样强转的。long l = (long)3;int和long都是基本类型的数据,是可以强转的,那么我...
1 2 3 4 5 ... 20
收藏数 2,043,888
精华内容 817,555
关键字:

类型转换