一、整数类型
- Java有四种整数类型：byte、short、int和long。
- Java默认整数计算的结果是int类型。
- 整数的字面量是int类型。
- 若字面量超过int类型的最大值，则字面量是long类型，那么后面要用L（或l）表示该值是long类型。
【示例】将字面量30亿赋值给一个long类型的变量。
long longValue=3000000000L; 后面必须写有L，否则会报语法错误。
- java底层byte和short按照32位（int类型）计算。
【示例】以下将注释符号去掉，结果是？
示例.png
代码
public static void main(String[] args) {
byte b1=5;
byte b2=b1+3;
}
去掉后，会出现语法错误，将光标移动到错误位置，提示不匹配，不能将int类型转换成byte类型。
修改方式一：
public static void main(String[] args) {
byte b1=5;
byte b2=(byte) (b1+3); //强转成byte类型
}
修改方式二：
public static void main(String[] args) {
byte b1=5;
int b2=b1+3; //将b2定义成int类型，语法错误消失，证明b1+3的结果是int类型
}
扩展：
public static void main(String[] args) {
byte b1=5;
byte b2=124+3;
}
这样书写，代码不会报错。
分析：124+3Java语言对于明显的能确定出结果的计算都会在编辑器把这个值直接计算完保存在变量b2中。
编译器就是.java程序变成.class文件这个过程，在解释运行时，不再运行124+3了，而直接b2中存储的就是结果127，因此就不出现刚才遇到的语法错误。
如果把124变成125，又会出现编译错误，这个错误是因为125+3的结果128超过了byte类型最大值127，所以又会出现编译错误，根据提示修改即可。
二、浮点类型
1、概述
- 浮点类型用于表示小数的数据类型。
- 浮点数原理：也就是二进制科学计数法。
- Java的浮点类型有float和double两种。
- Java默认浮点类型计算的结果是double类型，字面量也是double类型。
若要给float类型的变量赋字面量的值，则要在字面量后面加F（或f）。
【示例】float f=5.3;将会出现编译错误，正确的赋值是：float f=5.3f;
2、浮点类型的科学计数法
- 十进制浮点数科学计数法：219345=2.19345*（10^5）
- 二进制浮点数科学计数法：10111=1.0111*（2^100）
以2.19345*（10^5）为例介绍如下概念：
尾数：2.19345
指数：5
基数：10
3、float类型
- float类型共32位，1位为符号位，指数8位，尾数23位。
- float的精度是23位（即能精确表达23位的数，超过就被截取了）。
小数是以尾数长度来表示精确度的，比如pi=3.1415的精度是4位。- float存储数据的范围大于int类型，但精度比int要小，因为int的精度是31位。
4、double类型
- double类型，1位符号位，11位指数，52位尾数。
- double范围远远大于long，但double精度不如long(long存储数据的位数是63位)。
5、浮点运算特点
浮点运算就是实数运算，由于计算机只能存储整数，所以实数都是约数，这样浮点运算是很慢的而且会有误差。
【示例】浮点运算误差，如下代码所示：
代码：
public static void main(String[] args) {
double d = 2.6;
double e = d - 2;
System.out.println("d-2="+e);
}
运算结果：d-2=0.6000000000000001
三、字符类型
1、概述
- char类型的字面量可以是一个英文字母、字符或一个汉字，并且由单引号包括。
例如：'A' 、 'a' 、 '3' 、 '\n'- Java底层使用一个16位的整数来处理字符类型，该数值是一个字符的unicode编码值。
2、unicode编码
- unicode编码是全球范围内的编码方法。
- unicode编码的英文部分与ASCII码兼容（ASCII表示范围0~128），同时英文字符和数字是连续编码的。
- Java在处理char类型的数据时，在底层是按unicode码来处理的。
- 编码是什么？
计算机硬件系统只能用0和1表示数，我们人为地做了规定，某个数还可以表示一个字符。
例如：65代表的字符是A
【示例-1】编写Java代码在控制台打印出unicode码从0~127的所有字符：
代码
public class Test07 {
/**
* 显示0-127的字符
*/
public static void main(String[] args) {
for (int i = 0; i <= 127; i++) {
System.out.println((char)i+":"+i);
}
}
}
四、转义字符
转义字符是“\”，通过转义字符，可表示一些特殊的字符。
例如：
'\n'表示回车
'\t'表示制表位字符，一个制表符表示向右跳8-10个字符
'\\'表示\
'\''表示单引号
'\"'表示双引号
'\u4e2d'表示unicode编码对应的字符（汉字：中）。
【示例】在输出命令中打印转义符。
输出命令.png
代码
public class Test08 {
public static void main(String[] args) {
System.out.print('\u4e2d'+":");
System.out.println(4*Math.pow(16, 3)+14*Math.pow(16, 2)+2*16+13);
System.out.println((char)20013+":"+20013);
System.out.println("我和\n你不在一行呦");
System.out.println("\t我在这里显示呦!");
System.out.println("System.out.println(\"双引号也显示出来啦\");");
}
}
结果：
中:20013.0
中:20013
我和
你不在一行呦
我在这里显示呦!
System.out.println("双引号也显示出来啦");
五、布尔类型的概念和用法
- boolean类型用来表示肯定或否定两种可能。
- 布尔类型常用在分支语句、循环语句中。用来控制程序的走向。
- boolean类型的值有两个：
true：表示肯定意义；false：表示否定意义：- 布尔变量的定义:
boolean isPass;- 布尔变量的初始化
boolean isPass=true;
isPass=59>=60; //赋值
【示例】编程用布尔变量表示考试是否及格，运行效果如下图所示：
运行效果.png
代码
public class Test09 {
public static void main(String[] args) {
boolean isPass;
isPass=true;
System.out.println("考试通过："+isPass);
isPass=false;
System.out.println("考试通过："+isPass);
isPass=65>=60;
System.out.println(65+"分及格："+isPass);
}
}
结果：
考试通过：true
考试通过：false
65分及格：true
六、小类型向大类型转换
1、概述
不同的类型的数据经常出现相互转换的现象。
- 小类型向大类型的转换会自动完成，即不需要程序员编写额外的代码，由JVM负责。
提示：自动类型转换也叫“隐式类型转换”。- 自动转换的规则：符号位会自动扩展，负数补1，正数补0。
- 自动类型转换包含以下情况：
（1）byte->short->int->long->float->double
（2）int和char类型的数据在某些情况下可以自动相互转换。- 整数到浮点数转换会损失精确度。
【示例】int类型的数据自动转换为long类型的数据。
代码
public class Test10 {
public static void main(String[] args) {
int i=-2;
long l=i;
System.out.println(i+":"+Integer.toBinaryString(i));//打印i的二进制值
System.out.println(l+":"+Long.toBinaryString(l));//打印l的二进制值
}
}
结果：
-2:11111111111111111111111111111110
-2:1111111111111111111111111111111111111111111111111111111111111110
2、案例
- 小类型向大类型转换一般情况下是安全的。
- 当小类型的精度高于大类型时要注意精度丢失的隐患。
【案例一】 int类型转换为float类型丢失精度的案例。
代码
public class Test11 {
public static void main(String[] args) {
//7位的十六进制数，7位数转换成二进制就是4*7=28-28位，这样就超出了float类型尾数23位的范围，
//就有可能出现尾数不够，精度丢失的问题
int i=0x1000001;
float f=i;
System.out.println(Integer.toBinaryString(i)+":"+i);
System.out.println(Integer.toBinaryString((int)f)+":"+f);
}
}
结果：
1000000000000000000000001:16777217
1000000000000000000000000:1.6777216E7
【案例二】long类型转换为double类型的精度丢失案例
代码
public class Test12 {
public static void main(String[] args) {
//long是8位8个字节64位，高位是符号位，存储数据的精度是63位
//double类型也是8个字节64位，存储数据的尾数即精度只有52位
//给一个十六进制的数，54位的：56\4=14 ,14位的十六进制数
long l=0x20000000000001L;
double d=l;
System.out.println(Long.toBinaryString(l)+":"+l);
System.out.println(Long.toBinaryString((long)d)+":"+d);
}
}
结果：
100000000000000000000000000000000000000000000000000001:9007199254740993
100000000000000000000000000000000000000000000000000000:9.007199254740992E15
七、大类型向小类型转换
1、概述
- 强转类型转换-简称强转
例如：
byte b=5;
b=(byte)(b+10);强转
b=5+10;无需类型转换
原因：Java语言对于5+10这种明显的可以得出结果的字面量的运算，在编译期间直接将5和10相加，如果结果没有超过字节类型的最大值，那么就没有任何错误，结果15会在编辑期间就保存在变量b中。如果是变量b和10相加，那么Java语言不能确定变量b中的值肯定是5，因此b+10是在解释运行期间才进行计算，那么这个结果就按默认的int类型来处理，所以如果是向字节类型变量赋值，需要做强制类型转换。- 强制类型转换时，要注意边界数风险问题。
2、案例
【示例-1】大类型转换小类型时，源数据的数据位变为目标数据的符号位。
int i=129;
byte b=(byte)i;
变量b的值是多少？
10000001=129
011111111 逐位取反再加1
-127
【示例-2】大类型的数据超过了小类型的位数示例。
int i=257
byte b=(byte)i;
变量b的值是多少？
1,0000,0001=257
0000,0001 byte类型变量只能存储8位，最高位抛弃
因此，257转换为byte类型后结果是+1。
八、int类型与char类型转换
Java对char类型的数据在底层是按int类型来处理的。
【示例-1】int类型与char类型在赋值时可自动转换。
代码
public class Test13 {
public static void main(String[] args) {
char c=65;
int i='B';
System.out.println(c+","+i);
}
}
结果：
A,66
【示例-2】字符类型的数据可进行数值计算。
代码
public class Test14 {
public static void main(String[] args) {
char c='A';
int i=c+1;
c=(char) (c+1);//强制类型转换
System.out.println(c+":"+i);
}
}
结果：
B:66
