【Java】数据类型与变量

如果不是天能天生丽质

就要做到天生励志

---

目录

1.常量 

2.数据类型 

3.变量

3.1 认识变量

3.2 变量的赋值 

3.3 整型家族变量

3.4浮点型家族变量 

3.5字符型变量 

3.6 布尔型变量

4.类型转换

4.1 认识类型转换

4.2 隐式类型转换 

4.3 强制类型转换 

4.4 类型提升

5.字符串类型 

5.1认识字符串

5.2 int 转换为 String 

5.3 String 转换为 int 

---

1.常量 

常量：程序运行期间，固定不变的量称为常量

常量按数据类型分类：

① 整型常量：程序中直接写的数字（没有小数点），就是整型常量。整型常量又可以分为： 二进制、八进制、十进制、十六进制 的整型常量。二进制的整型常量是由 0 和 1 构成，一般前面会加 0b 或者 0B ；八进制的整型常量是由 0~7 的数字构成，一般前面会加 0；十进制一般由 1~9 的数字构成，没有前缀；十六进制的整型常量是由0~9 A~F构成，一般前面加上 0x 或 0X。

public class Test {
    public static void main(String[] args) {
        System.out.println("二进制："+0b11101);
        System.out.println("八进制："+011101);
        System.out.println("十进制："+11101);
        System.out.println("十六进制："+0x11101);
    }
}

上述代码通过十进制打印后的结果： 

为什么都是11101最后打印出来的结果不一样咧？

答：因为进制不一样所以转换成十进制也就不一样

② 浮点数常量：程序中直接写的小数，就是浮点数常量。浮点型常量又可以分为 double 双精度浮点型 和 float 单精度浮点型。要是在小数后面加了 d 或 D 就表示双精度浮点型，要是在小数后面加了 f 或 F 就表示单精度浮点型，要是在程序中直接写的 小数 没有加 后缀 默认是双精度浮点型。其中 单精度浮点型 还可以用指数形式来表示。

public class Test {
    public static void main(String[] args) {
        System.out.println(3.14);
        System.out.println(3.14d);
        System.out.println(3.14f);
        System.out.println(3e12);
    }
}

③ 字符常量：由 单引号 ' ' 括起来的单个字符，就是字符常量。转义字符也属于字符常量。

public class Test {
    public static void main(String[] args) {
        System.out.println('a');
        System.out.println('\n');
    }
}

④ 字符串常量：：由 " " 括起来的，就是字符串常量。" " 里面一个字符都没有的长度就是0，里面要是有一个空格那么长度就是 1。

public class Test {
    public static void main(String[] args) {
        System.out.println("abc");
    }
}

⑤ 布尔常量：布尔常量是用来表示真假的，只有两个值一个是 true 表示真，还有一个是 false 表示假。

public class Test {
    public static void main(String[] args) {
        System.out.println(false);
        System.out.println(true);
 
        if(true) {
            System.out.println(true);
        } else {
            System.out.println(false);
        }
    }
}

⑥ 空常量： 空常量表示对象引用为空，只有一个值 null。

常量还可以从表现形式上进行分类：

① 字面值常量：就是看得这个常量就知道值

② 符号常量：就是用符号表示的常量，看得这个符号之后去找这个符号的值就能知道值了，通常要用 final 来定义这样一个符号常量 

public class Test {
    public static void main(String[] args) {
        final int a = 10;
    }
}

---

2.数据类型 

 在 Java 中数据类型主要分为两类：基本数据类型 和 引用数据类型。

基本数据类型又可以分为：四类 八种

四类 八种：

public class Test {
    public static void main(String[] args) {
        byte a = 10;
        short b = 10;
        int c = 10;
        long d = 10;
        double e = 10.0;
        float f = 10.0f;
        char g = 'g';
        boolean h = true;
    }
}

 上面代码中数据类型不一样，它们所占空间大小也就不一样，取值范围也不一样

