【JavaSE 基础知识盲点小结】

一、第一天：

1. 在 cmd 命令窗口问题：

①编译是： javac HelloWorld.java
②运行时是： java HelloWorld (类名不加 .class)

2. 编码和解码问题：

字符转换为二进制机器语言是编码反过来是解码；
①编码的过程：字符转换为二进制的数值；
②解码的过程：二进制的数值转换为字符

3. 解决乱码问题：

在 cmd 命令窗口编译时： javac -encoding UTF-8 等类似加入 -encoding UTF-8 的操作
①-d 参数表示指定存放文档的目录（javadoc 命令可以自动创建这个目录）
②-encoding 参数可以指定编码字符集

4. 源文件与类名一致问题：

①如果是 public 类的：源文件名与类名保持一致；
②如果不是 public 类的：源文件可以与类名不一致

5. 源文件可以有多个类问题：

一个源文件可以有多个类编译后生成多个 .class字节码文件；一个源文件只能有一个 public 的类

6. 命名规则问题：

只能使用26个字母 0~9的数字下划线美元符号$；
①类名，接口名：XxxYyyZzz ；
②变量，方法名：xxxYyyZzz ；
③包名：xxx.yyy.zzz （包的命名规则还包括：域名倒序.项目名称.模块名称.当前包自己的具体名称）；
④常量名：XXX_YYY_ZZZ

二、第二天：

1. 类，接口，数组，属于引用数据类型

2. 常量问题：

①自定义常量：通过 final 关键字来定义
②字面值常量：字符串常量（要用""双引号括起来），整数常量（默认是 int 类型 超过int类型范围末尾加入 L 就以长整型范围输出），浮点常量（默认是 double 类型，加上 F 表示以 float 类型输出），字符常量（要用’ '单引号括起来），布尔常量，空常量。

3. 变量问题：

变量使用前必须初始化

4. 进制的表示问题：

①二进制：0b 或 0B 开头
②八进制：0 开头
③十六进制：0x 或 0X 开头

5. 字节问题：

字节有八位，以 byte 字节类型为例，最高位是符号位1是负号 0是正号
①负数的范围：
1000 0001 是 -1
1000 0000 是 -128（特殊规定）
②正数的范围：
0000 0000 是 0
0111 1111 是 127

6. 原码、补码、反码问题：

计算机存储以补码形式，计算机只有加法，以补码的加法算实际的减法，最高位是符号位，1是负数 0是正数，并有如下规定：

正数的补码与反码，原码一样，称为三码合一；
负数的补码与反码，原码不一样；
负数的原码：把十进制转换为二进制，然后把最高位设置为一；
负数的反码：在原码的基础上，最高位不变，其余取反；
负数的补码：反码加一；

7. 转义字符问题：


\r;	回车覆盖最前方
\"	" 双引号
\’	’ 单引号
\b	删除键 Backspace
\u	转为字符的 Unicode 编码值的十六进制型 ‘\u5c1a’

8. 字符问题：

直接给 char 类型变量赋值十进制的 0~65535 之间的 Unicode 编码值就可以出现字符

9. 基本数据类型转换问题：

①隐式类型转换：

类型	占用内存
byte	1字节
short	2字节
char	2字节
int	4字节
long	8字节
float	4字节
double	8字节

当 byte，short，char 数据类型进行算术运算时，按照 int 类型处理

②显式类型转换：转后类型变量名 = (转后类型)要转换的数据
③特殊的数据类型转换：String 类型想转换为基本数据类型不能强制类型转换，需要调用包装类型的方法来转换

三、第三天：

1. 取模问题：

取模也叫取余被取模的数值为负时，取模的结果也为负
取模结果是正数还是负数看被取模的数值是正数还是负数
小数取模结果可能是小数

2. 比较运算符：" instanceof " ：

①运算：检查是否是类的对象
②规范："Hello"instanceof String
③ 结果：true

3. 逻辑运算符：

符号	含义
&	逻辑与（且）
或（竖）	逻辑或
^	逻辑异或（不同返回true）

4. 位运算算符：

运算符	运算	范例	运算结果
<<	左移	3<<2	12
>>	右移	4>>1	2
>>>	无符号右移	3>>>1	1
&	按位与	6&3	2
或	按位或	6 或 3	7
^	按位异或	6^3	5
-	按位取反	-6	-7

“或” 是： “|” 符号

运算符	运算方式
<<	空位补0，被移除的高位丢弃，空缺位补0。
>>	当最高位是0，右移后，空缺位补0，当最高位是1，空缺位补1。
>>>	被移位二进制最高位无论是0或者是1，空缺位都用0补。
&	二进制位进行&运算，只有1&1时结果是1，否则是0;
“或”	二进制位进行"或"运算，只有0"或"0时结果是0，否则是1;
^	二进制位相同是0，二进制位不同是1
~	按补码取反

四、第四天：

1. break 的用法：

当一个 switch 语句中出现在循环中，switch 语句中使用 break 只能能对 switch 语句有效，对循环无效。

2. return 的用法：

操作遇到 return 会结束，值遇到 return 会返回值

五、第五天：

1. 介绍 Utility 工具类：

