03-Java数据类型

Java的数据类型分为两大类：基本数据类型（primitive data type）和引用数据类型（reference data type）

一、基本数据类型（四类八种）：

数据类型名称	占用存储空间（字节/位）	默认值	范围	封装器
byte（字节型）	1字节/8位	0	-2^7 ~ 2^7-1	Byte
short（短整型）	2字节/16位	0	-2^15 ~ 2^15-1	Short
int（整形）	4字节/32位	0	-2^31 ~ 2^31-1	Integer
long（长整型）	8字节/64位	0.0l	-2^63 ~ 2^63-1	Long
float（浮点型）	4字节/32位	0.0f	3.40282347e^-38 ~ 3.40282347e^+38	Float
double（双精度浮点型）	8字节/64位	0.0d	1.79769313486231570^-38 ~ 1.79769313486231570e^+38	Double
char（字符型）	2字节/16位	\u0000（空格）		Character
boolean（布尔型）	1位	false	false/true

1、整形 ：byte、short、int、long

几进制，就是逢几进1

​ 十进制（D）：如：555

​ 八进制数（Q）：要求以0开头，如：0555

​ 十六进制数（H）：要求以0x或0X开头，如：0x555

​ 二进制数（B）：要求0b或0B开头，如：0b11

public class IntegerTypes {
    public static void main(String[] args) {
        //定义整数类型的变量
        int num1 = 12;//默认情况下，赋值就是十进制
        int num2 = 012;//前面加上0，表示八进制
        int num3 = 0x12;//前面加上0x或0X，表示十六进制
        int num4 = 0b10;//前面加上0b或者0B，表示二进制
        System.out.println("十进制：" + num1);// 12
        System.out.println("八进制：" + num2);// 10
        System.out.println("十六进制：" + num3);// 18
        System.out.println("二进制：" + num4);// 2

        System.out.println("==========");

        //定义byte类型的变量
        byte b = 126;//范围-2^7~2^7-1，1字节，8位
        //定义short类型的变量
        short s = 30000;//范围-2^15~2^15-1，2字节，16位
        //定义int类型的变量
        int i = 1234567890;//范围-2^31~2^31-1，4字节，32位
        //定义long类型的变量
        long l = 12345678910L;//范围-2^63~2^63-1，8字节，64位
        //整数类型默认是int类型的，如果超出int类型的范围，那么需要在后面加上L（推荐）或l
        //注意：只有当这个数超出了int类型的范围了，后面才需要加L，否则无需加L也可以赋值给long类型
        System.out.println(b);// 126
        System.out.println(s);// 30000
        System.out.println(i);// 1234567890
        System.out.println(l);// 12345678910
    }
}

2、浮点型 ：float、double

float类型又称作单精度类型，尾数可以精确到7位有效小数，很多情况下，float类型的精度很难满足需求。

double类型又称作双精度类型，数值精确度是float类型的两倍，绝大部分应用程序都使用double类型。

float类型的数值有一个后缀F或f，没有的浮点数默认为double类型，也可以在浮点数值的后添加D或者d后缀，以明确其为double类型

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

        //浮点类型的变量
        //注意：浮点类型默认的是double类型，要想将一个double类型的数赋给float类型，必须后面加上F或者f
        float f1 = 3.1423456789623F;// 3.1423457,精度不够显示不全
        double d1 = 3.1423456789623D;
        System.out.println(f1);// 3.1423457
        System.out.println(d1);// 3.1423456789623

        //注意：最好不要进行浮点类型的比较
        float f2 = 03F;
        double d2 = 0.3D;
        System.out.println(f2 == d2);// false
        /*
        =和==的区别：
            =   赋值运算：将等号右侧的值赋给等号左侧
            ==  判断==左右两侧的值是否相等，结果要么是相等true、要么是不相等false
         */
    }
}

3、字符型 ： char

Java中使用单引号来表示字符常量，字符型在内存中占2个字节

char类型用来表示在Unicode编码表中的字符。Unicode编码被设计用来处理各种语言的文字，它占2个字节，可以允许有65536个字符。

转义字符：

转义符	含义	Unicode值
\b	退格	\u0008
\n	换行	\u000a
\r	回车	\u000d
\t	制表符	\u0009
"	双引号	\u0022
'	单引号	\u0027
\	反斜杠	\u005c