• 不论是在16位系统还是32位系统，int都占用4个字节，long都占8个字节
• 整形和浮点型都是带有符号的
• 整型默认为int型，浮点型默认为double
• 字符串属于引用类型
• 字节是计算机中基本存储单元，1字节=8bit 
• 数据范围是空间大小  - 1 次方，因为第一位是符号位。不然整型的数据范围，整型占四个字节，则数据范围就是 2 的 -31 次方 ~ 2 的 31次方-1

为什么会有数据类型？

答：其实各种编程语言都有数据类型，不同编程语言的数据类型也是大同小异的，都是为了使用适合的空间。如果存储的数据只需要一个很小的数据空间，而选择了一个大的数据空间，就会造成空间的浪费。要是存储的数据需要一个很大的数据空间，而选择了一个小的数据空间，那就存储不下。

---

3.变量

3.1 认识变量

变量：在运行过程中，其值可以改变的量就是变量

定义变量的语法格式： 数据类型  变量名 = 初始值；

public class Test {
    public static void main(String[] args) {
        int a = 10;
        System.out.println(a);
        a = 100;
        System.out.println(a);
    }
}

代码解析：定义了一个变量，类型是 int（整型），变量名是 a，初始值是 10 ，此时 变量 a 中存储的是 10 ，打印 a ，则打印的是 10。因为 a 是变量，所以给 a 赋值为 100， 此时变量 a 中存储的则是 100，打印 a，则打印的是 100。

3.2 变量的赋值 

1.定义时赋初始值

public class Test {
    public static void main(String[] args) {
        int a = 10;
        System.out.println(a);
    }
}

2.先定义后赋值 

public class Test {
    public static void main(String[] args) {
        int a ;
        a = 10;
        System.out.println(a);
    }
}

 注意：必须在使用前赋值，否则程序直接报错。建议使用第一种方法，如果不知道赋什么值可以先赋值为 0

3.3 整型家族变量

1.字节型变量

public class Test {
    public static void main(String[] args) {
        byte a = 10;
        System.out.println(a);
        System.out.println("最大值："+Byte.MIN_VALUE);
        System.out.println("最小值："+Byte.MAX_VALUE);
    }
}

• byte 在任何系统下都占 1 个字节
• byte 的表示范围为：-128 ~ 127
• 使用时注意不要超过范围
• byte 的包装类型为 Byte 
• 通过 Byte.MIN_VALUE 可以访问短整型的最小值，通过 Byte.MAX_VALUE 可以访问短整型的最大值

2.短整型变量

public class Test {
    public static void main(String[] args) {
        short a = 10;
        System.out.println(a);
        System.out.println("最小值："+Short.MIN_VALUE);
        System.out.println("最大值："+Short.MAX_VALUE);
    }
}

• short在任何系统下都占2个字节
• short的表示范围为：-32768 ~ 32767
• 使用时注意不要超过范围
• short的包装类型为Short 
• 通过 Short.MIN_VALUE 可以访问短整型的最小值，通过 Short.MAX_VALUE 可以访问短整型的最大值

3.整型变量

public class Test {
    public static void main(String[] args) {
        short a = 10;
        System.out.println(a);
        System.out.println("最大值："+Integer.MIN_VALUE);
        System.out.println("最小值："+Integer.MAX_VALUE);
    }
}

• int 不论在何种系统下都是 4 个字节
• int 的表示范围为：-2147483648 ~ 2147483647
• 在给变量设置初始值时，值不能超过 int 的表示范围，否则会导致溢出
• int 的包装类型为 Integer 
• 通过 Integer.MIN_VALUE 可以访问整型的最小值，通过 Integer.MAX_VALUE 可以访问整型的最大值

 4.长整型变量

public class Test {
    public static void main(String[] args) {
        long a = 10L;//一般在长整型变量初始值后面加上大写的 L ,方便与 ing 区分
        System.out.println(a);
        System.out.println("最小值："+Long.MIN_VALUE);
        System.out.println("最大值："+Long.MAX_VALUE);
    }
}

