java回忆录—数据类型的魅力

朱雀 2022-09-24 15:14 136阅读 0赞

Java 语言是一种**强类型语言**。通俗点说就是，在 Java 中存储的数据都是有类型的，而且必须在编译时就确定其类型。 Java 中有两类数据类型：

![这里写图片描述][20160802171230948]

**在 Java 的领域里，基本数据类型变量存的是数据本身，而引用类型变量存的是保存数据的空间地址。**

**说白了，基本数据类型变量里存储的是直接放在抽屉里的东西，而引用数据类型变量里存储的是这个抽屉的钥匙，钥匙和抽屉一一对应。**

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

**byte：**

byte数据类型是8位（1个字节）、有符号的，以二进制补码表示的整数；
    
    最小值是-128（-2^7）；
    
    最大值是127（2^7-1）；
    
    默认值是0；
    
    byte类型用在大型数组中节约空间，主要代替整数，因为byte变量占用的空间只有int类型的四分之一；
    
    例子：byte a = 100，byte b = -50。

**short：**

short数据类型是16位（2个字节）、有符号的以二进制补码表示的整数
    
    最小值是-32768（-2^15）；
    
    最大值是32767（2^15 - 1）；
    
    Short数据类型也可以像byte那样节省空间。一个short变量是int型变量所占空间的二分之一；
    
    默认值是0；
    
    例子：short s = 1000，short r = -20000。

**int：**

int数据类型是32位（4个字节）、有符号的以二进制补码表示的整数；
    
    最小值是-2,147,483,648（-2^31）；
    
    最大值是2,147,483,647（2^31 - 1）；
    
    一般地整型变量默认为int类型；
    
    默认值是0；
    
    例子：int a = 100000, int b = -200000。

**long：**

long数据类型是64位（8个字节）、有符号的以二进制补码表示的整数；
    
    最小值是-9,223,372,036,854,775,808（-2^63）；
    
    最大值是9,223,372,036,854,775,807（2^63 -1）；
    
    这种类型主要使用在需要比较大整数的系统上；
    
    默认值是0L；
    
    例子： long a = 100000L，Long b = -200000L。

**float：**

float数据类型是单精度、32位（4个字节）、符合IEEE 754标准的浮点数；
    
    float在储存大型浮点数组的时候可节省内存空间；
    
    默认值是0.0f；
    
    浮点数不能用来表示精确的值，如货币；
    
    例子：float f1 = 234.5f。

**double：**

double数据类型是双精度、64位（8个字节）、符合IEEE 754标准的浮点数；
    
    浮点数的默认类型为double类型；
    
    double类型同样不能表示精确的值，如货币；
    
    默认值是0.0d；
    
    例子：double d1 = 123.4。

**boolean：**

boolean数据类型是8位（1个字节）；
    
    只有两个取值：true和false；
    
    这种类型只作为一种标志来记录true/false情况；
    
    默认值是false；
    
    例子：boolean one = true。

**char：**

char类型是一个单一的16位Unicode字符（2个字节）；
    
    最小值是’\u0000’（即为0）；
    
    最大值是’\uffff’（即为65,535）；
    
    char数据类型可以储存任何字符；
    
    例子：char letter = ‘A’。

Java语言是一个面向对象的语言，但是Java中的基本数据类型却是不面向对象的，这在实际使用时存在很多的不便，为了解决这个不足，在设计类时为每个基本数据类型设计了一个对应的类进行代表，这样八个和基本数据类型对应的类统称为包装类(Wrapper Class)。

包装类均位于java.lang包，包装类和基本数据类型的对应关系如下表所示：

![这里写图片描述][20160802201705132]

实际上，JAVA中还存在另外一种基本类型void，它也有对应的包装类 java.lang.Void，不过我们无法直接对它们进行操作。

对于包装类来说，这些类的用途主要包含两种：

a、作为和基本数据类型对应的类类型存在，方便涉及到对象的操作。
    
    b、包含每种基本数据类型的相关属性如最大值、最小值等，以及相关的操作方法。

对于数值类型的基本类型的取值范围，我们无需强制去记忆，因为它们的值都已经以常量的形式定义在对应的包装类中了。如：

基本类型byte 二进制位数：Byte.SIZE最小值：Byte.MIN\_VALUE最大值：Byte.MAX\_VALUE

基本类型short二进制位数：Short.SIZE最小值：Short.MIN\_VALUE最大值：Short.MAX\_VALUE

基本类型char二进制位数：Character.SIZE最小值：Character.MIN\_VALUE最大值：Character.MAX\_VALUE

基本类型double 二进制位数：Double.SIZE最小值：Double.MIN\_VALUE最大值：Double.MAX\_VALUE

其实范围推也可以推出来的，比如byte类型，占一个字节，8位，那么它可以存储2^8=256个数，又知byte是有符号的，所以正数和负数应该各占一半（128个），正数的最大值应该为 0111 1111 = 127 ,所以正数的范围为0~127，则负数的范围应该为-128~-1，其他的数据类型也是同理。

注意：float、double两种类型的最小值与Float.MIN\_VALUE、 Double.MIN\_VALUE的值并不相同，实际上Float.MIN\_VALUE和Double.MIN\_VALUE分别指的是 float和double类型所能表示的最小正数。

也就是说存在这样一种情况，0到±Float.MIN\_VALUE之间的值float类型无法表示，0 到±Double.MIN\_VALUE之间的值double类型无法表示。

