## 类型转换
> **二进制**
>
> 1. 在计算机运算的时候，都是以 **补码** 的方式来运算的。
> 2. 二进制 转为 十进制，必须使用 **二进制的原码** 进行转换 。
#### 转换规则
##### 谨记
> **第一条：**八种数据类型中，除boolean不能转换，剩下的七种都可以进行转换；
>
> **第二条：**如果整数型字面量没有超出 byte、short、char 的取值范围，可以直接赋值给其类型的变量；
>
> **第三条：**小容量转换为大容量是自动类型转换，容量从大到小排序：
>
> byte < short(char) < int < long < float < double
>
> 其中，short和char的容量大小一致，都只占用两个字节，但是char可以表示更大的正整数；
>
> **第四条：**大容量转换为小容量是强制类型转换，编写时必须添加“强制类型转换符”，但运行时可能会丢失精度和内存溢出；
>
> **第五条：**byte、short、char 类型混合运算时，**先各自转换为int类型再进行运算**；
>
> **第六条：**多种数据类型混合运算时，先各自转换成容量最大的数据类型再进行运算。
#### 自动转换
> **整数型：**java中**整数型字面量默认是int类型**的，所以`int a = 100;`，不存在类型转换，
>
> 如果希望**整数型字面量被当作long类型**，需要**在字面量后加L或l**，一般加L
>
> **浮点型：**java中**浮点型字面量默认是double类型**的，所以`double a = 3.1415926;`，不存在类型转换，
>
> 如果希望**整数浮点型字面量被当作float类型**，需要**在字面量后加F或f**
>
> **注意点：**
>
> 1. 在java中先执行等号右边，所以**整数型**需要注意字面量是否**超出默认范围**，即int取值范围
>
> 例：int [-2147483648 ~ 2147483647]
>
> `int a = 2147483647;`，编译通过可执行
>
> `long a = 2147483648L;`，编译通过可执行
>
> `int a = 2147483648;`，编译不通过，报错，即**等号右边超出int默认范围**
>
> 2. 在java中先执行等号右边，所以**浮点型**需要注意字面量是否**超出默认范围**，即double取值范围
>
> 例：double [-2^61 ~ 2^61-1]
>
> `double a = 3.1415926;`，编译通过可执行
>
> `float a = 3.1415926f;`，编译通过可执行
##### 实例
```java
//整数型 int [-2147483648 ~ 2147483647]
int a = 2147483647;//不存在类型转换，默认2147483647为int类型，且不超出int取值范围
long b = 2147483647;//类型自动转换，将int类型转换为long类型
int c = 2147483648;//编译报错，默认2147483648为int类型，但2147483648已超出int取值范围
long d = 2147483648L;//不存在类型转换，在字面量后已经声明L，且不超出long的取值范围
//浮点型 double
double a = 3.1515926;//不存在类型转换，默认3.1515926为double类型，且不超出double取值范围
float b = 3.1515926;//编译报错，默认3.1515926为double类型
float c = 3.1515926f;//类型自动转换，将double类型转换为float类型
```
> 当用**byte、short和char**数据类型定义的字面量没有超过其取值范围时，不需要强制转换为其数据类型
>
> 当一个整数赋值给char类型变量时，会自动转换为char字符型，输出时，会输出一个字符结果
```java
//整数赋值给char类型变量时，输出结果为'a'
char a = 97;
//当字面量没有超过其数据类型的取值范围时，不需要强制转换为其数据类型
byte a = 100;
byte b = 1;
//当在计算并赋值时，默认a+b为int类型，此时则需要强转
byte c = (byte)a+b;
```
#### 强制转换
> 大容量无法直接转换为小容量，必须经过强制转换才可以，
>
> 但是，用**byte、short和char**数据类型定义的字面量没有超过其取值范围时，就不需要强制转换为其数据类型
>
> 当在计算并赋值时，默认a+b为int类型，此时则需要强转，因为编译器不知道计算结果，只知道a+b是int类型
>
> ```java
> //JDK7特性：数字之间可以用下划线分割
> int a = 21_4748_3647;
> int b = 1;
> int sum = a + b;//结果应为2147483648，实际结果为-2147483648，因为出现了内存溢出问题（二进制原码、反码、补码）
> ```
>
> **注意点：**
>
> 1. 大容量转换为小容量时，需要强制转换
> 2. 转换的时候可能存在**内存溢出**和**丢失精度**问题
> 3. **操作比较大的数时，容易出现内存溢出问题**
> 4. 不能转换布尔类型
> 5. 不能把对象转为不相干的类型
>
> **从低到高：**byte、short、char --> int --> long --> float --> double
##### 实例
```java
1. byte i = 300;//会直接编译报错
2. byte b = (byte)300;//编译通过，运行结果为44，因为大容量转换为小容量时只保留小容量的二进制位数
/*例：300为int类型，其二进制表示为：00000000 00000000 00000001 00101100
当转换为byte类型时，只保留为：00101100 ，其转换为十进制就是44 */
3. char c = 'a';//ASCII码值为97，所以char c = 97时，c为'a'
int d = c+1;//默认c+1为int类型
System.out.println(d);//输出为98，因为c在计算机中时二进制码00110001，此时+1就是00110010，即为98
System.out.println((char)d);//输出为b，同上，此时二进制码为00110010，强制转换为ASCII码，即为b
```
> 牵扯到二进制问题
>
> [详解](https://blog.csdn.net/qq_41694349/article/details/79481089?utm_medium=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromBaidu%7Edefault-5.control&depth_1-utm_source=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromBaidu%7Edefault-5.control)
```java
byte b = (byte)135;
System.out.println(b);//-121
/*
* 内存溢出
*
* 135的二进制码（此时即为补码）：00000000 00000000 00000000 10000111
*
* 转换为byte是（此时也为补码）：10000111
*
* 需要将二进制转换为十进制输出，则
*
* 需要从补码逆推出原码（补码的补码就是原码，即补码取反+1，或者补码-1取反）
*
* 补码：10000111 10000111
*
* 反码：10000110 11111000
*
* 原码：11111001 11111001
*
* 64+32+16+8+1=121
*
* System.out.println(b);//-121
*
* 补码转原码（示例，跟上题无关）
* 取反+1 -1取反
* 原码：10011011
* 反码：11100100
* 补码：11100101
* 反码：11100100 10011010
* 原码：10011011 10011011
*
* */
```
#### 混合运算
> **当byte、short、char进行混合运算时，会各自转换成int类型进行运算**
>
> 当其他数据类型进行混合运算时，结果类型是最大容量的数据类型
##### 实例
```java
//当只有byte、short、char进行混合运算时，会各自转换成int类型进行运算
byte a = 100;
short b = 1000;
char c = 'a';
int sum = a + b + c;//1197
//当与其他数据类型进行混合运算时，结果类型是最大容量的数据类型
//例1：
long a = 1000L;
int b = 100;
short c = 10;
byte d = 1;
char e = 'c';
long sum = a + b + c + d + e;//1210
//例2：
long a = 1000L;
int b = 100;
short c = 10;
byte d = 1;
char e = 'c';
float f = 1.11f;
double g = 11.11;
double sum = a + b + c + d + e + f + g;//1222.2199853515624，java中浮点型存放的都是近似值
//java中规定，int类型的最终结果还是int类型
int a = 10/3;//a=3
int b = 1/2;//b=0
```