• 长整型不论在那个系统下都占8个字节 
• 长整型的表示范围为：-9223372036854775808 ~ 9223372036854775807
• 长整型变量的初始值后加L或者l，推荐加L
• long的包装类型为Long 
• 通过 Long.MIN_VALUE 可以访问整型的最小值，通过 Long.MAX_VALUE 可以访问整型的最大值 

byte、short、int、long都可以定义整型变量，为什么要给出 4 种不同类型呢？ 

答：因为存储空间大小的不同，所以为了更加合理化分配空间就把整型又细分成了4种不同的类型 。就好比如碗的大小一样，为什么碗又分为大碗和小碗了，要是有一个小朋友来你家吃饭，我们会给他用小碗，因为如果用大碗，他根本吃不了那么多的饭，就会造成空间浪费。要是有一个大人来你家吃饭，我们会给他用大碗，因为如果用小碗，他根本吃不饱，就会造成空间不足。

3.4浮点型家族变量 

1.双精度浮点型 

public class Test {
    public static void main(String[] args) {
        double a = 2.0;
        System.out.println(a);
        System.out.println("最小值："+Double.MIN_VALUE);
        System.out.println("最大值："+Double.MAX_VALUE);
    }
}

• double在任何系统下都占8个字节
• 浮点数与整数在内存中的存储方式不同，不能单纯使用 2的n次方 的形式来计算
• double的包装类型为Double
• double 类型的内存布局遵守 IEEE 754 标准(和C语言一样), 尝试使用有限的内存空间表示可能无限的小数, 势必会存在一定的精度误差，因此浮点数是个近似值，并不是精确值。

注：

 整型 / 整型 ！= 小数：整型除以整型不可能得到一个小数

public class Test {
    public static void main(String[] args) {
        int a = 1;
        int b = 2;
        System.out.println(a / b);
    }
}

如果想要结果得要小数则有两种方法：

①.在整型/整型之前，先乘以一个小数，这样就可以让一个整型提升为浮点型

public class Test {
    public static void main(String[] args) {
        int a = 1;
        int b = 2;
        System.out.println(a * 1.0 / b );
    }
}

 ②.类型设置为浮点型：

public class Test {
    public static void main(String[] args) {
        double a = 1.0;
        double b = 2.0;
        System.out.println(a / b );
    }
}

2.单精度浮点型 

public class Test {
    public static void main(String[] args) {
        float a = 1.0f;
        System.out.println(a);
        System.out.println("最小值："+Float.MIN_VALUE);
        System.out.println("最大值："+Float.MAX_VALUE);
    }
}

 

• float 类型在 Java 中占四个字节
• 同样遵守 IEEE 754 标准.
• float的包装类型为Float。

3.5字符型变量 

public class Test {
    public static void main(String[] args) {
        char a = 'a';
        char b = '哈';
        System.out.println(a);
        System.out.println(b);
    }
}

• Java 中使用 Unicode 表示字符，因此 一个字符占用两个字节, 表示的字符种类更多, 包括中文
• char的包装类型为Character 

3.6 布尔型变量

public class Test {
    public static void main(String[] args) {
        boolean a = true;
        if (a) {
            System.out.println("真");
        } else {
            System.out.println("假");
        }
    }
}

• Java中的布尔类型只有两个取值一个是 true 表示真，还有一个是 false 表示假。（注：C语言0表示假，非零表示真，大家不要弄混了哦）
• Java 的 boolean 类型和 int 不能相互转换, 不存在 1 表示 true, 0 表示 false 这样的用法.
• Java虚拟机规范中，并没有明确规定 boolean 占几个字节，也没有专门用来处理 boolean 的字节码指令，在 Oracle 公司的虚拟机实现中，boolean 占 1 个字节
• boolean 的包装类型为 Boolean 

---

4.类型转换

4.1 认识类型转换

类型转换：顾名思义就是将一个类型转换为另一个类型。

Java 作为一个强类型编程语言, 当不同类型之间的变量相互赋值的时候, 会有教严格的校验 

