【Java基础】4.基本数据类型、类型转换、包装类、Math 类

---

前言

变量就是申请内存来存储值。也就是说，当创建变量的时候，需要在内存中申请空间。
内存管理系统根据变量的类型为变量分配存储空间，分配的空间只能用来储存该类型数据。
因此，通过定义不同类型的变量，可以在内存中储存整数、小数或者字符。
Java 有两大数据类型：内置数据类型、引用数据类型。

一、基本数据类型（4类8种）

Java 语言提供了四大类八种基本类型。
四个整数类型：byte、short、int、long。
两个浮点类型：float、double。
一种字符类型：char。
一种布尔类型/逻辑类型：boolean。

1.整数类型

byte
整数类型，byte字节型，占1个字节，默认值是 0，取值范围为-128到127。

// 整数：1、byte字节型，占1个字节，取值范围为-128到127
byte a = 12;
System.out.println("byte变量a = " + a); // 12

short
整数类型，short短整型，占2个字节，默认值是 0，取值范围为-32768到32767。

// 整数：2、short短整型，占2个字节，取值范围为-32768到32767
short b = 300;
System.out.println("short变量b = " + b); // 300

int（整数型的默认类型）
整数类型，int整型，整数型的默认类型，占4个字节，默认值是 0，取值范围为-2147483648到2147483647。

// 整数：3、int整型，默认的类型，占4个字节，取值范围为-2147483648到2147483647
int c = 10000;
System.out.println("int变量c = " + c); // 10000

long
整数类型，long长整型，占8个字节，默认值是 0L，取值范围为-9223372036854775808到9223372036854775807。为了表明整数是long型，数字后面一定要加L。

// 整数：4、long长整型，占8个字节，取值范围为-9223372036854775808到9223372036854775807
long d = 10000L;
System.out.println("long变量d = " + d); // 10000

2.浮点类型

float（单精度）
浮点类型，float单精度，占4个字节，默认值是 0.0f。为了表明浮点数是float型，数字后面一定要加F。

// 浮点型：5、float单精度，占4个字节
float f = 0.5F;
System.out.println("float变量f = " + f); // 0.5

double（双精度，浮点型的默认类型）
浮点类型，double双精度，占8个字节，默认值是 0.0d。浮点型的默认类型。

// 浮点型：6、double双精度 占8个字节
double g = 0.5;
System.out.println("double变量g = " + g); // 0.5

3.字符类型

字符类型，char，是一个单一的 16 位 Unicode 字符，可以储存任何字符。

// 7、字符类型：char
char e = 'e';
System.out.println("char变量e = " + e); // e

4.布尔类型/逻辑类型

布尔类型/逻辑类型，boolean，只有两个取值：true 和 false。这种类型只作为一种标志来记录 true/false 情况。默认值是 false。

// 8、布尔类型：boolean
boolean h = true;
boolean h1 = false;
System.out.println("boolean变量h = " + h); // true
System.out.println("boolean变量h1 = " + h1); // false

二、类型转换

Java 作为一个强类型的编程语言，当不同类型之间的变量相互赋值的时候，会有较严格的校验。在 Java 中，当参与运算不一致时，就会进行类型转换。Java 中类型转换主要分为两类：自动类型转换（隐式）和强制类型转换（显示）。

1.自动类型转换

自动类型转换（隐式转换，小类型转换为大类型），代码不需要经过任何处理，在代码编译时，编译器会自动进行处理。
byte->short->int->long->float->double

// byte->short->int->long->float->double
byte b = 20;
short s = b;
int i = s;
long l = i;
float f = l;
double d = f;
System.out.println("byte变量b = " +b); // 20
System.out.println("short变量s = " +s); // 20
System.out.println("int变量i = " +i); // 20
System.out.println("long变量l = " +l); // 20
System.out.println("float变量f = " +f); // 20.0
System.out.println("double变量d = " +d); // 20.0

char->int

