前置知识
计算机世界中只有二进制。那么在计算机中存储和运算的所有数据都要转为二进制。包括数字、字符、图片、声音、视频等。
进制
进制也就是进位计数制，是人为定义的带进位的计数方法 。不同的进制可以按照一定的规则进行转换。
进制的分类
- 十进制：由0到9 数字组成，进位规则：逢十进一，
- 二进制：由0到1 数字组成，进位规则：逢二进一
- 八进制：由0到7 数字组成，进位规则：逢八进一
- 十六进制：由0到9数字和字母a到f 组成，进位规则：逢十六进一
在Java代码中如何表示四种进制的值
public class Demo1 {
/*
十进制：Java中，数值默认都是10进制，不需要加任何修饰。
二进制：数值前面以0b开头，b大小写都可以。
八进制：数值前面以0开头。
十六进制：数值前面以0x开头，x大小写都可以。
注意: 书写的时候, 虽然加入了进制的标识, 但打印在控制台展示的都是十进制数据.
*/
public static void main(String[] args) {
// 十进制：正常表示
System.out.println(10);//10
//二进制：0b或0B开头
System.out.println(0B10);//2
//十六进制：0x或0X开头
System.out.println(0x10);//16
//八进制：0开头
System.out.println(010);//8
}
}计算机如何存储运算数据
计算机中的数据，都是以二进制补码的形式在存储和运算，而补码则是通过反码和原码推算出来的。
- 原码 ：可直观看出数据大小，就是二进制定点表示法，即最高位为符号位，【0】表示正，【1】表示负，其余位表示数值的大小。
- 反码 : 正数的反码与其原码相同，负数的反码是对其原码逐位取反，但符号位除外。
- 补码 : 数据以该状态进行运算，正数的补码与其原码相同；负数的补码是在其反码的末位加1。
Java中如何存储字符
在计算机的内部都是二进制的0、1数据，如何让计算机可以直接识别人类文字的问题呢？就产生出了编码表的概念。编码表 ：就是将人类的文字和一个十进制数进行对应起来组成一张表格。常见字符和数值的对应关系如下图所示：
总结：
- 将所有的英文字母，数字，符号都和十进制进行了对应，因此产生了世界上第一张编码表ASCII（ 美国标准信息交换码）。
- Unicode 是为了解决传统的字符编码方案的局限而产生的，它为每种语言中的每个字符设定了统一并且唯一的二进制编码，以满足跨语言、跨平台进行文本转换、处理的要求。
- Java中使用的字符集：Unicode字符集。存储字符时：需要查找码表,找到字符对应的数字,将数字转换为二进制数存放到计算机中 。使用字符时：将对应的二进制数转换为十进制 找到ASC表中对应的字符显示出来
- 如果编码和解码的使用不是同一种编码表，则会出现乱码问题。
计算机中的存储单位
- 进制：计算机中的数据不同于人们生活中的数据，人们生活采用十进制数，而计算机中全部采用二进制数表示，它只包含0、1两个数，逢二进一，1+1=10。每一个0或者每一个1，叫做一个bit（比特）。
- 字节：是我们常见的计算机中最小存储单元。计算机存储任何的数据，都是以字节的形式存储，右键点击文件属性，我们可以查看文件的字节大小。 8个bit（二进制位） 0000-0000表示为1个字节，写成1 byte或者1 B，计算机数据计量单位 如下所示
变量
字面量就是数据/数值，只有“字面量”机制的话，是远远不够的，因为字面量内存是无法重复利用的。使用变量之后，内存空间就得到了复用。
所谓变量：变量就是用来存储一个数据的内存区域（可以理解成盒子），且里面存储的数据可以变化。 假设变量 i 中之前存储的数据是10，我们可以将 10 换成 100，变量就是这个意思。
声明变量的实质就是申请内存空间。变量的作用：用来存储数据，代表内存的一块存储区域，这块内存中的值是可以改变的。根据变量名进行使用，可以输出，也可以修改值。变量定义的格式包括三个要素：
- 数据类型：规定了变量可以存储数据大小及存储什么样子的数据
- 变量名：告诉程序员如何访问这块内存及其里面的数据
- 数据值：存储在变量中的数据
变量的声明和赋值
- 方式一：先声明，后赋值（使用前赋值即可）
public class Demo01Variable {
public static void main(String[] args) {
/*
变量的定义格式
数据类型 变量名称;
变量名称 = 数据值;
*/
byte a;//声明了一个byte类型(1个字节)的变量,给变量名称叫做a
//把数字66存储到byte类型的变量a中
a = 66;
//打印变量a中保存的数据
System.out.println(a);// 66
//把数字88存储到byte类型的变量a中,原有的数据66将被替换
a = 88;
//打印变量a中保存的数据
System.out.println(a);// 88
}
}还可以在同一行声明多个同一种数据类型的变量，中间使用逗号隔开。但不建议使用这种方式，降低程序的可读性。
public class Demo02Variable {
public static void main(String[] args) {
/*
变量的定义格式
数据类型 变量名称1,变量名称2,变量名称3;
变量名称1 = 数据值1;
变量名称2 = 数据值2;
变量名称3 = 数据值3;
*/
//声明了三个int类型(4个字节)的变量,给每个变量分别起名为c,d,e
int c, d, e;
//给c,d,e 变量分别赋值
c = 200;
d = 300;
e = 500;
//打印各种变量中保存的数据
System.out.println(c);//200
System.out.println(d);//300
System.out.println(e);//500
}
}- 方式二：声明变量且同时赋值
public class Demo03Variable {
public static void main(String[] args) {
/*
变量的定义格式二:
数据类型 变量名称 = 数据值;
*/
//声明了一个short类型(2个字节)的变量,变量名称为b,同时给b赋值为100
short b = 100;
System.out.println(b);// 100
}
}也可以在同一行声明多个同一种数据类型的变量，中间使用逗号隔开。但不建议使用这种方式，降低程序的可读性。
public class Demo04Variable {
public static void main(String[] args) {
/*
变量的定义格式
数据类型 变量名称1 = 数据值1,变量名称2 = 数据值2,变量名称3 =数据值3 ;
*/
//声明3个long类型的变量f,g,h，并且同时各自赋值
long f = 600L,g = 700L,h = 800L;
//打印long类型(8个字节)的变量中保存的内容
System.out.println(f); //600
System.out.println(g); //700
System.out.println(h); //800
}
}变量定义的注意事项:
- 变量名称：变量的有效范围是从定义开始到 “}” 截止，同一个范围内部不能定义2个同名的变量。对变量重新赋值时，前面一定不要加数据类型，否则相当于重新声明一个新的变量会报错
- 变量的作用域：变量的有效范围。大家可以记住一句话，变量出了所在的大括号就从内存中释放了。如果超过作用域，也会报“找不到符号”错误 。例如：局部变量只在方法体当中有效，方法体执行结束该变量的内存就释放了。
- 变量赋值：定义的变量，不赋值不能使用。赋值又叫初始化，如果没有初始化，会报“未初始化”错误
- 定义long类型的变量时：需要在整数的后面加L（大小写均可，建议大写）。随便写一个整数字面值，默认是int类型的，
- 定义float类型的变量时：需要在小数的后面加F（大小写均可，建议大写）。随便写一个小数字面值，默认是double类型的
-
什么类型变量一定要存储什么类型的字面值， 存储了其他类型的数据就可以报错。 例如：int类型的变量存储了字符串就会报错
代码示例
public class Demo04Variable {
public static void main(String[] args) {
/*
1. 变量名不允许重复定义
*/
int a = 10;
// int a = 20; 错误代码，重复定义变量名
a = 20;
System.out.println(a);
/*
3. 变量在使用之前一定要进行赋值
*/
int i;
//System.out.println(i);错误
/*
4. 定义float和long变量的注意事项
定义float类型变量的使用: 需要在数值的后面加入F的标识,F可以大写也可以小写.但是, 建议大写
定义long类型变量的使用 : 需要在数值的后面加入L的标识,L可以大写也可以小写.但是, 建议大写
*/
float f = 12.3F;
long l = 1000L;
System.out.println(f);
System.out.println(l);
/*
5. 变量的作用域范围
变量的作用域 : 只在它所在的大括号中有效
*/
{
int x = 20;
// 当这个大括号中的代码执行完毕后, 内部所[定义]的变量就会丛内存中消失
System.out.println(x);
}
//System.out.println(x); 错误：变量的作用域 : 只在它所在的大括号中有效
}
}数据类型
Java是一种强类型语言，针对每种数据都给出了明确的数据类型 。Java的数据类型分为两大类：
- 基本数据类型：包括 整数、浮点数、字符、布尔类型
- 引用数据类型：包括 类、数组、接口。
今天我们重点学习的是基本数据类型，关于引用数据类型，后面我们会重点学习。
那为什么会有不同的数据类型呢？
- 不同的数据类型分配了不同的内存空间，数据类型就是约束变量存储数据的形式。
- 不同的内存空间，所存储的数据大小是不一样的
在这里，我们给出每种基本数据类型的内存占用和取值范围，大家了解一下：
整型系列(整数)
/*
注意事项：
Java中的默认整数类型是int，给 byte 或者 short赋值时，其值只要不超出其取值范围就可以直接赋值，否则报错
声明long类型数值的时候 要在数值的末尾+l/L。 建议使用大写的L
*/
public class Demo01DataTypeTest {
public static void main(String[] args) {
/*
（1）byte：字节类型： 占内存：1个字节 存储范围：-128~127
*/
byte b = 127;
// b = 128; 不兼容的类型: 从int转换到byte可能会有损失
System.out.println("b = " + b);
/*
short：短整型类型：占内存：2个字节，存储范围：-32768~32767
*/
short s = 20;
System.out.println("s = " + s);
/*
int：整型：占内存：4个字节，存储范围：-2的31次方 ~ 2的31次方-1
*/
int i = 30;
System.out.println("i = " + i);
/*
long：长整型：占内存：8个字节，存储范围：-2的63次方 ~ 2的63次方-1
*/
long l = 2222222222L; //如果要表示某个超过int范围的常量整数它是long类型，那么需要在数字后面加L
System.out.println("l = " + l);
}
}
浮点型系列（小数）
/*
浮点型：
1. 浮点类型 默认的数据类型是 double，
2. 声明float类型的数据 要在数值的末尾 + f/F
建议大家使用 F
3.浮点类型底层采用的是科学计数法表示
double d1 = 3.14e2;
d1 = 3.14E2;
4. 小数底层存储方式与 整数不同，细分为 符号位 指数位 尾数位
5. 小数不能精确的表示一个值
*/
public class Demo02DataTypeTest {
public static void main(String[] args) {
/*
float：单精度浮点型
占内存：4个字节
精度：科学记数法的小数点后6~7位
*/
float f = 3.14F; //如果要表示某个常量小数是float类型，那么需要在数字后面加F或f，否则就是double类型
System.out.println("f = " + f); //f = 3.14
f = 3.14E10F;
System.out.println("f = " + f); //f = 3.13999995E10
/*
double：双精度浮点型
占内存：8个字节
精度：科学记数法的小数点后15~16位
*/
double d = 3.14;
System.out.println("d = " + d); //d = 3.14
d = 3.14e10;
System.out.println("d = " + d); //d = 3.14E10
}
}
单字符类型：char
字符常量的几种表示方式
- 一个字符 ，例如：'A'，'0'，'尚'
- 转义字符，例如：\n：换行 。转义：把一个字符通过在前面附加“\”符号，让它从自己原本的含义，转变为新的含义
- \u字符的Unicode编码值的十六进制型
- 直接给char类型变量赋值十进制的0~65535之间的Unicode编码值
/*
字符类型:
占内存：2个字节 ,有且只能存储一个字符
*/
public class Demo04DataTypeTest {
public static void main(String[] args) {
//一个字符
char c1 = 'A';
System.out.println("c1 = " + c1); //c1 = A
//（2）转义字符
char c2 = '\t';
System.out.println("你好" + c2 + "世界"); //你好 世界
//（3）字符的Unicode编码值的十六进制型
char c3 = '\u5c1a';
System.out.println("c3 = " + c3); //c3 = 尚
//（4）直接给char类型变量赋值十进制的0~65535之间的Unicode编码值
char c4 = 97;
System.out.println(c4);// a
}
}
布尔类型
虽然计算机底层使用0和1表示false和true，但是在代码中不能给boolean类型的变量赋值0和1，只能赋值false和true
/*
boolean
占内存：1个字节
有且仅有两个值 true / false
*/
public class Demo03DataTypeTest {
public static void main(String[] args) {
boolean flag = true;
System.out.println(flag); //true
flag = false;
System.out.println(flag); //false
}
}
总结：
- 书写long类型的常量，需要在数字后面加大写L（建议用大写）或小写l
- 如果要表示某个常量小数是float类型，那么需要在数字后面加F或f，否则就是double类型
- 书写char类型的字符常量，我们可以直接写单个字符或者写转义字符又或者直接写Unicode编码值的十六进制形式。因为在Java中是使用Unicode编码表表示。（兼容ASCII码），每一个字符都有一个唯一的Unicode编码值。
- 虽然计算机底层使用0和1表示false和true，但是在代码中不能给boolean类型的变量赋值0和1，只能赋值false和true
- 浮点类型不精确，因为十进制的小数部分转二进制会需要舍去。float类型的4个字节能表示的数字范围比long类型的8个字节还要大因为小数底层存储方式与整数不同
数据类型转换
- Java程序中要求参与的运算的数据，必须要保证数据类型的一致性，如果数据类型不一致将发生类型的转换。
- boolean类型不参与数据类型转换。
自动类型转换
- 将 取值范围小的类型 自动提升为 取值范围大的类型的过程就是自动类型转换。
- 自动类型转换是自动完成的,不需要我们代码的干预。类型范围小的变量，可以直接赋值给类型范围大的变量。
- 自动类型转换对原有数据大小是没有影响的，数据类型的转换关系（取值范围从小到大），如图所示：
下列情况就会发生自动类型转换
- 当把存储范围小的值（常量值、变量的值、表达式计算的结果值）赋值给了存储范围大的变量时，
byte b = 1;
short s = b; //byte自动升级为short
// char c = s; 错误
int i = 'A';//char自动升级为int
double d = 10;//int自动升级为double
byte b1 = 127; //右边的整数常量值必须在-128~127范围内
//byte bigB = 130;错误，右边的整数常量值超过byte范围
long num = 1234567; //右边的整数常量值如果在int范围呢，编译和运行都可以通过，这里涉及到数据类型转换
long bigNum = 12345678912L;//右边的整数常量值如果超过int范围，必须加L，否则编译不通过- 当存储范围小的数据类型与存储范围大的数据类型一起混合运算时，会按照其中最大的类型运算。表达式的最终结果类型由表达式中的最高类型决定。
int i = 1;
byte b = 1;
double d = 1.0;
double sum = i + b + d;//混合运算，升级为double- 当byte,short,char数据类型进行算术运算时，都会先自动转换为int类型在进行运算。
byte b1 = 1;
byte b2 = 2;
byte b3 = b1 + b2;//编译报错，b1 + b2自动升级为int
char c1 = '0';
char c2 = 'A';
System.out.println(c1 + c2);//113 强制类型转换由来
- 类型范围大的数据或者变量，不能直接赋值给类型范围小的变量，会报错。
强制类型转换
- 将取值范围大的类型 强制转换成 取值范围小的类型 的过程就是强制类型转换
特点：
- 自动转换是Java自动执行的，而强制转换需要我们自己手动执行。
- 转换格式：数据类型 变量名 = （数据类型）被转数据值；
- 强制类型转换对原有数据大小是有影响的，有可能造成数据溢出和精度损失
下列情况就会发生强制类型转换
当把存储范围大的值（常量值、变量的值、表达式计算的结果值）赋值给了存储范围小的变量时，需要强制类型转换，提示：有风险，可能会损失精度或溢出
public class Demo02Convert {
public static void main(String[] args) {
short s = 1;
/*
s是short类型,1是int类型,运算时类型不一致,会发生自动类型转换
short类型(2个字节)的s会自动转换成int类型
最终变成了两个int数据相加,结果是int类型
不能直接赋值给左侧的short类型的变量s
但是在赋值之前把int类型的结果,强制转换成short类型(砍掉左侧的2个字节的内容),
*/
s = (short) (s + 1);
System.out.println(s);
double d = 9.999;
//浮点型强转成整型，直接丢掉小数部分，保留整数部分返回。
int i = (int) d;//精度损失
System.out.println(i);//9
int a = 8888;
byte b = (byte) a;//数据溢出
System.out.println(b);//-72
}
}当某个值想要提升数据类型时，也可以使用强制类型转换。提示：这个情况的强制类型转换是没有风险的。
int i = 1;
int j = 2;
double shang = (double)i/j;基本数据类型之间是存在固定的转换规则的，无论是哪个程序， 将这 6 个规则套用进去，问题迎刃而解：
- 八种基本数据类型中，除 boolean 类型不能转换，剩下七种类型之间都可以进行转换；
- 如果整数型字面量没有超出 byte,short,char 的取值范围，可以直接将其赋值给 byte,short,char 类型的变量；
- 小容量向大容量转换称为自动类型转换，容量从小到大的排序为：byte < short(char) < int < long < float < double，其中 short 和 char 都占用两个字节，但是 char 可以表示更大 的正整数；
- 大容量转换成小容量，称为强制类型转换，编写时必须添加“强制类型转换符”，但运行时可能出现精度损失，谨慎使用；
- byte,short,char 类型混合运算时，先各自转换成 int 类型再做运算；
- 多种数据类型混合运算，各自先转换成容量最大的那一种再做运算；