将把一个双精度类型的值赋给一个整型时程序将会直接报错。 

将把一个双精度类型的值转换为整型，然后赋给一个整型时程序将通过。

这就是类型转换的功能，将把一个值赋值给一个不同的类型变量时，就需要类型转换。

类型转换可以分为：隐式类型转换 和 强制类型转换。

4.2 隐式类型转换 

隐式类型转换又称为自动类型转换：数据范围小的转为数据范围大的时候，代码不需要经过任何处理，在代码编译时，编译器会自动进行处理。 

public class Test {
    public static void main(String[] args) {
        int a = 10;
        long b = 20;
        b = a;//自动类型转换
        System.out.println(b);
    }
}

当数据范围大的转为数据范围小的时候，编译器则不会自动处理，则会直接报错 

 当数据范围大的转为数据范围小的时候，我们则需要用到强制类型转换

4.3 强制类型转换 

 强制类型转换：当数据范围大的转为数据范围小的时候，编译器则不会自动处理，此时我们则需要自己去转换，由用户自己转换的就叫做强制类型转换。

public class Test {
    public static void main(String[] args) {
        int a = 10;
        long b = 20;
        a = (int) b;//强制类型转换
        System.out.println(a);
    }
}

• 不同数字类型的变量之间赋值, 表示范围更小的类型能隐式转换成范围较大的类型
• 如果需要把范围大的类型赋值给范围小的, 需要强制类型转换, 但是可能精度丢失
• 将一个字面值常量进行赋值的时候, Java 会自动针对数字范围进行检查（比如：将一个小数赋给一个整型变量）
• 强制类型转换不一定能成功，不相干的类型不能互相转换（比如：将布尔类型强制转换为整型）

4.4 类型提升

类型提升：不同类型的数据之间相互运算时，数据类型小的会被提升到数据类型大的 

 ① 数据类型小的 与 数据类型大的进行运算

当一个 整型 和 长整型 进行运算时，整型会被提升为长整型然后进行运算。

上述代码中 a + b ---》int + long ---》long + long 赋值给 int 时会丢失数据，编译时会报错。

 上述代码 a + b ---》int + long ---》long + long 赋值给 long，则编译成功。

② 低于4个字节的数据类型进行的运算

由于计算机的 CPU 通常是按照 4 个字节为单位从内存中读写数据. 为了硬件上实现方便, 诸如 byte 和 short 这种低于 4 个字节的类型, 会先提升成 int, 再参与计算。

上述代码中 a + b ---》short + short ---》int + int 赋值给 short 时会丢失数据，编译时会报错 

上述代码 a + b ---》short + short ---》int + int 赋值给 int，则编译成功。 

• 不同类型的数据混合运算, 范围小的会提升成范围大的
• 对于 short, byte 这种比 4 个字节小的类型, 会先提升成 4 个字节的 int , 再运算 

5.字符串类型 

5.1认识字符串

字符串属于引用类型 

public class Test {
    public static void main(String[] args) {
        String str1 = "abc";
        String str2 = "def";
        System.out.println(str1);
        System.out.println(str2);
        System.out.println(str1 + str2);
    }
}

• C语言中没有字符串类型，如果想在C语言中存储字符串只能运用数组。
• 在Java中使用 String 类定义字符串类型。
• Java 中两个字符串相加就表示把两个字符串拼接起来

5.2 int 转换为 String 

方法一：整型变量 + 双引号

public class Test {
    public static void main(String[] args) {
        int a = 1;
        String str = a + "";
        System.out.println(str);
    }
}

 方法二：用 String 包装类

public class Test {
    public static void main(String[] args) {
        int a = 1;
        String str = String.valueOf(a);
        System.out.println(str);
    }
}

5.3 String 转换为 int 

直接用 Integer 包装类

public class Test {
    public static void main(String[] args) {
        String str = "100";
        int a = Integer.parseInt(str);
        System.out.println(a);
    }
}