// char->int
// 当 char 直接赋给 int 时，实际上是把 char 变量的 ASCII 码赋给 int 类型
char c = 'a';
int code = c;
System.out.println("char变量c = " + c); // a
System.out.println("char变量转int变量code = " + code); // 97

2.强制类型转换

强制类型转换（显示转换，大类型转换为小类型），当进行操作时，代码需要经过一定的格式处理，不能自动完成。可能出现精度丢失，丢掉小数点或者数据溢出问题。
格式：数据类型 变量2 = （数据类型）变量1/数据

long l = 50L;
int i = (int) l;
short s = (short) i;
byte b = (byte) s;
System.out.println("long变量l = " + l); // 50
System.out.println("int变量i = " + i); // 50
System.out.println("short变量s = " + s); // 50
System.out.println("byte变量b = " + b); // 50

精度丢失，丢掉小数点或者数据溢出问题。

double d = 99.5;
float f = (float) d;
int score = (int) f;
System.out.println("double变量b = " + d); // 99.5
System.out.println("short变量s = " + f); // 99.5
System.out.println("浮点型转整数int变量score = " + score); // 99

三、引用类型

在Java中，引用类型是指在使用该类型时，变量实际上存储的是该对象的引用地址而非对象本身。也就是说，使用引用类型定义一个变量时，变量本身只存储了指向对象内存空间的地址，而对象本身则被保存在内存的某个区域中。
引用数据类型变量，调用方法时作为参数是按引用传递的，传递的是引用的副本，默认值是null。像类、接口、数组、枚举、注解、字符串等都是引用类型。

System.out.println("----除了基本数据类型，其余都是引用数据类型----");
String i = "字符串类数据类型，非基本数据类型";
System.out.println("String变量i = " + i);

四、基本数据类型的包装类

Java 语言是一个面向对象的语言，但是 Java 中的基本数据类型却是不面向对象的。基本类型的数据不具备"对象"的特性（没有成员变量和成员方法可以调用），因此，Java 为每种数据类型分别设计了对应的类，即包装类。后续的集合和泛型只能支持包装类型，不能支持基本数据类型。
整数型：byte -> Byte，short -> Short，int -> Integer，long -> Long。
浮点型：float -> Float，double -> Double。
字符型：char -> Character。
布尔型：boolean -> Boolean。

所有的包装类（Integer、Long、Byte、Double、Float、Short）都是抽象类 Number 的子类。

1.自动装箱

自动装箱：基本数据类型的数据和变量可以直接赋值给包装类型的变量。

int a = 10;
Integer a1 = 11;
// 自动装箱：基本数据类型的数据和变量可以直接赋值给包装类型的变量
Integer a2 = a;
System.out.println("int变量a = " + a); // 10
System.out.println("Integer变量a1 = " + a1); // 11
System.out.println("int变量a赋值给Integer变量a2 = " + a2); // 10

2.自动拆箱

自动拆箱：包装类型的变量可以直接赋值给基本数据类型的变量。

Integer it = 100;
// 自动拆箱：包装类型的变量可以直接赋值给基本数据类型的变量
int it1 = it;
System.out.println("Integer变量it = " + it); // 100
System.out.println("Integer变量it赋值给int变量it = " + it1); // 100

应用

包装类可以将字符串类型的数据转换为对应的基本类型。
格式：基本数据类型 变量名称 = 对应包装类.parse对应基本类型(字符串)
valueOf()的作用和parseXXX实际使用出来的效果一模一样。
字符串（引用类型）转换成整数（基本数据类型）

String number = "23";
// 字符串转换成整数
int int1 = Integer.parseInt(number);
int int2 = Integer.valueOf(number);
System.out.println(int1 + 1); // 24
System.out.println(int2 + 2); // 25

字符串（引用类型）转换成浮点数（基本数据类型）

String number1 = "99.9";
//转换成小数
double d1 = Double.parseDouble(number1);
double d2 = Double.valueOf(number1);
System.out.println(d1 + 0.1); // 100.0
System.out.println(d2 + 1.1); // 101.0

五、Math 类

1.常用 Math 类方法