方法的调用方式	方法的作用
Utility.readMenuSelection()	读取菜单序号：1. 2. 3. 4. …
Utility.readNumber()	读取金额数值（数字）
Utility.readString()	读取文字（字符串）
Utility.readConfirmSelection()	读取确认是否退出时输入的 y 或者 n
Utility.readKeyBoard(int limit)	从键盘读取 limit 个字符（限制个数）

2. IDEA 快捷键：（具体内容参阅【JavaSE 第五天】）

3. 数组的静态创建与动态创建问题：

①动态初始化：数组声明且为数组元素分配空间与赋值的操作分开进行
②静态初始化：在定义数组的同时就为数组元素分配空间并赋值

4. 关于数组问题：

（1）数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型
（2）创建数组对象会内存中开辟一整块连续的空间，而数组名中引用的是这块连续空间的首地址
（3）按照元素的数据类型区分数组：①基本数据类型元素的数组，②引用数据类型的数组（即对象数组）
（4）数组是引用类型，他的元素相当于类的成员变量，因此数组一经分配空间，其中的每一个元素也被按照成员变量同样的方式被隐式初始化

数组元素类型	元素默认初始值
byte	0
short	0
int	0
long	0L
float	0.0F
double	0.0
char	0或写为：‘\u0000’(表现为空)
boolean	false
引用类型	null

六、第六天：

1. 数组中转移变量问题：

仅仅将变量值中的地址值传给了另一个数组所以这时另一个数组也会指向该地址值下的数据（就相当于多了一个访问数据的入口），通过另一个变量访问数组元素仍然可以读取或者是更改数据

2. 数组变量指向新数组对象问题：

就相当与整个变量的地址值更改并抛弃原地址（将来会被垃圾回收，释放掉，数据全部丢失）

3. 多维数组的底层是内存存储结构

4. 多维数组的理解：

在多维数组声明并创建完毕后，需要 new （例如：格式2，格式3… … 另外只有在初始化完成后才能访问具体数据（读，写））低一维度的数组，将他的地址值存入比他高一维度的“堆内存”中，之后就是一级一级的嵌套，直到最后是最终数据在一维数组中（具体内容参阅【JavaSE 第六天】和【JavaSE 第七天】）

5. 二维数组特殊写法情况： x 是一维数组，y 是二维数组：`int[] x,y[];`

七、第七天：

1. Arrays 工具类的使用：

名称	作用
boolean equals(int[] a,int[] b)	判断两个数组是否相等
String toString(int[] a)	输出数组信息
void sort(int[] a)	对数组进行排序
void fill(int[] a,int vall)	将指定值填充到数组之中
int binarySearch(int[] a,int key)	对排序后的数组进行二分法检索指定的值

2. Java 类及类的成员，面向过程、面向对象的不同称谓：

Field = 属性 = 成员变量， Method = (成员)方法 = 函数

英文名	面向过程的角度	面向对象的角度
Filed	成员变量	属性
Method	成员函数	方法

3. 权限修饰符：

修饰符名称	含义	本类	同包其他类	子类	同工程其他类
private	私有	可以使用	不可使用	不可使用	不可使用
default	缺省	可以使用	可以使用	不可使用	不可使用
protected	受保护	可以使用	可以使用	可以使用	不可使用
public	公共	可以使用	可以使用	可以使用	可以使用

对于 class (类) 的权限修饰符只可以用 public 和 default (缺省)

4. 变量的分类：成员变量与局部变量问题：

①在方法体外，类体内声明的变量称为成员变量
②在方法体内部声明的变量称为局部变量
③成员变量包含（①实例变量（不以static修饰）和 ②类变量（以static修饰））
④局部变量包含（①形参（方法、构造器中定义的变量）和 ②方法局部变量（在方法内定义）和 ③代码块局部i变量（在代码块内定义））

成员变量和局部变量的区别：

	成员变量	局部变量
声明的位置	直接声明在类中	方法形参或内部，代码块，构造器等
修饰符	private，public，static，final等	不能用权限修饰符修饰，可以用 final 修饰
初始化值	有默认初始化值	没有默认初始化值，必须显式赋值，方可使用
内存加载位置	堆空间或静态域内	栈空间

5. Math 类的常用方法：

①生成随机数：Math.random()，返回值类型 double；
②四舍五入取整：Math.round(double d)，返回值类型 long。

八、第八天：

1. 方法重载的规则限制：

①参数列表要求不同：参数个数和参数类型（二选一不同或都不同）（参数类型相同，但顺序不同也可以算重载）
② 不能根据返回值类型判断（不看返回值）

2. 方法可变参数的语法规则：

①声明格式：方法名(参数的类型名...参数名)
②可变参数方法的使用与方法参数部分使用数组是一致的
③方法的参数部分有可变参数，需要放在形参声明的最后
④在一个方法的形参位置，最多只能声明一个可变个数形参
⑤可以将数组传递给可变参数列表
⑥数组作为参数时，不能将多个值传递给数组（解释：数组传递是地址值的传递）（可变参数可以兼容数组参数，但数组参数无法兼容可变参数。当试图使用数组作为参数去实现重载时，会报错，说明可变参数与数组冲突）
⑦方法名相同，一个参数是可变参数，一个参数是一维数组，这两个方法不是重载，因为一个可变参数等价于相应类型的一维数组，就可以对可变参数列表，进行相应的数组操作，比如求长度
⑧可变参数列表所在的方法，是最后被执行访问的。举例：Ⅰ、调用方法 add(5, 3) Ⅱ、可变参数方法：add(int ... args) Ⅲ、具体参数方法：add(int i, int j)【系统会调用这个方法】