这并没有什么好奇怪的，因为这些范围内的数值超出了它们的精度范围。

另外，所有基本类型（包括void）的包装类都使用了final修饰，因此我们无法继承它们扩展新的类，也无法重写它们的任何方法。

**Java基本类型存储在栈中，因此它们的存取速度要快于存储在堆中的对应包装类的实例对象。**

**基本数据类型间的转换**

1、boolean类型不能转换成任何其他数据类型。

2、简单类型数据间的转换,有两种方式:自动转换和强制转换,通常发生在表达式中或方法的参数传递时。

自动转换：容量小的数据类型可以自动转换成容量大的数据类型，如byte-short-int-long-float-double。byte、short、int不会互相转换，他们三者在计算时会转换成int类型。
    
        ①下面的语句可以在Java中直接通过：
    
        byte b;int i=b; long l=b; float f=b; double d=b;
    
        ②如果低级类型为char型，向高级类型（整型）转换时，会转换为对应ASCII码值，例如
    
        char c='c'; int i=c;
    
        System.out.println("output:"+i);输出：output:99;
    
        ③对于byte,short,char三种类型而言，他们是平级的，因此不能相互自动转换，可以使用下述的强制类型转换。
    
        short i=99 ; char c=(char)i; System.out.println("output:"+c);输出：output:c;
    
    强制转换：容量大的数据类型转换成容量小的数据类型时，要加上强制转换符。可以想象，这种转换肯定可能会导致溢出或精度的下降。
    
        如： int n=(int)3.14159/2;

3、当一个java算术表达式中包含多个基本类型的值时，整个算术表达式的数据类型将发生自动提升。注意下面的规则。

①所有的byte,short,char型的值将被提升为int型；
    
    ②如果有一个操作数是long型，计算结果是long型；
    
    ③如果有一个操作数是float型，计算结果是float型；
    
    ④如果有一个操作数是double型，计算结果是double型；
    
    例：
    
    byte b=4;    //右边的int值在byte范围之内默认强转
    byte b1=3;
    byte b2=7;
    b=b1+b2; //这样是计算不出b,是错误的
    b=b1+7; //这样也是计算不出b
    byte b=3+7; //怎么这样又可以计算?
    解释：
    
    编译器在编译时（byte类型取值是有限的）他在判断右边的数值的时候发现是int类型（是“常量”）,
    但他会判断是不是在byte字节范围之内,如果在的话,会给右边的int类型做默认的强转,他把最后的一个字节（byte八个二进制）赋值到了b这个变量当中
    
    b1和b2是“变量”意味着这两值不确定、可能随时变化,编译器无法检查,也无法确定是否在byte字节范围之内,
    他检查不了就会报错（可能丢失精度）,如果是“常量”编译器就能够判断了。

4、包装类过渡类型转换

一般情况下，我们首先声明一个变量，然后生成一个对应的包装类，就可以利用包装类的各种方法进行类型转换了。
    
    例如：
    
        ①当希望把float型转换为double型时：
    
        float f1=100.00f;
    
        Float F1=new Float(f1);
    
        double d1=F1.doubleValue();//F1.doubleValue()为Float类的返回double值型的方法
    
        ②当希望把double型转换为int型时：
    
        double d1=100.00;
    
        Double D1=new Double(d1);
    
        int i1=D1.intValue();

简单类型的变量转换为相应的包装类，可以利用包装类的构造函数。

即：Boolean(boolean value)、Character(char value)、Integer(int value)、Long(long value)、Float(float value)、Double(double value)

而在各个包装类中，总有形为××Value()的方法，来得到其对应的简单类型数据。

利用这种方法，也可以实现不同数值型变量间的转换。

例如，对于一个双精度实型类，intValue()可以得到其对应的整型变量，而doubleValue()可以得到其对应的双精度实型变量。

5、字符串与其它类型间的转换

其它类型向字符串的转换
    
        ①调用类的串转换方法:X.toString();
    
        ②自动转换:X+"";
    
        ③使用String的方法:String.volueOf(X);
    
    字符串作为值,向其它类型的转换
    
        ①先转换成相应的封装器实例,再调用对应的方法转换成其它类型
    
            例如，字符中"32.1"转换double型的值的格式为:new Float("32.1").doubleValue()。
            也可以用:Double.valueOf("32.1").doubleValue()
    
        ②静态parseXXX方法
    
            String s = "1";
    
            byte b = Byte.parseByte( s );
    
            short t = Short.parseShort( s );
    
            int i = Integer.parseInt( s );
    
            long l = Long.parseLong( s );
    
            Float f = Float.parseFloat( s );
    
            Double d = Double.parseDouble( s );

在JDK 5.0之前，没有存在自动拆解箱的操作，即Auto Box操作，所以在这之前是不能使用以下方式的赋值代码的：

Integer a = 0; //这种赋值方式不能够在JDK 1.4以及以下的JDK编译器中通过

但是JDK 5.0出现了自动拆解箱的操作，所以在JDK 5.0以上的编译器中，以上的代码是可以通过的

**Java引用类型**

Java有 5种引用类型（对象类型）：类 接口 数组 枚举 标注

引用类型：底层结构和基本类型差别较大

所有引用类型的默认值都是null。

JVM的内存空间：

（1）. Heap 堆空间：分配对象 new Student（）

（2）. Stack 栈空间：临时变量 Student stu

（3）.Code 代码区 ：类的定义，静态资源 Student.class

eg：Student stu = new Student（）； //new 在内存的堆空间创建对象