Java 的 Math 包含了用于执行基本数学运算的属性和方法，如初等指数、对数、平方根和三角函数。
Math 的方法都被定义为 static 形式，通过 Math 类可以在主函数中直接调用。

public class MathDemo {
    public static void main(String[] args) {
        // 1.Math.abs取绝对值:返回正数
        System.out.println("10的绝对值 = " + Math.abs(10)); // 10的绝对值 = 10
        System.out.println("-10.3的绝对值 = " + Math.abs(-10.3)); // -10.3的绝对值 = 10.3

        // 2.Math.ceil向上取整: 5
        System.out.println("4.001向上取整 = " + Math.ceil(4.001)); // 4.001向上取整 = 5.0
        System.out.println("4.0向上取整 = " + Math.ceil(4.0)); // 4.0向上取整 = 4.0

        // 3.Math.floor向下取整：4
        System.out.println("4.99向下取整 = " + Math.floor(4.99)); // 4.99向下取整 = 4.0
        System.out.println("4.0向下取整 = " + Math.floor(4.0)); // 4.0向下取整 = 4.0

        // 4.Math.pow求指数次方
        System.out.println("2^3指数次方 = " + Math.pow(2, 3)); // 2^3指数次方 = 8.0

        // 5.Math.round四舍五入 10
        System.out.println("4.499四舍五入 = " + Math.round(4.499)); // 4.499四舍五入 = 4
        System.out.println("4.501四舍五入 = " + Math.round(4.501)); // 4.501四舍五入 = 5

        // 6.Math.random随机数,0.0 - 1.0 （包前不包后，不包含0.0和1.0）
        System.out.println("随机数 = " + Math.random()); // 随机数 = 0.057928626478629175

        // 拓展：生成 3 - 9 之间的随机数，（0 - 6） + 3
        // 因为Math.random()<1.0,所以Math.random()*7<7.0
        int data = (int) (Math.random() * 7) + 3;
        System.out.println("3-9之间的随机数 = " + data); // 3-9之间的随机数 = 8

    }
}

2.常用 Number & Math 类方法

1. xxxValue()：将 Number 对象转换为xxx数据类型的值并返回。
2. compareTo()：将number对象与参数比较。
3. equals()：判断number对象是否与参数相等。
4. valueOf()：返回一个 Number 对象指定的内置数据类型。
5. toString()：以字符串形式返回值。
6. parseInt()：将字符串解析为int类型。
7. abs()：返回参数的绝对值。
8. ceil()：返回大于等于( >= )给定参数的的最小整数，类型为双精度浮点型。
9. floor()：返回小于等于（<=）给定参数的最大整数 。
10. rint()：返回与参数最接近的整数。返回类型为double。
11. round()：四舍五入，算法为 Math.floor(x+0.5)，即将原来的数字加上 0.5 后再向下取整，所以，Math.round(11.5) 的结果为12，Math.round(-11.5) 的结果为-11。
12. min()：返回两个参数中的最小值。
13. max()：返回两个参数中的最大值。
14. exp()：返回自然数底数e的参数次方。
15. log()：返回参数的自然数底数的对数值。
16. pow()：返回第一个参数的第二个参数次方。
17. sqrt()：求参数的算术平方根。
18. sin()：求指定double类型参数的正弦值。
19. cos()：求指定double类型参数的余弦值。
20. tan()：求指定double类型参数的正切值。
21. asin()：求指定double类型参数的反正弦值。
22. acos()：求指定double类型参数的反余弦值。
23. atan()：求指定double类型参数的反正切值。
24. atan2()：将笛卡尔坐标转换为极坐标，并返回极坐标的角度值
25. toDegrees()：将参数转化为角度。
26. toRadians()：将角度转换为弧度。
27. random()：返回一个随机数。

总结

Java 有4类8种基本数据类型，除了数据类型以外都是引用类型。每种基本数据类型都有自己对应的包装类（引用类型），也是 Java 的意义，把一切都当作对象来看待。后续的集合和泛型只能支持包装类型，不能支持基本数据类型。