public class StringTypes {
    public static void main(String[] args) {
        //定义字符类型的变量
        char ch1 = 'a';
        char ch2 = 'A';
        char ch3 = '4';
        char ch4 = '中';
        char ch5 = '?';
        char ch6 = ' ';
        // Java中无论：字母、数字、符号、中文，都是字符类型的变量，都占用2个字节。
        // 字符类型：都是单引号引起来的单个字符
        System.out.println(ch1);// a
        System.out.println(ch2);// A
        System.out.println(ch3);// 4
        System.out.println(ch4);// 中
        System.out.println(ch5);// ?
        System.out.println(ch6);// 空格
        /*
        转义字符：
        \将后面的普通字符转换成特殊含义
         */
        //换行
        char ch7 = '\n';
        System.out.println("aaa" + ch7 + "bbb");// 等同于 System.out.println("aaa\nbbb");// aaa 换行 bbb

        //制表符
        char ch8 = '\t';
        System.out.println("aaa" + ch8 + "bbb");// 等同于 System.out.println("aaa\tbbb");// aaa	bbb

        //回退，向前退一格
        char ch9 = '\b';
        System.out.println("aaa" + ch9 + "bbb");// 等同于 System.out.println("aaa\bbbb");// aabbb

        // 回车，将光标到本行开头并回车
        char ch10 = '\r';
        System.out.println("aaa" + ch10 + "bbb");// 等同于 System.out.println("aaa\rbbb");// bbb

        // 将双引号原样输出
        char ch11 = '\"';
        System.out.println(ch11 + "java" + ch11);// 等同于 System.out.println("\"java\"");// "java"

        // 将单引号原样输出
        char ch12 = '\'';
        System.out.println(ch12 + "java" + ch12);// 等同于 System.out.println("\'java\'");// \java\

        // 将单引号原样输出
        char ch13 = '\\';
        System.out.println(ch13 + "java" + ch13);// 等同于 System.out.println("\\java\\");// \java\
    }
}

public class Types04String {
    public static void main(String[] args) {
        char ch1 = 'A';
        System.out.println(ch1);// A ,A = 65,ASCII码表
        System.out.println(ch1 + 90);// 155
        System.out.println(155 - ch1);// 90
        // char类型我们看到的样子就是它本身的字面常量，但是底层在进行计算的时候，实际上是按照一个码进行计算的，这个码就是ASCII码
        // 之前说char类型是按照Unicode码表进行存储的（Unicode兼容ASCII码，Unicode的前128位就是ASCII码）

        char ch2 = '中';
        System.out.println(ch2);// 中
        System.out.println(ch2 + 90);// 20103
        System.out.println(20103 - ch2);// 90

        int num1 = (int) ch2;
        System.out.println(num1);// 20013

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

        char ch5 = 20013;
        System.out.println(ch5);

        char ch6 = '2' + 2;// 50 +2 
        System.out.println(ch6);//'4', 52
    }
}

乱码问题：

用记事本选择编码方法的时候一般选择为 ANSI，即获取当前操作系统的编码格式：GBK

4、布尔型 ： boolean

boolean类型有两个常量，true和false，在内存中占1位（不是一个字节），不可以使用0或非0的整数代替true和false。

boolean类型采用逻辑判断，一般用于程序流程控制

public class Types05Boolean {
    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
    }
}

5.基本数据类型转换

什么是类型转换？

​ 在赋值运算或者算数运算的时候，要求数据类型一致，就要进行类型的转换

类型转换的种类：

​ 自动转换，强制转换

类型级别：（从低到高）
byte，short，char --> int --> long --> float --> double

级别用来做什么？
当一个表达式中有多种数据类型的时候，要找出当前表达式中级别最高的那个类型，然后其余的类型都转换为当前表达式中级别最高的类型进行计算。

在进行运算的时候：
左 = 右 : 直接赋值
左 < 右 : 强转
左 > 右 : 直接自动转换

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

        // 在同一个表达式中，有多个数据类型的时候，应该如何处理
        // 多种数据类型参与运算的时候，整数类型、浮点类型、字符类型都可以参与运算，唯独布尔类型不可以参与运算
        double d2 = 12 + 1294L + 8.5f + 3.81 + 'a';
        System.out.println(d2);
        /*
        类型级别：（从低到高）
        byte，short，char --> int --> long --> float --> double
        级别用来做什么？
        当一个表达式中有多种数据类型的时候，要找出当前表达式中级别最高的那个类型，然后其余的类型都转换为当前表达式中级别最高的类型进行计算
         */
        // 报错 int d3 = 12 + 1294l + 8.5f + 3.81 + 'a';
        int d3 = (int) (12 + 1294L + 8.5f + 3.81 + 'a');
        System.out.println(d3);

        /*
        在进行运算的时候：
            左 = 右   : 直接赋值
            左 < 右   : 强转
            左 > 右   : 直接自动转换
         */

        // 特殊情况：对于byte，short，char类型来说，只要在它们表数的范围中，赋值的时候就不需要进行强转了，直接赋值即可
        byte b = 12;
        System.out.println(b);
        // 报错 byte b2 = 256;
        byte b2 = (byte) 256;
        System.out.println(b2);
    }
}

​ 一个变量被final修饰，这个变量就变成了一个常量，这个常量的值就不可以再变，这个常量也成为字符常量

约定成俗的规定：

​ 字符常量的名称全部大写

二、引用类型：

除了基本类型以外的所有类型都属于引用类型，包括：类、接口、数组等