2. 方法参数的值传递机制问题：

①Java 的实参值传入方法：值传递（Java 里方法的参数传递方式只有一种：值传递。即将实际参数值的副本（复制品）传入方法内，而参数本身不受影响。）
②Java 中形参值传入方法：Ⅰ、形参是基本数据类型：将实参基本数据类型变量的“数据值”传递给形参； Ⅱ、形参是引用数据类型：将实参引用数据类型变量的“地址值”传递给形参

3. 信息的封装和隐藏操作：

Java 中通过将数据声明为私有的（private），再提供公共的（public）方法：getXxx() 和 setXxx() 实现对该属性的操作

4. 构造器的特征：

①它具有与类相同的名称。
②它不声明返回值类型。（与声明 void 不同）
③它不能被 static ，final ，synchronized ，abstract ，native 修饰，不能有 return 语句返回值。
④初始化操作放到构造器里面，由构造器自动完成，程序员就不必在创建对象后还想着对这对象做初始化操作。
⑤一个类可以有多个构造器：根据参数列表的不同，多个构造器之间是重载的关系。
⑥父类的构造器不可被子类继承

5. 类的属性赋值的顺序：

①默认初始化
②显式初始化
③构造器中初始化
④通过 “ 对象.属性 ” 或 “ 对象.方法 ” 的方式赋值

6. JavaBean 是指符合如下标准的 Java 类：

①类是公共的
②有一个无参的公共的构造器
③有私有属性值，针对私有属性设置的公共的 getter()、setter() 方法

7. this 关键字：

①它在方法内部使用，即这个方法所属的对象的引用；它在构造器内部使用，表示该构造器正在初始化的对象
②this 可以调用类的Ⅰ属性、Ⅱ方法和 Ⅲ构造器

8. this 调用构造器的规则：

①可以在类的构造器中使用 this (参数列表) 的方式，调用本类中重载的其他构造器
②在构造器中调用其他构造器，this (无/参数列表) 语句必须在第一行
③明确：构造器中不能通过 this (参数列表) 的方式调用自身构造器
④在类的一个构造器中，最多只能声明一个 this (参数列表) ，且不能构成死循环

9. package 关键字：

①格式为：package 顶层包名.子包名;
②package 声明所在包的语句必须是在类的第一行。若缺省该语句，则指定为无名包

10. import 关键字：

①语法格式：import 包名.类名
②精确导入：Ⅰ、在 import 关键字后面指定全类名： import java.util.Scanner; ；Ⅱ、全部导入：在 import 关键字后面指定包名.* ：import java.util.*;
③语法规则：Ⅰ、如果导入的类或接口时 java.lang 包下的，或者是当前包下的，则可以省略此 import 语句；Ⅱ、如果已经导入 java.a 包下的类，那么如果需要使用 a 包的子包下的类的话，仍需要导入；Ⅲ、import static 组合的使用，调用指定类或接口下的静态的属性或方法（静态导入。让当前类可以直接调用导入的类中的静态属性或方法，不必写类名。）

九、第九天：

1. 继承后成员变量的特点：

子类和父类的成员变量同名的情况：子类自己有，使用自己的，子类没有，使用父类

2. 方法中的局部变量与类中的成员变量同名的情况：

①在方法内部用 this. 区分成员变量和局部变量
②在方法内部用 super. 调用父类的成员变量

3. 重写与重载的区别：重载实现于一个类中、重写实现于子类中

①重写（Override）是父类与子类之间多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Override)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了。
②重载（Overload）是一个类中多态性的一种表现。如果在一个类中定义了多个同名的方法，它们参数列表不同，则称为方法的重载。

4. 方法重写的问题：

①权限问题：保证子类的权限要大于或者等于父类的方法权限（具体内容参阅【JavaSE 第九天】）
②如果父类的方法权限是 private，子类不知道该方法的存在，没有继承的说法。（不存在重写），这时四个写法都会正确，但并不是方法重写。

5. 继承后构造器的特点：

①构造方法特点 : 子类的构造方法（构造器）中，第一行存在隐式代码，代码是 super(); ，作用是调用父类的无参数构造方法（构造器）。（并且 super(); 与后续的代码不能换位置，必须在构造方法（构造器）的第一行。）
②父类中没有无参数构造方法的情况（自己显式定义了新的构造方法，默认的隐式构造方法（无参的构造方法）消失），子类的构造方法中要用 super(传递参数); 因为父类中没有无参构造方法，所以要传递相应的参数
③父类中存在多个构造方法，子类的构造方法只要调用到其中的一个即可（必须调用，至少一个）

十、第十天：

1. 对象多态性前提：

①必须有继承或者是接口实现
②必须有方法的重写

2. 多态的语法规则：

父类或者接口的引用指向自己的子类的对象。写法：父类变量(对象名) = new 子类对象();

3. 多态中成员的特点：

