Java基础一--基本数据类型&类型转换

发表于 | 分类于 | 阅读次数: ℃
字数统计: 2.4k | 阅读时长 ≈ 9

Java 中有两大数据类型：

  • 内置数据类型
  • 引用数据类型

数据类型

内置数据类型

Java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。

基本类型 大小 最小值 最大值 默认值 包装类 例子
byte 8 bit -128 +127 0 Byte byte a = 100
short 16 bit -2^15 +2^15 - 1 0 Short short s = 1000
int 32 bit -2^31 +2^31 - 1 0 Integer int a = 100000
long 64 bit -2^63 +2^63 -1 0L Long long a = 100000L
float 32 bit IEEE754 IEEE754 0.0f Float float f1 = 234.5f
double 64 bit IEEE754 IEEE754 0.0d Double double d1 = 123.4
char 16 bit Unicode 0 Unicode 2^16-1 空 Character char letter = ‘A’
boolean - - - false Boolean boolean one = true

包装类

虽然 Java 语言是典型的面向对象编程语言，但其中的八种基本数据类型并不支持面向对象编程，基本类型的数据不具备“对象”的特性——不携带属性、没有方法可调用。 沿用它们只是为了迎合人类根深蒂固的习惯，并的确能简单、有效地进行常规数据处理。

基本数据类型的不足

  • 不具有对象的特性
  • 无法进行对象化交互
  • 解决办法——包装类

这种借助于非面向对象技术的做法有时也会带来不便，比如引用类型数据均继承了 Object 类的特性，要转换为 String 类型（经常有这种需要）时只要简单调用 Object 类中定义的 toString() 即可，而基本数据类型转换为 String 类型则要麻烦得多。为解决此类问题 ，Java 为每种基本数据类型分别设计了对应的类，称之为包装类(Wrapper Classes)。这样便可以把这些基本类型转换为对象来处理了。

每个包装类的对象可以封装一个相应的基本类型的数据，并提供了其它一些有用的方法。包装类对象一经创建，其内容（所封装的基本类型数据值）不可改变。

包装类有哪些？

Java 中常用的包装类可以分为三类：Character、Number、Boolean

包装类与基本数据类型

  • 装箱：把基本数据类型转换成包装类
    • 自动装箱
    • 手动装箱
  • 拆箱：把包装类转换成基本数据类型
    • 自动拆箱
    • 手动拆箱

装箱&拆箱

什么是自动拆箱装箱？

很简单，下面两局代码就可以看到装箱和拆箱的过程

1
2
3
4
//自动装箱
Integer total = 99;
//自动拆箱
int totalprim = total;

简单的来说，自动装箱是 Java 编译器在 Java 基本数据类型和对应的对象包装类型上做的自动转换。例如把 int 转换成 Integer ，double 转换成 Double 等等

如果反过来，就是自动拆箱，这也是编译器为我们做的事。

通常我们要创建一个类的对象实例的时候，我们会这样：Class c = new Class(parameter);

当我们创建一个 Integer 对象是，却可以这样：Integer i = 100;

实际上，执行上面那句代码的时候，系统为我们执行了：Integer i = Integer.valueOf(100);

此即基本数据类型的自动装箱功能。

当我们将 Integer 对象赋值给 int 类型时：

Integer i = 10;

int t = i;

实际上，执行上面那句代码的时候，系统为我们执行了：int i = i.intValue();>

接下来，我们来看这样的代码

1
2
3
4
5
6
7
8
9
10
public class Main{
    public static void main(String args[]) {
        Integer i1 = 32;
        Integer x1 = 32;
        System.out.println(i1 == x1);
        Integer i2 = 132;
        Integer x2 = 132;
        System.out.println(i2 == x2);
    }
}

运行结果

true
false

解释如下：

初始值在 -128 – 127 之间的值，它们被装箱为Integer对象后，会在内存中被重用。超过这个值的时候每次装箱是会产生新的对象。

为重载带来的问题

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class Main{
    public static void method(Integer x) {
        System.out.println("Integer");
    }

    public static void method(long x) {
        System.out.println("long");
    }

    public static void method(Long x) {
        System.out.println("Long");
    }

    public static void main(String[] args) {
        method(5);
    }
}

运行结果

long

在这种情况下编译器选择的是加宽操作，而不是装箱。

测试结果（优先级排序）：

int>long > float > Integer > Long(运行出错) > char(编译报错)

这里说一下为什么转 Long 会出错。

因为 int 不能直接转为 Long 类型，int 是基本数据类型，而 Long 是包装类。int 转 Integer 可以通过装箱实现，而 Long 不是 int 的包装类，所以不行。

那么如果想将 int 转为 Long 呢？

可以通过一下步骤

