Java基础：Java 数据类型

一. 数据类型

        数据类型在程序语言的构成要素里占有相当重要的地位。Java 的数据类型可分为基本数据类型和引用数据类型两种，其中基本数据类型包括了最基本的 byte、short、int、long、float、double、char、boolean 等。而对于引用数据类型（类似于 C/C++ 的指针），在操作时必须要进行内存的开辟。数据类型的划分如图所示。

         注意：基本数据类型不牵扯到内存的开辟，引用数据类型牵扯到内存的开辟

 二. Java 基本数据类型的大小和范围

 

        如果从实际开发角度来讲，以下的几种基本数据类型最为常用。

•  int型：只要是看见了整数的定义，其类型都是int；
•  double型：只要是看见了小数的定义，其类型都是double；
•  byte型：日后进行数据传输的时候使用此类型；
•  long型：表示日期时间或文件长度的时候使用；
•  boolean型：用于程序的逻辑操作使用。 

        下面分别对几种基本数据类型的使用进行说明。

 三. 数据类型说明

1. 整型（byte、short、int、long）

 (1). 定义变量

        整型就表示一个基本的整数，可以直接使用 int 定义，而且在 Java 中默认为一个整数，如20，其类型默认为 int。

public class TestDemo {
    public static void main(String[] args) {
        int x = 10; //10是一个整数常量，默认属于 int型
        int result = x * 2; //int型 * int型 = int型
        System.out.println(result); //输出 int型数据
    }
}

        程序运行结果：

        20

        在这里会有人问，什么是常量，什么是变量。常量简单理解就是内容不能改变的量，变量简单理解就是内容可以随意修改的量。

        在这里演示一个错误的操作：

public class TestDemo {
    public static void main(String[] args) {
        int x; //按道理来讲，x int型，没有赋值，结果应该是0，但实际上不是的
        System.out.println(x);
    }
}

        编译错误提示：

        The local variable x may not have been initialized

        int 型数据类型的默认值是0，如果一个 int型变量定义时没有为其赋予内容，那么其应该是对应数据类型的默认值，但是这种默认值是不会针对于方法起作用的，只能在以后讲解类属性定义时起作用，所以 x 的内容时属于未知的，所以程序编译就会出错。

        那么如何修改呢，下面时修改之后的操作，只需要对定义的内容进行赋值就可以了：

public class TestDemo {
    public static void main(String[] args) {
        int x; //按道理来讲，x int型，没有赋值，结果应该是0，但实际上不是的
        x = 10; //在使用之前为 x 变量赋值
        System.out.println(x);
    }
}

        程序运行结果：

        10

(2). 数据溢出 

        提示：在 Java 中可以方便地取得每一个数据类型的最大值和最小值，以 int 为例：

• 取得 int 数据类型范围的最大值： Integer.MAX_VALUE;
• 取得 int 数据类型范围的最小值： Integer.MIN_VALUE;

public class TestDemo {
    public static void main(String[] args) {
        int max = Integer.MAX_VALUE; //最大值
        int min = Integer.MIN_VALUE; //最小值
        System.out.println(max);
        System.out.println(min);
        //数据溢出操作：最大值 + 1 = 最小值
        System.out.println(max + 1); //int型 + int型 = int型， -2147483648
        System.out.println(max + 2); //int型 + int型 = int型， -2147483647
        //数据溢出操作：最小值 - 1 = 最大值
        System.out.println(min - 1); //int型 - int型 = int型， 2147483647
    }
}

        程序运行结果：

        2147483647
        -2147483648
        -2147483648
        -2147483647
        2147483647

        通过观察可以发现当数据已经时其对应数据类型的最大值（或最小值）时执行 int型数据类型的加法操作（或减法操作），那么就会变为最小值（或最大值），这样就出现了一个循环操作，这种情况在程序上称为数据溢出。

        而解决溢出的主要方法可以通过扩大数据范围来完成。比 int 大的范围时 long ，所以现在可以使用如下的两种方式完成：数字或变量 L、（long）数字或变量。