简记：成员方法编译看左边(父类)，运行看右边(子类)。成员变量都是左边(父类)。（Person p = new Student();）
①多态当中成员变量的特点：
Ⅰ、编译：如果父类中没有成员变量，编译失败
Ⅱ、运行：如果父类和子类都有成员变量，运行父类中的成员变量
②多态中成员方法的特点：
Ⅰ、编译：如果父类中没有成员方法，编译失败
Ⅱ、运行：如果父类和子类都有成员方法，运行子类的方法重写

4. 多态的转型问题：

多态的程序中，不能调用子类的特有成员。需要使用子类的特有成员，必须进行强制类型转换：转后类型变量名 = (转后类型)要转换的数据

5. 多态转型下容易出现异常，解决异常的安全写法：

对象名 instanceof 类的名字 ，比较这个对象，是不是由这个类产生的

6. 抽象类的使用时注意：

①创建子类对象（共两类：一种是使用多态性创建对象，一种是只利用子类创建对象）
②（建议）使用多态性创建对象，调用方法执行子类的重写
③抽象类中，可以不定义抽象方法，但是，如果有抽象方法存在，这个类必须是抽象类

7. 接口的相关问题：

①当一个抽象类中的所有方法全部都是抽象方法的时候，这个抽象类就叫做接口，接口是特殊的抽象类。
②接口中成员变量的修饰符是固定的： public static final
③成员方法的修饰符是固定的： public abstract

十一、第十一天：

1. 静态成员内存的特点：

①静态成员跟随自己的类进入元数据区（且是进入其中的静态区）
②静态成员属于自己的类，不属于对象
③静态成员进入内存后赋为默认值
④静态成员变量的初始化实际早于对象

2. 静态成员的调用方式：

①静态成员调用方式只有类名调用（当创建对象后进行对象调用静态成员时，会出现警告，但并不是错误，javac 编译时会自动改为类名的调用（.class 文件的反编译 javap ））
②非静态成员调用只有对象调用

3. 静态方法问题：

①静态方法直接类名调用，静态方法中不能直接使用(调用) 非静态成员（可以间接调用）而非静态可以直接调用静态
②由于静态在内存中优先于对象进入，所以在静态对象方法中不能使用 this(当前对象引用) 和 super(子类对象的空间标识) 来进行调用

4. 详解受保护权限 protected ：

①权限的成员，为子类提供使用
②Object 类是所有类的父类，类中的方法权限有 public 和 protected
③protected 有一个关键的使用方式：受保护权限的方法只能是子类使用 super 调用，子类对象不能调用，不能出子类

5. final 修饰符：

① final 可以修饰：类、方法、成员变量、局部变量，（绝大多数东西都可以修饰）（接口不可以修饰，但是接口里面的东西可以修饰
final 修饰类
②被 final 修饰的类，称为最终类，不能被其他的类继承，无子类。
③被 final 修饰的类有：String、System、Scanner 等
final 修饰局部变量
④ final 修饰的基本数据类型，锁死值
⑤ final 修饰的引用数据类型，锁死内存地址 (引用类型中的成员不受影响)
⑥ final 修饰了方法的参数（参数列表），调用者传递值后，方法的参数值就锁死
final 修饰成员变量
⑦成员变量的定义位置很特别，是在类中，且在方法外面，成员变量在内存中有默认值。final 修饰成员变量的时候，锁住的不是内存默认值，而是程序人员手动的赋值。
⑧ final 修饰的成员变量，Ⅰ、可以直接赋值、Ⅱ、可以构造方法（构造器）赋值，Ⅲ、不能使用 set 方法赋值

6. 静态代码块：

①写在类中，却在方法外面：static {}
②静态代码块的执行时机：只要使用了这个类的成员(①new 对象、②调用静态方法、③调用静态变量等)，静态代码块就会执行，而且就执行一次

7. 构造代码块：

①写在类中，却在方法外面的 “ {} ”，创建对象的时候运行，new 对象一次，运行一次
②构造代码块的运行优先级高于构造器

8. 局部代码块：

① 写在方法内部的 “ {} ” 就是局部代码块，基本极少用到，用处不大。
②可以用来限制变量的生存周期
③其实 if 判断语句和 for 循环语句中的 “ {} ” 就是局部代码块

9. 成员内部类问题：（具体内容参阅【JavaSE 第十一天】）

①成员内部类，是一个类定义在了另一个类的成员位置，这个内部类可以使用成员修饰符，public 、static 、final 、private 。（可以相当于成员变量来写）
②对于内部类：可以直接使用外部类的成员，如果外部类要使用内部类的成员，必须要创建对象。
③主要使用的：非静态调用方式：公式：外部类名.内部类名 = new 外部类对象().new 内部类对象，相关知识：Ⅰ、内部类 Inner ，编译后有 class 文件：名字是：外部类$内部类Ⅱ、内部类也是类，可以继承 Object 类，可以实现接口
④内部类是静态的调用方式 : 外部类名.内部类名变量名 = new 外部类.内部类()

10. 在内部类中的方法调用局部或成员变量打印时：（具体内容参阅【JavaSE 第十一天】）

①直接打印就会打印距离最近的赋值。
②当内部类中的成员变量与局部变量同名时用 this 标识成员变量
③调用外部类的成员变量时：外部类名.this.变量名

11. 局部内部类问题：