1
2
3
4
5
6
7
public class Main{
    public static void main(String[] args) {
        int a = 5;
        long l = a;//先将 int 转为 long 类型
        Long l1 = l;//再将 long 装箱
    }
}

字符串与基本数据类型

  • 基本数据类型转换为字符串
    • 使用包装类的 toString() 方法
  • 字符串转换为基本数据类型
    • 自动拆箱调用包装类的 parseXXX() 静态方法
    • 调用包装类的 valueOf() 方法转换为基本类型的包装类，自动拆箱

基本类型与包装类型的异同

  • 在 Java 中，一切皆对象，但是八大基本类型却不是对象
  • 声明方式的不同，基本类型无须通过 new 关键字来创建，而包装类型需要 new 关键字
  • 存储方式及位置的不同，基本数据类型是将变量的值保存在栈中，这样可以更高效的存取，包装类型需要通过引用指向实例，具体的实例保存在堆中
  • 初始值的不同，包装类型的初始值为 null ，基本类型的初始值视具体的类型而定，比如 int 的初始值为0；boolean 的初始值为 false
  • 使用方法的不同，比如与集合类合作使用时(泛型)，只能使用包装类型

引用类型

  • 在 Java 中，引用类型的变量非常类似于 C/C++ 的指针。引用类型指向一个对象，指向对象的变量是引用变量。这些变量在声明时被指定为一个特定的类型，比如 Employee、Puppy 等。变量一旦声明后，类型就不能被改变了
  • 引用数据类型包括：类、接口类型、数组类型、枚举类型、注解类型，字符串型；
  • 所有引用类型的默认值都是 null

类型转换

什么是类型转换？

整型、实型（常量）、字符型数据可以混合运算。运算中，不同类型的数据先转化为同一类型，然后进行运算。

转换从低级到高级

低————————————————————>高

byte,short,char—> int —> long—> float —> double

数据类型转换必须满足如下规则：

  • 不能对boolean类型进行类型转换。

  • 不能把对象类型转换成不相关类的对象。

  • 在把容量大的类型转换为容量小的类型时必须使用强制类型转换。

  • 转换过程中可能导致溢出或损失精度，例如：

    1
    2
    int i =128;   
    byte b = (byte)i;

    因为 byte 类型是 8 位，最大值为127，所以当 int 强制转换为 byte 类型时，值 128 时候就会导致溢出。

  • 浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入，例如：

    1
    2
    (int)23.7 == 23;        
    (int)-45.89f == -45

类型转换分为：

  • 自动类型转换
  • 强制类型转换

自动类型转换

必须满足转换前的数据类型的位数要低于转换后的数据类型，例如: short数据类型的位数为16位，就可以自动转换位数为32的int类型，同样float数据类型的位数为32，可以自动转换为64位的double类型。

1
2
3
4
5
6
7
8
9
10
public class ZiDongLeiZhuan{
        public static void main(String[] args){
            char c1='a';//定义一个char类型
            int i1 = c1;//char自动类型转换为int
            System.out.println("char自动类型转换为int后的值等于"+i1);
            char c2 = 'A';//定义一个char类型
            int i2 = c2+1;//char 类型和 int 类型计算
            System.out.println("char类型和int计算后的值等于"+i2);
        }
}

结果为：

1
2
char自动类型转换为int后的值等于97
char类型和int计算后的值等于66

解析：c1 的值为字符 a ,查 ASCII 码表可知对应的 int 类型值为 97， A 对应值为 65，所以 i2=65+1=66。

强制类型转换

将高级别类型赋值给低级别类型时，必须进行强制类型转换。

  • 条件是转换的数据类型必须是兼容的。
  • 格式：(type)value type是要强制类型转换后的数据类型。

小结

  • Java 中有两大数据类型，基本数据类型和引用数据类型。

    • 基本数据类型在被创建时，在栈上给其划分一块内存，将数据直接存储在栈上.
    • 引用数据类型在被创建时，首先要在栈上给其引用分配一块内存，而对象的具体信息都存储在堆上，然后由栈上面的引用指向堆中对象的地址。

  • 简答的说小类型可自动转换为大类型，大类型转小类型需要强制转换。

Java类型转换

箭头指向的方向表示可以自动转换，箭头的相反方向需要强制转换，虚线所指向的内容可能发生精度的丢失。

-------------本文结束感谢您的阅读-------------

本文标题:Java基础一--基本数据类型&类型转换

文章作者:Cui Zhe

发布时间:2018年10月13日 - 18:10

最后更新:2018年10月28日 - 11:10

原始链接:https://cuizhe1023.github.io/2018/10/13/Java基础一/

许可协议: 署名-非商业性使用-禁止演绎 4.0 国际 转载请保留原文链接及作者。