public class TestDemo {
    public static void main(String[] args) {
        int max = Integer.MAX_VALUE; //最大值
        int min = Integer.MIN_VALUE; //最小值
        System.out.println(max);
        System.out.println(min);
        System.out.println(max + 1L); //int型 + long型 = long型， 2147483648
        System.out.println(min - (long) 1); //int型 - long型 = long型， -2147483649
    }
}

        程序运行结果：

        2147483647
        -2147483648
        2147483648
        -2147483649

         本程序将每一个操作的其中一个 int 型数据变为了 long 型数据，这样程序在处理的时候就会发生数据的转型，最终就变为了对 long 型数据进行数学操作，从而很好地解决数据溢出的问题

(3). 整型数据的转型操作： 

public class TestDemo {
    public static void main(String[] args) {
        int x = 10; //定义 int型数据
        long y = x; //int型变为 long 型，自动转换
        long result = x * y; //int * long = long, 自动转换
        int temp = (int)result; //long -> int,强制转换
        System.out.println(result);
    }
}

         程序运行结果：

        100

        本程序使用了 int 和 long 两个数据类型进行了转型操作，当 int 变为 long 或与 long 类型数据计算时，操作的数据量类型自动变为了 long 型，而如果将 long 型的变量变为 int 型，那么就必须执行数据类型的强制转换。

        数据的转型操作——将 int 变为 byte，执行强制转换

public class TestDemo {
    public static void main(String[] args) {
        int x = 200; //超过了 byte 的范围
        byte b = (byte)x; //强制转换，溢出数据
        System.out.println(b);
    }
}

         程序运行结果：

        -56

        本程序中 int 型变量 x 保存的内容是 200，这个数值已经超过了 byte 的数据范围，所以依然发生了数据的溢出。

        注意：对 byte 的赋值操作 Java 有一个特殊的支持

        如果现在用户要定义 byte 型变量，那么会存在两种情况，下面用代码说明。

        第一种情况是定义的变量在 byte 范围之内：

public class TestDemo {
    public static void main(String[] args) {
        byte b = 20; //20是 int 型，但是这个数值在 byte 范围中，所以自动变为 byte 型
        System.out.println(b);
    }
}

         程序运行结果：

        20

        第二种情况是定义的变量不在 byte 范围之内：

public class TestDemo {
    public static void main(String[] args) {
        byte b = 200; //200是 int 型，但是这个数值不在 byte 范围中，所以编译出错
        System.out.println(b);
    }
}

        程序运行结果：

        cannot convert from int to byte

        此时由于 200 已经超过了 byte 的范围，所以程序在编译时就是告诉用户，int 型数据无法直接转换为 byte 型数据，用户需要自己执行强制处理。

2. 浮点型（float、double） 

        浮点型指的是小数，在 Java 语言中，每一个小数常量类型都为 double。

(1). 定义浮点型数据

public class TestDemo {
    public static void main(String[] args) {
        double x = 10.02; //一个小数，默认类型为 double
        System.out.println(x); 
    }
}

        程序运行结果：

        10.02

        在浮点型数据之中，分为两种：double 和 float 两种。float 的范围（-3.4E38（-3.4 * 10^38）~3.4E38(3.4 * 10^38)）要小于 double 的范围（-1.7E308 (-1.7 * 10^308) ~ (1.7E308) (1.7 * 10^308)），那么既然默认的小数属于 double 型数据，所以如果要为 float 变量赋值，就必须强制转换，而转换的方式有两种，数字F 和  (float)数字。

(2). 为 float 变量赋值

public class TestDemo {
    public static void main(String[] args) {
        float x = 10.02F; //double 强制转换为 float
        float y = (float)10.02; //double 强制转换 float
        System.out.println(x * y); //数学计算并输出
    }
}

        程序运行结果：

        100.400406

        通过以上操作，读者应该清楚了 double 和 float 的基本使用以及彼此的操作关系，但是需要注意的是，如果一个浮点型数据和一个整型数据一起操作的话，则整型自动的向浮点型转换。

(3). int 型和 double 型操作，结果为 double 型

public class TestDemo {
    public static void main(String[] args) {
        int x = 10; //int 型数据
        double y = x; //int 型自动转换为 double 型
        System.out.println(y * x); //double 型 * int 型 = double 型
    }
}

        程序运行结果：

        100.0

        本程序分别定义了两个变量：x（int型）、y（double型），因为 int 型数据的范围小于 double 型数据的保存范围，按照数据的自动转换型原则，最终的计算结果为 double 型。 

