只记录我觉得重点的，自用，如果有漏的请自己看视频

33. 内容梳理

详见视频，回顾第2章内容

34. 变量原理

34.1 为什么需要变量

• 变量是程序的基本组成单位

不论是使用哪种高级程序语言编写程序，变量都是其程序的基本组成单位

//变量有三个基本要素（类型+名称+值）
public class Test
{public static void main(String[] args){int a = 1;//定义了一个变量，类型int整型，名称a ，值1int b = 3;//定义了一个变量，类型int整型，名称b ，值3b = 89;//把89值赋值给b变量System.out.println(a);//输出a变量的值System.out.println(b);//输出b变量的值}
}

创建一个变量会在内存中开辟一段空间

实际上这个变量名在计算机中对应的是主存单元地址（详细见计算机组成原理）

35. 变量概念

35.1 概念

变量相当于内存中一个数据存储空间的表示，你可以把变量看做是一个房间的门牌号，通过门牌号我们可以找到房价，而通过变量名可以访问到变量（值）。

35.2 变量使用的基本步骤

1. 声明变量，如：int a;
2. 赋值，如a = 60; //应该这么说：把60赋给a
3. 使用System.out.println(a);//输出结果

也可以一步到位[int a = 60; //通常我们是一步完成]
声明变量的简单例子代码：

public class Var01
{public static void main(String[] args){//声明变量int a;a = 100;System.out.println(a);//还可以这样使用int b = 800;System.out.println(b);}
}

编译运行结果：

36. 变量入门

36.1 变量使用入门案例

演示记录人的信息的代码，用不同的数据类型来记录这个人的信息。
代码：

public class Var02
{//编写一个main方法public static void main(String[] args){//记录人的信息int age = 30;double score = 88.9;char gender = '男';String name = "king";//输出信息System.out.println("人的信息如下");System.out.println(name);System.out.println(age);System.out.println(score);System.out.println(gender);}
}

编译运行结果：

37. 变量细节

37.1 变量使用注意事项

1. 变量表示内存中的一个存储区域[不同的变量，类型不同，占用的空间大小不同
   比如:int 4 个字节， double 就是 8个字节,先有基本印象，后面说字节]
2. 该区域有自己的名称[变量名]和类型[数据类型]
3. 变量必须先声明，后使用，即有顺序
4. 该区域的数据/值可以在同一类型范围内不断变化
5. 变量在同一个作用域内不能重名
6. 变量=变量名+值+数据类型，这一点请大家注意。变量三要素。

举例子的代码：

public class VarDetail
{public static void main(String[] args){//变量必须先声明，后使用，即有顺序int a = 50;System.out.println(a);}
}

运行结果：

反过来不行：

如果后期赋值将a赋值为String类型也会报错，变量必须保持一个类型。

变量在同一个作用域里不能重复定义：

但是在不同的作用域（比如不同的类）可以重复定义同一个名字的变量：

38. 加号使用

38.1 程序中+号的使用

1. 当左右两边都是数值型时，则作加法运算；
2. 当左右两边有一方为字符串，则作拼接运算；
3. 运算顺序是从左到右

下面代码输出什么？

System.out.println(100 + 98);//198
System.out.println("100" + 98);//10098
System.out.println(100 + 3 + "hello");//从左到右，先算数值型100+3=103，然后将1-3和hello字符串拼接最后得103hello
System.out.println("hello" + 100 +3);//先拼接hello字符串和数值100，然后变为字符串hello100后再拼接3，变成字符串hello1003

39. 数据类型

每一种数据都定义了明确得数据类型，再内存中分配了不同大小的内存空间（字节）。

上图说明

1. java 数据类型分为两大类 基本数据类型， 引用类型
2. 基本数据类型有 8 中 数值型 [byte , short , int , long , float ,double] char , boolean
3. 引用类型 [类，接口， 数组]

【注】String不是基本数据类型，它是一个类。

40. 整型使用

40.1 整数的类型

Java的整数类型就是用于存放整数值的，比如12，30，3456等等，范围是根据二进制位数来确定的，具体可见计算机组成原理。

类型	占用存储空间	范围
byte[字节]	1字节	-128~127
shott[短整型]	2字节	$$\begin{gathered} -2^{15}\sim 2^{15}-1 \\ -32768\sim 32767 \end{gathered}$$
int[整型]	4字节	$$\begin{gathered} -2^{31}\sim 2^{31}-1 \\ -2147483648\sim 2147483647 \end{gathered}$$
long[长整型]	8字节	$-2^{63}\sim 2^{63}-1$

41. 整型细节

41.1 整型的使用细节

1. Java各整数类型有固定的范围和字段长度，不受具体OS[操作系统]的影响，以保证java程序的可移植性。
2. Java的整型常量(具体值)默认为int 型，声明long型常量须后加’l’或’L’；
   比如：

int n1 = 1;
int n2 = 1l; //错的，左侧是int，右侧是long，无法赋值，编译器先发现右侧是long类型，占8个字节

这样写就对了：

long n3 = 1L;//或者写1l，小写的l也对

4. java程序中变量常声明为int型，除非不足以表示大数，才使用long；（尽可能占用的字节数少）
5. bit: 计算机中的最小存储单位。byte:计算机中基本存储单元,1byte =8 bit。
   [二进制再详细说，简单举例一个 byte 3 和 short 3 ]

byte n1 = 3;
short n2 = 3:

思考题:long 类型，有几个 bit [8个字节*8bit= 64]
long n = 3;// 内存中存在形式（画八个字节，从右往左最开始第0位，第1位是1，剩下全是0）

42. 浮点数使用

Java的浮点类型可以表示一个小鼠，比如123.4，7.8，0.12等等

42.1 浮点型的分类

类型	占用存储空间	范围
单精度float	4字节	-3.403E38~3.403E38，即$-3.403^{38}\sim 3.403^{38}$
双精度double	8字节	-1.798E308~1.798E308，即$-1.798^{308}\sim 1.798^{308}$

【注】1)关于浮点数在机器中存放形式的简单说明，浮点数=符号位+指数位+尾数位；
2)尾数部分可能丢失，造成精度损失（小数都是近似值）

43. 44. 浮点数细节1,2

1. 与整数类型类似，Java浮点类型也有固定的范围和字段长度，不受具体OS的影响。[float 4个字节，double 是8个字节]
2. Java的浮点型常量默认位double型，声明float型常量，须后加’f’或’F’；
3. 浮点型常量有两种表示形式：
   十进制数形式：如： 5.12 512.0f .512（必须有小数点）
   科学计数法形式：如 5.12e2[] 5.12E-2[]
4. 通常情况下，应该使用double型，因为它比float型更精确。
   double num9 = 2.1234567851;
   float num10 = 2.1234567851F;
5. 浮点数使用陷阱：2.7和8.1/3比较

public class FloatDetail
{public static void main(String[] args){//Java的浮点型常量默认位double型，声明float型常量，须后加'f'或'F'；//float num1 = 1.1; //不做任何处理占8个字节的double，这是错误的float num2 = 1.1F; //对的，明确告诉编译器这是float，写小写的f也可以double num3 = 1.1; //对的double num4 = 1.1F; //把占字节数小的float放入占8个字节的double中是可以的//十进制数形式：如： 5.12	512.0f	.512（必须有小数点）double num5 = .123; //等价于0.123System.out.println(num5);//打印出0.123//科学计数法形式：如 5.12e2[]	5.12E-2[]System.out.println(5.12e2);//512.0System.out.println(5.12E-2);//0.0512//通常情况下，应该使用double型，因为它比float型更精确。double num9 = 2.1234567851;float num10 = 2.1234567851F;System.out.println(num9);System.out.println(num10);//看卡一段代码double num11 = 2.7;double num12 = 8.1 / 3;//正常应该是2.7System.out.println(num11);System.out.println(num12);//接近2.7的一个小数，而不是2.7，小数进行运算的是近似运算//可以参考IEEE浮点数标准和计算机组成原理教材的除法器设计//得到一个重要的使用点：当我们对运算结果是小鼠的进行相等判断是，要小心//比较两个浮点数是否相等，应该是以两个数的差值的绝对值在某个精度范围内判断if(num11 == num12){System.out.println("相等");//不会输出，不相等}//正确的写法，Math.abs是绝对值函数System.out.println(Math.abs(num11 - num12));//打印相差多少if(Math.abs(num11 - num12)<0.000001)//相差0.000001就算相等{System.out.println("插值非常小，到我的规定精度，认为相等……");//会输出}//细节：如果是直接查询得到的小数或者直接赋值，是可以判断相等}
}

运行结果：

45. Java API文档

1. APl(Application Programming Interface,应用程序编程接口)是 Java 提供的基本编程接口(java提供的类还有相关的方法)。中文在线文档:https://www.matools.com
2. Java语言提供了大量的基础类，因此 Oracle公司也为这些基础类提供了相应的API文档，用于告诉开发者如何使用这些类，以及这些类里包含的方法。
3. Java类的组织形式
   
4. 举例说明如何使用API，查找ArrayList类：
   知道在哪个包里：
   
   
   不知道在哪个包里（比如找Math类）：
   
   
   

46. 字符型使用

字符类型可以表示单个字符,字符类型是char，char是两个字节(可以存放汉字)
多个字符我们用字符串String(我们后面详细讲解String)
演示代码：

//演示char的基本使用
public class Char01
{public static void main(String[] args){char c1 = 'a';char c2 = '\t';char c3 = '韩';char c4 = 97; //说明：字符类型可以直接存放一个数字System.out.println(c1);System.out.println(c2);System.out.println(c3);System.out.println(c4);}
}

运行结果：
输出c4的时候，会输出97这个数字表示的那个字符，这里会涉及到编码的概念，后面详细介绍。

47. 字符型细节

47.1 字符类型使用细节

1. 字符常量是用单引号(‘’)括起来的单个字符。例如:
   char c1 =‘a’;
   char c2 =‘中’;
   char c3 =‘9’;
   【注】用双引号引起来是字符串类型，如果char变量被赋值双引号括起来的字符，编译器会报错。
2. Java中海允许使用转义字符’‘来将其后的字符转变为特殊字符型常量。例如：
   char c3 = ‘\n’; //’\n’表示换行符；
3. 在Java中，char的本质是一个整数，在输出时，是unicode码对应的字符。转换可以用下面的网站：http://tool.chinaz.com/Tools/Unicode.aspx
4. 可以直接给char赋一个整数，然后输出时，会按照对应的unicode字符输出[97]；
5. char类型是可以进行运算的，相当于一个整数，因为它都对应有Unicode码。

测试代码：

public class CharDetail
{public static void main(String[] args){//用unicode码赋值字符char c1 = 97;System.out.println(c1);//输出a对应的数字，将其转换为int类型char c2 = 'a';System.out.println((int)c2);char c3 = '韩';System.out.println((int)c3);//38889char c4 = 38889;System.out.println(c4);//char类型是可以进行运算的，相当于一个整数，因为它都对应有Unicode码。System.out.println('a' + 10); //输出了107，单个字符char，不是刚才的字符串拼接String//课堂小测试char c5 = 'b' + 1;//98 + 1 = 99System.out.println((int)c5); //99System.out.println(c5); // c(编码表ASCII)}
}

运行结果：

48. 字符型本质

48.1 字符类型本质探讨

1. 字符型存储到计算机中，需要将字符对应的码值（整数）找出来，比如’a’
   存储：‘a’==>码值97==>二进制（110 0001）==>存储
   读取：二进制（110 0001）=>97===>‘a’=>显示

2. 字符和码值的对应关系是通过字符编码表决定的（是规定好）
   ASCII (ASCII 编码表 一个字节表示，
   一个128 个 字符,实际上一个字节可以表示256个字符,只用128个)
   Unicode (Unicode 编码表 固定大小的编码 使用两个字节来表示字符，字母和汉字统一都是占用两个字节
   这样浪费空间 )
   utf-8(编码表，大小可变的编码 字母使用1个字节，汉字使用3个字节,
   gbk(可以表示汉字，而且范围广，字母使用1个字节，汉字2个字节)
   gb2312(可以表示汉字，gb2312<gbk)
   big5 码(繁体中文, 台湾，香港)
   了解设计这些编码的思想可以看视频

49. 常用编码

49.1 ASCII 码

1. ASCII 码：上个世纪60年代，美国制定了一套字符编码(使用一个字节),对英语字符与二进制位之间的关系，做了统一规定，这被称为ASCII 码。ASCII码一共规定了128个字符的编码，只占用了一个字节的后面7位，最前面的1位统一规定为0。特别提示：一个字节可以表示256个字符，ASCII码只用了128个字符.

2. 看一个完整的ASCIl码表[资料中]

3. 缺点：不能表示所有字符。

49.2 Unicode 编码

1. Unicode的好处：一种编码，将世界上所有的符号都纳入其中。每一个符号都给予一个独一无二的编码，使用 Unicode 没有乱码的问题。
2. Unicode 的缺点：一个英文字母和一个汉字都占用2个字节，这对于存储空间来说是浪费。
3. 2的16次方是 65536,所以最多编码是65536个字符。
4. 编码0-127的字符是与ASCII的编码一样.比如’a3在ASCII码是 0x61,在 unicode码是ox0061,都对应97.因此 Unicode码兼容 ASCl码.

49.3 UTF-8 编码

1. UTF-8是在互联网上使用最广的一种 Unicode的实现方式(改进)
2. UTF-8是一种变长的编码方式。它可以使用1-6个字节表示一个符号，根据不同的符号而变化字节长度。
3. 使用 大小可变的编码 字母占1个字节，汉字占3个字节。

50. 布尔类型

1. 布尔类型也叫boolean类型，boolean类型数据只允许取值true和false，无null
2. boolean类型占1个字节
3. boolean类型适于逻辑u那算，一般用于程序流程控制：
   if条件控制语句
   while循环抗旨语句
   do-while循环控制语句
   for循环控制语句

演示代码：

public class Boolean01
{public static void main(String[] args){//演示判断成绩是否通过的案例//定义一个布尔变量boolean isPass = true;if(isPass == true){System.out.println("考试通过，恭喜");}else{System.out.println("考试没有通过，下次努力");}}
}

运行结果：

将isPass改成false，就提示考试不通过
【注】boolean类型不可以用0和非0的整数代替false和true，这点和C语言不同。

51. 自动类型转换基础

当Java程序在进行赋值或者运算时，精度小的类型自动转换为精度大得数据类型，这个就是自动类型转换。
数据类型按精度（容量）大小排序为：

测试代码：

public class AutoConvert
{public static void main(String[] args){//演示自动转换int num = 'a';//正确，char->intdouble d1 = 80;//正确，int->doubleSystem.out.println(num);//97System.out.println(d1);//80.0}
}

运行结果：

52. 53. 自动类型转换细节1

1. 有多种类型得数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进行计算。
2. 当我们把精度（容量）大的数据类型赋值给精度（容量）小的数据类型时，就会报错，反之就会进行自动类型转换。
3. (byte, short)和char之间不会相互自动转换。
4. byte, short, char他们三者可以计算，在计算时首先转换为int类型。
5. boolean不参与转换。
6. 自动提升原则：表达式结果的类型自动提升为操作数中最大的类型。

public class AutoConvertDetail
{public static void main(String[] args){//细节1：有多种类型得数据混合运算时，//系统首先自动将所有数据转换成容量最大的那种数据类型，//然后再进行计算。int n1 = 10;//float d1 = n1 + 1.1;//错误，n1 + 1.1的结果类型是double，因为默认转成容量最大的//double d1 = n1 + 1.1;//对float d1 = n1 + 1.1F; //对，让1.1不是double而是float//细节2：当我们把精度（容量）大的数据类型赋值给精度（容量）小的数据类型时，//就会报错，反之就会进行自动类型转换。// int n2 = 1.1;//错误，double->int，精度高的不能转换到精度低的//(byte, short)和char之间不会相互自动转换。//当把数赋值给byte类型的变量时，先判断该数是否在byte范围内，//如果是就可以byte b1 = 10;//byte的范围是-128~127// byte b1 = 1000;//错，超过-128~127的范围//细节3：byte,short 和char之间不会相互自动转换//把int赋值给byte不行// int n2 = 1;//n2是int类型// byte b2 - n2;//错，如果是变量赋值，判断变量的类型，是int高精度转byte低精度，不行// char c1 = b1;//错，byte,short 和char之间不会相互自动转换// short s1 = b1;//错，同上//细节4：byte, short, char他们三者可以计算，在计算时首先转换为int类型byte b2 = 1;byte b3 = 2;short s1 = 1;// short s2 = b2 + s1;//错，b2 + s1运算时先转换为int，结果是int类型，int不能转向更低精度的shortint s2 = b2 + s1;//对，b2+s1运算时先转换为int，结果就是int类型// byte b4 = b2 + b3;//错，只要是byte类型之间作运算，其运算时自动转换为int类型//细节5：boolean不参与转换boolean pass = true;// int num100 = pass;//错，boolean不参与转换//细节6：自动提升原则：表达式结果的类型自动提升为操作数中最大的类型。byte b4 = 1;short s3 = 100;int num200 = 1;double num300 = 1.1;double num500 = b4 + s3 + num200 + num300;//整个运算的结果是操作数最大的类型即double// float num500 = b4 + s3 + num200 + num300;//错，操作数中最大的类型是double，double不能向更低精度float转换//b4 + s3 + num200 + num300的结果因为操作数最大的类型即double，所以只能让它赋值给double类型的变量}
}

54. 强制类型转换基础

强制类型转换是自动类型转换的逆过程，将容量大的数据类型转换为容量小的数据类型。使用时要加上强制转换符()，但可能造成精度降低或溢出，格外要注意。
演示代码：

public class ForceConvert
{public static void main(String[] args){//演示强制类型转换int n1 = (int)1.9;System.out.println("n1=" + n1);//1，精度损失int n2 = 2000;byte b1 = (byte)n2;//byte的范围是-128~127System.out.println("b1=" + b1);//数据溢出}
}

运行结果：

byte范围是-128~127，byte 类型只有 256（$2^8$）个可能的值（从 -128 到 127）。因此，当我们将一个超出这个范围的整数（如 2000）转换为 byte 时，实际存储的是这个整数值对 256 取模的结果。
计算 2000 % 256 的结果：
首先，计算 2000 除以 256，商为 7，余数为 2000 - 256 * 7 = 2000 - 1792 = 208。
结果 208 超过了 127，于是当转换为 byte 时会被看作 208 - 256，即：
208 - 256 = -48
（这么计算的原因详见计算机组成原理）

55. 强制类型转换细节

1. 当进行数据的大小从 大->小，就需要使用到强制类型转换；

2. 强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级；

3. char类型可以保存int的常量值，但不能保存int的变量值，需要强转；

4. byte和short类型在进行运算时，当做int类型处理。

演示代码：

public class ForceConvertDetail
{public static void main(String[] args){//演示强制类型转换//int x = (int)10*3.5+6*1.5;//错，强转符号只对最近的操作数有效，6*1.5是double，整个就是doubleint y = (int)(10*3.5+6*1.5);//用小括号提升优先级System.out.println(y);//char类型可以保存int的常量值，但不能保存int的变量值，需要强转char c1 = 100;//可以，保存的是常量值int m = 100;//char c2 = m;//不可以，保存的是int类型的变量值char c3 = (char)m;//可以，进行了强制类型转换System.out.println(c3);//100 ASCII码对应的字符d}
}

运行结果：

56. 类型转换练习

1. short s =12;//ok
   s = s-9;//short,byte,char计算时首先转为int计算，所以s-9结果的类型是int类型，没法赋值给short类型的变量s

2. byte b = 10;//ok
   b = b + 11;//short,byte,char计算时首先转为int计算，所以b + 11结果的类型是int类型，没法赋值给byte类型的变量b
   b = (byte)(b+11);//可以转换，b+11计算结果类型是int且值为21，通过强制类型转换为byte类型，21在-128~127的范围内，所以可以赋值给byte类型的变量b

3. char c = ‘a’;//ok
   int i = 16;//ok
   float d = .314F;//ok
   double result = c + i + d;//可以转换，最高精度的操作数类型是float，float可以向更高精度double转换

4. byte b = 16;
   short s = 14;
   short t = s + b;//short,byte,char计算时首先转为int计算，所以s + b结果的类型是int类型，没法赋值给short类型的变量t

57. String和基本类型转换

在程序开发中，我们经常需要将基本数据类型转成String类型。或者将String类型转成基本数据类型。
基本类型转String类型：将基本类型的值+""即可
String类型转基本数据类型：通过基本类型的包装类调用parseXX方法即可。

演示代码：

public class StringToBasic
{public static void main(String[] args){//基本数据类型转Stringint n1 = 100;float f1 = 1.1F;double d1 = 4.5;boolean b1 = true;String s1 = n1 + "";String s2 = f1 + "";String s3 = d1 + "";String s4 = b1 + "";System.out.println(s1 + "\t" + s2 + "\t" + s3 + "\t" + s4);//把字符串转基本数据类型String s5 = "123";//会在讲面向对象oop的时候详细讲//使用基本数据类型对应的包装类的相应方法，得到基本数据类型int num1 = Integer.parseInt(s5);double num2 = Double.parseDouble(s5);float num3 = Float.parseFloat(s5);long num4 = Long.parseLong(s5);byte num5 = Byte.parseByte(s5);boolean b = Boolean.parseBoolean("true");short num6 = Short.parseShort(s5);System.out.println("====================");System.out.println(num1);//123System.out.println(num2);//123.0System.out.println(num3);//123.0System.out.println(num4);//123System.out.println(num5);//123System.out.println(b);//trueSystem.out.println(num6);//123//怎么把字符串转成字符，char - >含义是指把字符串的第一个字符取到（类似C语言字符数组首地址）//s5.charAt(0)取得s5下标为0的（第一个）字符System.out.println(s5.charAt(0));}
}

运行结果：

58. String转基本数据类型细节

1. 在将String 类型转成 基本数据类型时，要确保String类型能够转成有效的数据，比如 我们可以把"123",转成一个整数，但是不能把"hello" 转成一个整数。
2. 如果格式不正确，就会抛出异常，程序就会终止，这个问题在异常处理章节中，会处理。

public class StringToBasicDetail
{public static void main(String[] args){String str = "123";//String str = "hello";//字符串改成hello会抛出异常//转成intint n1 = Integer.parseInt(str);System.out.println(n1);}
}

输出结果：

如果将字符串"hello"转成整型int，就会抛出异常：

59. 60. 本章作业

【答】输出：
30
8

【答】
2)代码如下：

public class Homework02
{public static void main(String[] args){char c1 = '\n';char c2 = '\t';char c3 = '\r';char c4 = '\\';char c5 = '1';char c6 = '2';char c7 = '3';System.out.println(c1);System.out.println(c2);System.out.println(c3);System.out.println(c4);System.out.println(c5);System.out.println(c6);System.out.println(c7);}
}

运行结果：

3)代码：

public class Homework03
{public static void main(String[] args){//保存书名String book1 = "数学分析";String book2 = "高等代数";System.out.println(book1 + book2);//性别用char保存char c1 = '男';char c2 = '女';System.out.println(c1 + c2);//char,short,byte运算按int运算，得到的是男的码值与女的码值相加//保存书的价格double price1 = 123.56;double price2 = 100.11;System.out.println(price1 + price2);//两个数相加}
}

运行结果：

4)
代码：

public class Homework04
{public static void main(String[] args){String name = "xx"; //姓名int age = 27; //年龄double grade = 90.5; //成绩char gender = '男'; //性别String hobby = "打篮球"; //爱好System.out.println("姓名\t年龄\t成绩\t性别\t爱好\n" + name + "\t" + age + "\t" + grade + "\t" + gender + "\t" + hobby);}
}

运行结果：