前言

  在java虚拟机开始运行时，会在内存开辟几个空间，堆空间，栈空间，常量池等等，而在定义常量变量的过程中，我们需要在内存中开辟一定量的空间，但是要开辟多大的空间，这个时候我们就要对这些变量进行数据类型的声明，下面本文就对Java中的数据类型进行详细的介绍。

1 基本数据类型总体分类

  java的类型可以分为两大类：基本数据类型（primitive data type）和引用数据类型（reference data type）（记忆：除了基本数据类型，其他都是引用数据类型）

2 整型

---

小问题：byte的右侧表数范围127怎么算出来的？
  byte: 1字节 = 8位
  二进制：01111111（因为第一位是符号位）
  可以表示的范围为：$$\begin{gathered} 1\ast 2^6+1\ast 2^5+1\ast 2^4+1\ast 2^3+1\ast 2^2+1\ast 2^1+1\ast 2^0 \\ =64+32+16+8+4+2+1=127 \end{gathered}$$

代码实例：

/**
 * 整型
 **/

public class demo1{
    public static void main(String[] args){
        /**
         * 不同进制数的表示
         */
        //定义整数类型的变量：
        //给变量赋值的时候，值可以为不同进制的，而输出都是以10进制输出
        int num1 = 12 ; // 默认情况下赋值就是 十进制 的情况
        System.out.println(num1); // 12
        int num2 = 012; // 前面加上0，这个值就是 八进制 的
        System.out.println(num2); // 10
        int num3 = 0x12; // 前面加上0x或者0X，这个值就是 十六进制 的
        System.out.println(num3); // 18
        int num4 = 0b10; // 前面加上0b或者0B,这个值就是 二进制 的
        System.out.println(num4); // 2

        //定义byte类型的变量：
        byte b = 126;//定义了一个byte类型的变量，名字叫b，赋值为126
        System.out.println(b); // 126
        //注意：超范围的赋值会报错。
        short s = 30000;
        System.out.println(s); // 30000
        int i = 1234;
        System.out.println(i); // 1234
        //整数类型默认就是int类型的，所以12345678910是一个int类型的数，对于int类型来说，它超出范围了
        //要想把一个数给long类型变量，那么后面加上L(推荐)或者l就可以了
        long num5 = 12345678910L;
        System.out.println(num5); // 12345678910
        //注意：只有这个数超出int类型的范围了后面才需要加上L，否则无需加L也可以赋值给long类型：
        long num6 = 12;
        System.out.println(num6); // 12
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

3 浮点类型

1. float类型又被称作单精度类型，尾数可以精确到7位有效数字，在很多情况下，float类型的精度很难满足需求。
2. double类型表示这种类型的数值精度约是float类型的两倍，又被称作双精度类型，绝大部分应用程序都采用double类型。
3. float类型的数值有一个后缀F或者f ，没有后缀F/f的浮点数值默认为double类型。也可以在浮点数值后添加后缀D或者d， 以明确其为double类型。

4. 表示法：
   （1）十进制数形式，如: 3.14 314.0 0.314
   （2）科学记数法形式，如：314e2 314E2 (E的大小写没有区分,表示$314\ast 10^2$)

代码实例：

/**
 * 浮点类型
 **/

public class demo2 {
    public static void main(String[] args) {
        //浮点类型的常量有两种形式：
        //十进制形式：
        double num1 = 3.14;
        System.out.println(num1); // 3.14
        //科学计数法形式：
        double num2 = 314E-2;
        System.out.println(num2); // 3.14

        //浮点类型的变量：
        //注意：浮点型默认是double类型的，要想将一个double类型的数赋给float类型，必须后面加上F或者f
        float f1 = 3.14234567898623F;
        System.out.println(f1);  // 3.1423457
        //注意：double类型后面可以加D或者d，但是一般我们都省略不写
        double d1 = 3.14234567898623D;
        System.out.println(d1); // 3.14234567898623

        //注意：我们最好不要进行浮点类型的比较：
        float f2 = 0.3F;
        double d2 = 0.3;
        System.out.println(f2 == d2); // false
            /*
            区别：
            = 赋值运算：  将等号右侧的值赋给等号左侧
            == 判断==左右两侧的值是否相等  ：结果要么相等 要么不相等
            ==运算符的结果就是要么是true，要么是false
            */
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

4 字符类型

1. Java中使用单引号 ' ' 来表示字符常量，字符型在内存中占2个字节。
   char 类型用来表示在Unicode编码表字符集中的字符。Unicode编码被设计用来处理各种语言的文字，它占2个字节，可允许有65536个字符。 由权威机构形成的编码表才可以称之为：字符集（EG：ASCII,GB2312,UTF-8,Unicode）

2. 转义字符
   

3. ASCII表
   

4. Unicode表
   https://www.cnblogs.com/csguo/p/7401874.html

代码实例：

/**
 * char类型
 **/

public class demo3{
    public static void main(String[] args){
        //定义字符类型的变量：单引号引起来的单个字符
        char ch1 = 'a';
        System.out.println(ch1); // a
        char ch2 = ' ';
        System.out.println(ch2);
        char ch3 = '中';
        System.out.println(ch3);
        char ch4 = '?';
        System.out.println(ch4);
        //java中无论：字母，数字，符号，中文都是字符类型的常量，都占用2个字节。

        System.out.println("--------------------------------");
        /*
        转义字符：
        \将后面的普通字符转换为特殊含义
        */
        char ch5 = '\n';
        System.out.println("aaa"+ch5+"bbb");
        System.out.println("aaa\nbbb"); // \n  换行

        System.out.println("aaaaaaa\tbbb"); //  \t  制表符

        System.out.println("aaa\bbbb"); // aabbb  \b  向前退一格

        System.out.println("aaa\rbbb"); // bbb   \r 将光标到本行开头 ：回车

        System.out.println("\"java\""); // \"：将双引号原样输出；  \'：将单引号原样输出； \\：将\原样输出。

        System.out.println("--------------------------------");
        char ch6 = 'A';
        System.out.println(ch6); // A
        System.out.println(ch6+90); // 155(A在ASCII中十进制是90)
        System.out.println(155-ch6); // 90
        //char类型我们看到的样子就是它本身的字面常量,但是底层在进行计算的时候，实际上是按照一个码进行计算的。
        //这个码就是ASCII
        //之前说char类型是按照Unicode码表进行存储的 (Unicode兼容了ASCII码，Unicode的前128位置ASCII)

        //转换：
        char ch7 = '中';
        int num1 = (int)ch7;
        System.out.println(num1); // 20013

        char ch8 = (char)20013;
        System.out.println(ch8); // 中

        int num2 = '中';
        System.out.println(num2); // 20013
        char ch9 = 20013;
        System.out.println(ch9); // 中
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

5 布尔类型

  boolean类型有两个常量值，true和false，在内存中占一位（不是一个字节），不可以使用 0 或非 0 的整数替代 true 和 false ，这点和C语言不同。 boolean 类型用来判断逻辑条件，一般用于程序流程控制 。

/**
 * boolean类型
 **/

public class demo4{
    public static void main(String[] args){
        //创建一个布尔类型的变量：
        boolean flag1 = true;
        System.out.println(flag1); // true
        boolean flag2 = false;
        System.out.println(flag2); // false
        boolean flag3 = 5==9;
        System.out.println(flag3); // false
        boolean flag4 = 5<9;
        System.out.println(flag4); // true
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

6 类型转换

1. 类型转换就是在赋值运算或者算数运算的时候，要求数据类型一致，如果不一致就要进行类型的转换。
2. 类型转换可以分为自动转换，强制转换两类
   

/**
 * 类型转换
 **/

public class demo5{
    public static void main(String[] args){
        //类型转换的两种形式：
        double d = 6; //int-->double  自动类型转换
        System.out.println(d); // 6.0
        int i = (int)6.5; //double--->int  强制类型转换 （强转）
        System.out.println(i); // 6

        //在同一个表达式中，有多个数据类型的时候，应该如何处理：
        //多种数据类型参与运算的时候，整数类型，浮点类型，字符类型都可以参与运算，唯独布尔类型不可以参与运算。
        //double d2 = 12+1294L+8.5F+3.81+'a'+true;
        double d2 = 12+1294L+8.5F+3.81+'a';
        System.out.println(d2); // 1415.31
        /*
        类型级别：(从低到高的)
            byte,short,char-->int--->long--->float--->double
           级别用来做什么？当一个表达式中有多种数据类型的时候，要找出当前表达式中级别最高的那个类型，
        然后其余的类型都转换为当前表达式中级别最高的类型进行计算。
        double d2 = 12+1294L+8.5F+3.81+'a';
                  = 12.0+1294.0+8.5+3.81+97.0
        */
        int i2 = (int)(12+1294L+8.5F+3.81+'a');
        System.out.println(i2);
        /*
        在进行运算的时候：
        左类型级别=右类型级别  : 直接赋值
        左<右  ：强转
        左>右  ：直接自动转换
        */

        /*
        以下情况属于特殊情形：对于byte，short，char类型来说，只要在他们的表数范围中，
        赋值的时候就不需要进行强转了直接赋值即可。
        */
        byte b = 12; 
        System.out.println(b);  /// 12
        byte b2 = (byte)270;  
        System.out.println(b2);  // 14
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44