(4). 浮点型数据的转型操作 

        提示：数据的转型操作 

        通过以上操作代码，读者可以发现，实际上数据的自动转换就是将范围小的数据类型自动变为范围大的数据类型，而数据的强制转换就是将数据范围大的类型变为数据范围小的数据类型，所以按照这个原则，各个数值型数据的转换流程如下：

• 自动转换(由小到大)：byte -> short -> int -> long -> float -> double
• 强制转换(由大到小)：double -> float -> long -> int -> short -> byte

3. 浮点型（char）

        在 Java 之中使用单引号 “'” 定义的内容就表示一个字符，如 'A'、'B' 就表示两个字符，在 Java 中定义的字符串类型使用 char 完成，另外，在 Java 中 char 和 int 之间是可以相互转换的，即可以使用数字编码来表示字符。

        提示：关于 int 和 char 转换

• 大写字母范围：65 ~ 90
• 小写字母范围：97 ~ 122

仔细的小伙伴就会发现，相同的字母，他们的大写和小写之间刚好都是相差32.

 (1). 定义字符并与 int 完成转换

public class TestDemo {
    public static void main(String[] args) {
        char c = 'A'; //定义一个字符
        int x = c; //char 型自动转换为 int 型
        x += 32; //大写字母变为小写字母
        char temp = (char)x; //int 型强制转换为 char 型
        System.out.println(temp);
    }
}

        程序运行结果：

        a

(2). 使用字符保护中文 

        提示：Java 使用的是 UNICODE 编码而不是 ASCII 编码       

        Java 在定义字符时使用的并不是 ASCII 编码，而是 UNICODE编码，这是一种使用十六进制定义的编码，可以表示出任意的文字，其中也包含了中文的编码定义。

public class TestDemo {
    public static void main(String[] args) {
        char c = '张'; //定义一个字符
        int x = c; //char 型自动转型为 int 型
        System.out.println(x);
    }
}

         程序运行结果：

        24352

        UNICODE 设计的时候包含了所有的 ASCII 码，所以有一部分编码是完全和 ASCII 编码重复的，但是也有许多编码是 ASCII 编码没有的。

4. 布尔型（boolean）

        布尔是一个数学家的名字，而布尔型主要表示的是一种逻辑的判断，对于布尔型数据只有两种取值：true 和 false，它常用于逻辑操作。

(1). 使用布尔型进行逻辑操作

public class TestDemo {
    public static void main(String[] args) {
        boolean flag = true; //定义布尔型数据
        if ( flag ) { //if 语句判断的就是布尔型数据，等价于 flag == true
            System.out.println("Hello World !");
        }
    }
}

        程序运行结果：

        Hello World !

        注意：布尔型数据的取值不能使用 0 或 非 0 来表示

        在许多语言中，布尔型也使用 0（false）或非 0（true）来表示，不过此概念在 Java 中无效，Java 中只有 true 和 false。

5. 字符串（String）

        字符串是在程序开发中使用频率较高的一种数据组成。在 Java 中使用 String 可以定义字符串变量，但是 String 本身不属于 Java 的基本数据类型，因为它属于一个类（引用型数据），但是这个类使用起来可以像基本数据类型那样方便的操作。字符串使用 “ " ” 定义的一串数据，在字符串操作中可以使用 “ + ” 进行连接操作。

public class TestDemo {
    public static void main(String[] args) {
        String str = "Hello "; //定义字符串
        str += "World "; //字符串连接
        str = str + "!!!"; //字符串连接
        System.out.println(str);
    }
}

        程序运行结果：

        Hello World !!!
        本程序首先使用 String 定义了一个字符串变量 str ，而后使用 “+” 和 “+=” 对字符串进行数据连接。

6. 转义字符

        

         这些转义字符可以出现在 char 的定义中，也可以直接出现在字符串常量的定义中，下面通过这个代码观察其使用。

public class TestDemo {
    public static void main(String[] args) {
        String str = "\"Hello World !!!\"\tHello MLDN\\"; //定义字符串
        System.out.println(str);
    }
}

        程序运行结果：

        "Hello World !!!"    Hello MLDN\

        本程序在一个完整的字符串中加入了多个转义字符，通过运行结果，可以观察到这些转义字符的特点！