①局部内部类：要定义在方法里面。因为方法里面是局部位置，所以不能使用成员修饰符、权限、静态、抽象。书写格式：class A { public void a(){ {class B{} } }
②局部内部类，访问局部变量，变量必须用 final 修饰

12. 匿名内部类（局部内部类的特殊写法）：（具体内容参阅【JavaSE 第十一天】）

①可以简化的部分：实现类、实现接口、重写方法、创建对象，或者是子类继承父类中重写方法、创建对象。
②匿名内部类使用的前提 :Ⅰ、必须有接口实现,或者是类的继承Ⅱ、格式 : new 接口或者父类(){重写抽象方法};（这种格式相当于实现类、实现接口、重写方法、创建对象一系列操作）

13. 非法修饰符组合：主要说的是：abstract（抽象）

① abstract 和 private 是非法组合，抽象方法需要重写，但 private 不能继承，冲突。
② abstract 和 final 是非法组合，抽象方法需要重写，但被 final 修饰不能重写，冲突。
③ abstract 和 static 是非法组合，抽象方法需要重写，但静态方法可以被类名直接调用，冲突（静态方法不能重写）。

十二、第十二天：

1. Object 类问题：

①Object 类定义在了 java.lang 包上， lang 包是核心包，此包中的任何类，在使用的时候不需要 import 导入
②Object 类的构造方法：Object(); 但是第一行中不是 super();
③本地方法：Ⅰ、方法的定义使用关键字，修饰符 native ，这个方法就是本地方法。Ⅱ、方法运行的时候，是一个独立的内存 (本地方法栈)。Ⅲ、作用：凡是遇到本地方法，方法的作用是和本机的操作系统交互

2. Object 类的方法 `toString()` ：

①输出语句中 System.out.println(对象); （默认）调用对象的 toString();方法；
②System.out.println(对象); 就相当于： System.out.println( 对象.toString() );

3. Object 类的方法 `equals()` ：

①作用就是用来比较对象。方法结果是 boolean 值，对象相等就是 true
②源码中：return (this == obj) 就是比较对象的地址(引用数据类型)是不是相同，所以 Object 类的方法 equals() 默认比较对象的内存地址
③可以重写 equals() 方法，建立我们创建的对象的自己的比较方式

4. String 字符串类：

①字符串对象是常量，一旦创建不能修改
②字符串这个数据类型，在 Java 中是不存在的，字符串的实现原理是用 char[] 数组表示。例如：“abc”，这个字符串是使用数组 char[] ch = {'a','b','c'} ; 以这种形式来表示

5. 字节编码：

①字符编码：ASCII，小写字母 a 的值97，大写字母 A 的值是65，数字是48到57；ASCII 是美国标准信息交换代码，一个字节编码代表一个字符
②中国（GB2312（大约4000个汉字）、GBK（大约20000个汉字，还有少数民族语言）、GB18030（尚未启用）），简体中文的编码表，汉字是用两个字节编码代表，并且两个字节编码都是负数的形式，防止与 ASCII 冲突
③ISO 国际标准化组织：全球的语言放在一个编码表中，万国语言标准：Unicode
④ UTF-8 ：存储全球的文字（字节表示变长，但是能用一个字节表示的，绝不用两个字节表示，为了节省资源），在其中汉字用三个字节表示且都是负值
⑤ UTF-16 ：定长表示，无论什么字符全部都是两个字节存储

6. 常用的 String 类的构造方法：

①字节数组转成字符串：

String(byte[] b) 字节数组转成字符串，使用平台的默认字符集
String(byte[] b,int off,int len) 字节数组转成字符串，使用平台的默认字符集，参数 off 指的是：数组的开始索引，len 指的是：要转的个数
String(byte[] b,int off,int,len,String,charsetName) 字节数组转成字符串，使用平台的默认字符集，参数 off 指的是：数组的开始索引，len 指的是：要转的个数，charsetName 参数是自己可以指定编码表

②字符数组转成字符串：

String(char[] b) 字符数组转成字符串
String(char[] b,int off,int,len) 字符数组转成字符串，参数 off 数组的开始索引，len 要转的个数

7. String 类的常用方法：

① String 类的判断类型的方法，返回的都是布尔类型

boolean equals(Object obj) 字符串之间的比较，两个字符串相同，返回 true，严格区分大小写
boolean equalsIgnoreCase(String str ) 字符串之间的比较，两个字符串相同，返回 true，忽略大小写
boolean startWith(String str) 判断字符串是否以另一个字符串开头，是开头就返回 true，严格区分大小写
boolean endsWith(String str) 判断字符串是否以另一个字符串结尾，是结尾就返回 true，严格区分大小写
boolean contains(String str) 判断字符串中是否包含另一个字符串，完全包含返回 true，严格区分大小写
boolean isEmpty() 判断字符串的长度是不是0，如果是0返回 true

② String 类的获取方法，返回值不一定（有可能找得到，有可能找不到，有可能有多个，有可能没有）

int length() 返回字符串长度，字符串中字符的个数
char charAt(int index) 返回指定索引上的单个字符
int indexOf(String str) 返回指定的字符串，在当前字符串中第一次出现的索引
int lastIndexOf(String str) 返回指定的字符串，在当前字符串中最后一次出现的索引
String substring(int start,int end) 截取字符串，参数表示开始索引和结束索引，包含开头索引，不包含结束索引

③ String 类的转换方法

String toLowerCase() 字符串中的所有内容转成小写
String toUpperCase() 字符串中的所有内容转成大写
char[] toCharArray() 字符串转成字符数组
byte[] getBytes() 字符串转成字节数组 (查询编码表)，平台默认字符集
byte[] getBytes(String charsetName) 字符串转成字节数组 (查询编码表)，指定编码表
static String valueOf(任意类型参数) 参数转成字符串对象

④ String 类的比较方法

int compareTo(String str) 字符串之间的比较，谁大谁小，按照字典顺序(自然顺序)（也就是 abcde… 的顺序）

⑤ String 类的方法：去空格、替换、切割

String trim() 去掉字符串两边空格，中间空格不去掉
String replace(String oldString,String newString) 替换字符串
String[] split("规则字符串") 对字符串进行切割

8. String 类正则表达式相关的功能：（具体内容参阅【JavaSE 第十二天】）

9. StringBuilder 字符串构建器：

①StringBuilder 是字符串对象的缓冲区对象，缓冲区（出现的目的，为了高效）提高 String 类的效率。
②实现原理：一个可变的字符序列，字符序列就是字符数组。char[] value;
③字符序列是数组，Java 数组是定长的，一旦创建，长度固定。
④创建对象的时候，StringBuilder 中的数组的初始化长度为16个字符
⑤出现无法容纳问题的时候， StringBuilder 自动的进行数组的扩容，新创建一个数组，并且是开始数组的两倍，新数组实现，原来数组的中元素复制到新的数组，并且原数组被内存废弃销毁。StringBuilder 内部永远只有一个数组
⑥StringBuilder 类是线程不安全的类，运行速度快，推荐使用StringBuilder 。
⑦StringBuffer 是线程安全的类，运行速度慢，多线程的程序中使用。这两个类的构造方法，和其他的方法都一模一样。

十三、第十三天

1. StringBuilder 类的常用方法：

StringBuilder append(任意类型) 参数追加形成字符串，无论参数写的是什么，变成字符串。相当于是字符串里面的“+” 运算
StringBuilder append(任意类型) 可以使用链式编程：保证一个方法的返回值是一个对象，再使用这个对象调用的调用方法：对象.方法().方法().方法()......
StringBuilder insert(int 索引, 任意类型) 可以将任意类型的参数，插入到字符串缓冲区，需要指定索引。
int length() 返回字符串缓冲区的长度
StringBuilder delete(int start,int end) 删除缓冲区中的字符，包含开头索引，不包含结束索引（在 Java 中一般都是包含开头索引，不包含结束索引）
void setCharAt(int 索引,char ch) 修改指定元素上的字符，没有返回值
StringBuilder reverse() 翻转字符串

2. StringBuilder 对象和 String 对象的互转：（具体内容参阅【JavaSE 第十三天】）

①String 对象转成 StringBuilder 对象：

StringBuilder 类的构造方法 StringBuilder(String str)
append 方法 append(String str)

②StringBuilder 对象转成 String 对象：

StringBuilder 的方法 toString()
String 类的构造方法

3. System 类：

System 是系统类：定义在 java.lang 包中，这个类定义了大量常用的字段(成员变量)和方法，该类不能实例化对象，不能使用 new 创建对象，因为类中的成员全部都是静态修饰，使用类名直接调用。该类的构造方法（构造器）被 private 修饰，第一行 super 操作继承 Object 类

4. System 类的方法：

①static long currentTimeMillis() 返回自1970年1月1日，午夜零时，到你程序运行的这个时刻，所经过的毫秒值，1000毫秒=1秒
②static void arrayCopy( Object src,int srcPos,Object dest, int destPos,int length) 复制数组的元素

src：要赋值的数据源,源数组
srcPos：源数组的开始索引
dest：要复制的目标数组
destPos：目标数组的开始索引
length：要复制的元素个数

③static Properties getProperties() 返回当前的操作系统属性

5. Math 类的方法：

static double PI 圆周率
static double E 自然数的底数
static int abs(int a) 返回参数的绝对值
static double ceil(double d) 返回大于或者等于参数的最小整数
static double floor(double d) 返回小于或者等于参数的最大整数
static long round(double d) 对参数四舍五入
static double pow(double a,double b ) a的b次幂
static double random() 返回随机数 0.0-1.0之间
static double sqrt(double d) 参数的平方根

6. Arrays 工具类：

static void sort(数组) 对数组进行升序排列 (目前为止效率最快)
static int binarySearch(数组,查找的关键字) 对数组进行二分搜索法
static void fill(数组,填充的元素) 填充覆盖原元素，拥有全新的数组元素
static String toString(数组) 返回数组的字符串表现形式
static List asList(T...t) 多个元素转成 List 集合

7. 数组的相关操作：（具体内容参阅【JavaSE 第十三天】）

①数组的翻转
②数组的二分(折半)搜索法
③数组的排序

8. 字符串的相关操作：（具体内容参阅【JavaSE 第十三天】具体内容参阅【JavaSE 第十四天】）

①字符串翻转
②自定义（模仿）方法 trim()
③字符出现的次数
④字符串出现的次数
⑤哪个字符出现的最多

十四、第十四天：

1. 大数运算：

java.math 包中具有：BigInteger 大整数、BigDecimal 大浮点数(高精度，不损失精度)

BigInteger 类使用，计算超大整数：
- 创建大数据运算对象直接 new BigInteger(String str) 数字格式的字符串，长度任意，支持正负数
- BigInteger add(BigInteger b) 计算两个 BigInteger 的数据求和
- BigInteger subtract(BigInteger b) 计算两个 BigInteger 的数据求差
- BigInteger multiply(BigInteger b) 计算两个 BigInteger 的数据求乘积
- BigInteger divide(BigInteger b) 计算两个 BigInteger 的数据求商，结果会截掉小数
BigDecimal 类使用，计算超大浮点数
- 构造方法，和 BigInteger 一样
- 方法 + (加法) - (加法) * (乘法) 和 BigInteger 一样
- BigDecimal divide 除法运算
- divide(BigDecimal big,int scalar,int round) 方法有三个参数：
  - big 是被除数
  - scalar 是保留几位
  - round 是保留方式
- 保留方式：参看该类的静态成员变量（字段摘要）：（静态类名成员，类名直接调用）
  - BigDecimal.ROUND_UP 不管四舍五入，直接向上进一位
  - BigDecimal.ROUND_DOWN 直接舍去
  - BigDecimal.ROUND_HALF_UP 四舍五入

2. Date 类：

表示当前的日期对象，精确到毫秒值，java.util.Date 类
①构造方法：

无参数构造方法： new Date()
有 long 型参数的构造方法： new Date(long 毫秒值)

②Date 类没有过时的方法：

long getTime() 返回当前日期对应的毫秒值
void setTime(long 毫秒值) 日期设定到毫秒值上

3. 日期对象和毫秒值之间的相互转换：

①日期对象，转成毫秒值：

new Date().getTime()
System.currentTimeMillis()

②毫秒值转成日期对象：

new Date(毫秒值)
new Date().setTime(毫秒值)

4. 日历类 Calendar：

①Calendar 是抽象类，不能建立对象，所以需要子类继承：GregorianCalendar (格林威治日历)
②Calendar 类定义了静态方法：static Calendar getInstance() 返回的是 Calendar 的子类的对象 GregorianCalendar (GregorianCalendar 是方法中自带原有的 new 创建的对象，直接调用即可)

5. 日历类的方法：

①int get(int field) 返回给定日历字段的值

日历中的任何数据，都是 int 类型
参数是具体的日历字段，传递年、月、日
日历字段的写法：参看 Calendar 类的静态成员变量（字段摘要中）

②void set() 修改日历的值

set(int field,int value) field要修改的字段，value 具体的数据
set(int,int,int) 传递年、月、日

③add()设置日历字段的偏移量

add(int field,int value) field 要修改的字段，value 具体的数据

6. DateFormat 日期格式化：

java.text.DateFormat 类：类的作用是格式化日期的，但是抽象类不能建立对象，需要创建子类的对象 SimpleDateFormat

7. SimpleDateFormat 子类使用:

①构造方法：带有 String 参数的构造方法

参数字符串：日期格式化后的样子
调用 SimpleDateFormat 类的父类方法 format
String format(Date date) 传递日期对象，返回字符串

②字符串转成日期对象：

SimpleDateFormat 调用方法 Date parse(String str)

③时区：

TimeZone 静态方法 .getDefault() 默认的时区

8. LocalDate 本地日期：（JDK8）

①获取该类的对象，属于静态方法

static LocalDate now() 获取 LocalDate 的对象，跟随操作系统
static LocalDate of() 获取 LocalDate 的对象，可以自己设置日期
- of 方法中传递年、月、日 of(int year,int month,int day)

②获取日期字段的方法：名字是 get 开头，非静态方法

int getYear() 获取年份
int getDayOfMonth() 返回月中的天数
int getMonthValue() 返回月份

③设置日期字段的方法：名字是 with 开头

LocalDate withYear(int year) 设置年份
LocalDate withMonth(int month) 设置月份
LocalDate withDayOfMonth(int day) 设置月中的天数
LocalDate 对象是不可变对象，设置方法 with 开头，返回新的 LocalDate 对象

④设置日期字段的偏移量：

设置日期字段的偏移量，方法名 plus 开头，向后偏移
设置日期字段的偏移量，方法名 minus 开头，向前偏移

9. Period 和 Duration 类：（JDK8）

①Period 计算日期之间的偏差：

static Period between(LocalDate d1,LocalDate d2) 计算两个日期之间的差值
- 计算出两个日期相差的天数，月数，年数

②Duration 计算时间之间的偏差：

static Period between(Temporal d1,Temporal d2) 计算两个日期之间的差值（Temporal 是一个接口）

10. 时区：（JDK8）

①ZonedDateTime.now() 返回当前时区
②ZonedDateTime.now(ZoneId.of("America/New_York")) 设置时区

11. DateTimeFormatter ：（JDK8）

①static DateTimeFormatter ofPattern(String str) 自定义的格式
②String format(TemporalAccessor t) 日期或者时间的格式化(其中的参数是一个接口)
③TemporalAccessor parse(String s) 字符串解析为日期对象

12. 基本数据类型对象包装类：

基本数据类型的包装类的最重要功能：实现类基本数据类型和 String 的互转

基本数据类型	对应的包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
boolean	Boolean
char	Character

①基本类型 int 变成 Integer 类的对象：

Integer 类的构造方法：
- Integer(int a) int 类型转成 Integer 对象
- Integer(String s) 字符串转成 Integer 对象，前提：字符串必须纯数字格式
- static Integer valueOf(int a) int 类型转成 Integer 对象
- static Integer valueOf(String s) 字符串转成 Integer 对象，前提：字符串必须纯数字格式

②String 对象转成基本数据类型 int ：

static int parseInt(String str) 参数字符串转成基本类型，字符串要求是数字格式（静态方法）
int intValue() 把 Integer 对象构造方法中的字符串，转成基本类型（非静态方法）

③自动装箱和拆箱：

自动装箱 : 基本数据类型 自动转成 引用类型 int → Integer
自动拆箱 : 引用类型 自动转成 基本数据类型 Integer → int

13. 异常的继承体系：

异常中的顶级父类：

java.lang.Throwable ：所有异常和错误的父类
- java.lang.Error ：所有错误的父类（java.lang.Throwable 的子类）
- java.lang.Exception ：所有异常的父类（java.lang.Throwable 的子类）
  - java.lang.RuntimeExeption ：所有的运行异常父类（java.lang.Exception 的子类）

14. Throwable 的方法：

子类继承即可使用

String toString() 返回异常信息的简短描述 (控制台红色部分)
String getMessage() 返回异常信息的详细描述
void printStackTrace() 异常信息追踪到标准的错误流

十五、第十五天：

1. try…catch 异常处理使用：

try{被检测的代码可能发生异常的代码
}catch(异常类的类名  变量名){异常的处理方式：写什么都可以定义变量，创建对象，调用方法，循环，判断...只要写了catch，异常就被处理掉了
}

多 catch 并行处理：异常处理的代码中：try 可以跟随多个 catch，多个catch处理异常的时候，写法特别注意：如果 catch 中的异常类没有继承关系，先写后写没有区别。 catch 中的异常类有继承关系时，父类写在最下面（如果父类写在上面，由于多态性，子类就无法捕获异常，成为多余的代码）

2. throw 和 throws 关键字的使用：

throw 关键字：只能写在方法内部，关键字的后面跟随对象的创建
throws 关键字：只能写在方法的定义上，关键字后面跟随异常类名
（内部有问题就用 throw，但是外界不知道该问题，对外声明暴露问题就需要 throws）

3. finally 代码块的使用：

①finally 代码块跟随 try … catch 使用，也可以跟随 try 使用
②finally 代码块里面的程序，无论是否出现异常，都会执行，必须执行（但是结束 JVM 后，finally 就不会执行）
③finally 代码块后期主要用于释放资源

4. RuntimeException 异常问题：

①异常的父类是 Exception，Exception 类的子类有 RuntimeException，凡是 RuntimeException 和他的所有子类，都称为运行异常，RuntimeException 和的它的子类之外的则都称为编译异常
②编译异常：方法出现编译异常，调用者必须处理，否则编译失败。处理方式可以是 try…catch 或者是 throws
③运行异常：方法出现运行异常，在方法的定义上，不需要 throws 声明，调用者也不需要处理这个异常，建议不要处理运行异常：程序一旦发生运行异常，请程序人员修改源码

5. 自定义异常类：（具体内容参阅【JavaSE 第十五天】）

①自定义异常，需要继承 Exception 或者 RuntimeException（只有 Exception 和他的子类，才具有可抛出性）
②在自定义的类中，构造方法，super 调用父类构造方法，传递异常信息

6. 集合框架的继承体系：（具体内容参阅【JavaSE 集合框架的继承体系】）

①第一个派系：

Collection (集合) 顶级接口单列集合（一次只能存一个对象）
- List (列表) 接口
  - ArrayList (数组列表) 实现类
  - LinkedList (链表) 实现类
  - Vector (数组列表) 实现类，已过时
- Set (集合) 接口
  - HashSet (哈希表) 实现类
    - LinkedHashSet (链表哈希表) 实现类，继承自 HashSet
  - TreeSet (红黑树) 实现类

②第二个派系：

Map (映射键值对) 顶级接口双列集合（一次可以存两个对象）
- HashMap (哈希表) 实现类
  - LinkedHashMap (链表哈希表) 实现类，继承自 HashMap
- TreeMap (红黑树) 实现类
- Hashtable (哈希表) 实现类，已过时
  - Properties (哈希表) 实现类，继承自 Hashtable
- ConCurrentHashMap (哈希表) 线程相关

③存在一个独立的接口：Iterator 迭代器接口（用来做遍历）
④泛型的使用
⑤增强型循环： for(:) 循环

十六、第十六天：

归结于【JavaSE 集合框架的继承体系】

十七、第十七天：

归结于【JavaSE 集合框架的继承体系】

十八、第十八天：

关于线程的知识

十九、第十九天：

关于线程的知识及 File 类的知识

二十、第二十天：

关于 File 类的知识

二十一、第二十一天：

关于枚举、反射、注解的知识

二十二、第二十二天：

关于 Junit(单元测试)、Lambda 表达式、Stream 流、Optional 类的知识

二十三、网络编程：

归结于【JavaSE 网络编程】