目录
一、命名规范
二、数据类型
1.基本数据类型
2.引用数据类型
3.定义变量
4.java支持的变量类型
5.转义序列
6.堆和栈
7.数据类型转换
三、运算符
1.算术运算符
2.比较运算符
3.逻辑运算符
四、三目运算
三目运算与if的区别
五、条件判断
1.if else
2.Switch
3.if（）else if 判断
六、循环
1.for循环
2.while循环
3.do while循环
4.死循环
5.break、continue、return语句
6.for循环与while循环的不同
七、数组
1.概念
2.数组的定义（使用）
3.数组遍历
4.空指针异常
5.索引越界异常
6.冒泡排序
7.打印数组
八、方法
1.定义
2.优点
3.命名规则
4.方法的三种调用格式
5.方法重载
九、面向对象
1.包
2.面向对象和面向过程的区别
3.面向对象和面向过程的特点
4.什么是对象
5.封装
6.访问修饰符
7.常用的非访问修饰符
8.类
9.继承
10.抽象
11.接口
12.多态（父类引用指向子类对象）
13.异常
14.常见的内置异常类
15.抛出异常
十、java高级
1.数组和集合的区别：
2.单列集合（Collection）
3.双列集合（Map）
4.遍历
5.泛型
6.包装类
7.list集合
8.Set集合
9.Map集合
10.ArrayList集合概述
11.Java常用类
12.Date（时间类）
13.CalendarDemo类（日历类）
14.装箱和拆箱
15.随机数
十一、IO流
1.File类
2.IO流
3.字节流
4.字符流
一、命名规范
Java命名规范：
1.只能用英文、下划线、数字、$结尾(硬性要求) 2.只能用英文、_、$开头(硬性要求)_ 3.不能使用关键字命名(硬性要求) 4.不可以用中文及拼音 有意义 首个单词首字母小写其余首字母大写（小驼峰） 虽然可以但一般不使用_$
包名命名规范：
1.全小写 2.com.baidu.login
代码一定规范
单行注释 // 多行注释
如果注释中中文输出错误则用：编码→编码字符集→中文→GB2312
ctrl+shift+f 格式化代码的格式（规范）
Alt+/ 提示补全
try{代码}catch（捕获异常）{} finally（不管有无异常都运行）
JDK工具包→JRE运行环境
二、数据类型
1.基本数据类型
| 数据类型 | 大小 |
|---|---|
| byte（整型） | 1字节8位 |
| short（整型） | 2字节16位 |
| int（整型） | 4字节32位 |
| long（整型） | 8字节64位 |
| float（浮点型） | 4字节32位浮点数 |
| double（浮点型） | 8字节64位浮点数 |
| boolean | 1个字节 |
| char（只能有一个字符，必须用单引号） | 2个字节 |
2.引用数据类型
String
3.定义变量
变量的声明与赋值
(1)先声明后赋值
int(数据类型) = a(变量名); a = 20(变量值);
(2)边声明边赋值
int a = 20;
也可以同时为多个赋值
int a1 = 10，a2 = 20;
B/S 互联网应用
C/S 客户端应用
4.java支持的变量类型
局部变量：类的方法中的变量
全局变量：独立于方法之外的变量，没有static修饰
类变量：独立于方法之外的变量，用static修饰
5.转义序列
| t | 在文中该处插入一个tad键 |
|---|---|
| b | 在文中插入一个后退键 |
| h | 在文中该处换行 |
| r | 在文中插入回车 |
| f | 在文中插入换页符 |
| ' | 单引号 |
| " | 双引号 |
| 反斜杠 |
6.堆和栈
| 名称 | 特征 |
|---|---|
| 堆 | 先进先出 |
| 栈 | 先进后出（栈中储存与堆的标识，通过标识找堆中实际标识） |
7.数据类型转换
自动转型：double num1 = 2;
强制转型：int num2 = (int)3.9;
三、运算符
1.算术运算符
+、-、*、/、%、++、--、+ =、- =、 * =、/ =、% =
注意：+比较特殊，在几个数字的运算中，+扮演了“加”的角色，在字符串中却扮演了“链接”的角色
2.比较运算符
>、<、>=、<=、==、!=、 .equals() （判断字符串是否相等）
注意：单个=是赋值运算符，两个==才是比较
3.逻辑运算符
| 运算符 | 用法 | 作用 |
|---|---|---|
| &&、& | num1 > num2 && num1 < 10 | 与，前后条件同时ture则为turre |
| ||、| | num1 == 5 || num1 < 10 | 或，前后条件同时false则为false |
| ! | !(num1 > 10) | 非，除了表达式的情况之外为ture |
四、三目运算
表达式？结果1：结果2;
?是三目运算符，当表达式结果为true,则执行?后面的代码;当表达式结果为false,则执行:后 面的代码。
三目运算与if的区别
三目运算有返回值，if没有返回值。
五、条件判断
1.if else
if(){
代码块1...
}else{
代码块2...
}
选择结构的第二种写法。增加了一种情况，属于条件分支，类似于Y字路口。功能与三目运算相同。但不能如同三目运算一样直接将结果进行赋值操作，if没有结果反馈，三目运算始终有结果反馈。
2.Switch
switch(表达式){
case 值1：
语句体1;
break;
case 值2：
语句体2;
break;
...
default:
语句体n+1;
break;
}
使用switch的注意事项:
1.case后面只能是常量，不能是变量,而且，多个case后面的值不能相同。
2.default可以省略。但一般不建议，除非结果是可以预计且不会发生变化的。
3.break可以省略，-般不建议，容易导致穿透。
4.default的位置可以出现在switch语句任意位置。
5.switch语句的结束条件必定是遇到break或已经执行到最末尾。
3.if（）else if 判断
if(){
代码块1...
}else if(){
代码块2...
}else{
代码块3...
}
如果满足小括号中内容，就执行代码，如果不满足就用else，执行else中的内容。
也可以if中套if，即要先满足第一个if，也要满足第二个if的内容
六、循环
1.for循环
for(声明循环变量;循环条件;迭代){
被循环的代码块
}
for循环可以在循环条件满足的情况下，反复执行{}大括号内的代码块。
执行顺序:声明循环变量-- > 判断循环条件:执行循环代码一-- >迭代-- > 判断循环条....
特点：结构紧凑、书写规范、内存使用合理、可预知次数的循环
2.while循环
声明循环变量
while(循环判断){
被循环的代码块
迭代
}
特点：语法宽松、适应各类循环、无法预支次数的循环
3.do while循环
do{
被循环的代码块
迭代
}while();
特点：优先先执循环代码
4.死循环
for( ; ; ){
循环体
}
while(ture){
循环体
}
5.break、continue、return语句
if(){
代码块1...
}else{
代码块2...
}
选择结构的第二种写法。增加了一种情况，属于条件分支，类似于Y字路口。功能与三目运算相同。但不能如同三目运算一样直接将结果进行赋值操作，if没有结果反馈，三目运算始终有结果反馈。
2.Switch
switch(表达式){
case 值1：
语句体1;
break;
case 值2：
语句体2;
break;
...
default:
语句体n+1;
break;
}
使用switch的注意事项:
1.case后面只能是常量，不能是变量,而且，多个case后面的值不能相同。
2.default可以省略。但一般不建议，除非结果是可以预计且不会发生变化的。
3.break可以省略，-般不建议，容易导致穿透。
4.default的位置可以出现在switch语句任意位置。
5.switch语句的结束条件必定是遇到break或已经执行到最末尾。
3.if（）else if 判断
if(){
代码块1...
}else if(){
代码块2...
}else{
代码块3...
}
如果满足小括号中内容，就执行代码，如果不满足就用else，执行else中的内容。
也可以if中套if，即要先满足第一个if，也要满足第二个if的内容
六、循环
1.for循环
for(声明循环变量;循环条件;迭代){
被循环的代码块
}
for循环可以在循环条件满足的情况下，反复执行{}大括号内的代码块。
执行顺序:声明循环变量-- > 判断循环条件:执行循环代码一-- >迭代-- > 判断循环条....
特点：结构紧凑、书写规范、内存使用合理、可预知次数的循环
2.while循环
声明循环变量
while(循环判断){
被循环的代码块
迭代
}
特点：语法宽松、适应各类循环、无法预支次数的循环
3.do while循环
do{
被循环的代码块
迭代
}while();
特点：优先先执循环代码
4.死循环
for( ; ; ){
循环体
}
while(ture){
循环体
}
5.break、continue、return语句
if(){
代码块1...
}else if(){
代码块2...
}else{
代码块3...
}
如果满足小括号中内容，就执行代码，如果不满足就用else，执行else中的内容。 也可以if中套if，即要先满足第一个if，也要满足第二个if的内容
六、循环
1.for循环
for(声明循环变量;循环条件;迭代){
被循环的代码块
}
for循环可以在循环条件满足的情况下，反复执行{}大括号内的代码块。
执行顺序:声明循环变量-- > 判断循环条件:执行循环代码一-- >迭代-- > 判断循环条....
特点：结构紧凑、书写规范、内存使用合理、可预知次数的循环
2.while循环
声明循环变量
while(循环判断){
被循环的代码块
迭代
}
特点：语法宽松、适应各类循环、无法预支次数的循环
3.do while循环
do{
被循环的代码块
迭代
}while();
特点：优先先执循环代码
4.死循环
for( ; ; ){
循环体
}
while(ture){
循环体
}
5.break、continue、return语句
for(声明循环变量;循环条件;迭代){
被循环的代码块
}
for循环可以在循环条件满足的情况下，反复执行{}大括号内的代码块。
执行顺序:声明循环变量-- > 判断循环条件:执行循环代码一-- >迭代-- > 判断循环条....
特点：结构紧凑、书写规范、内存使用合理、可预知次数的循环
2.while循环
声明循环变量
while(循环判断){
被循环的代码块
迭代
}
特点：语法宽松、适应各类循环、无法预支次数的循环
3.do while循环
do{
被循环的代码块
迭代
}while();
特点：优先先执循环代码
4.死循环
for( ; ; ){
循环体
}
while(ture){
循环体
}
5.break、continue、return语句
do{
被循环的代码块
迭代
}while();
特点：优先先执循环代码
4.死循环
for( ; ; ){
循环体
}
while(ture){
循环体
}
5.break、continue、return语句
break
作用：跳出所在循环体
位置：必须出现在循环或选择结构内
continue
作用：提前结束本次循环，继续进行下次循环
方式：无法单独使用，必须将continue关键字置于循环语句中
规律：不需要判断任何条件，只要遇到continue便直接跳出本轮循环进行下次循环
return
返回、终止整个结构且不执行结构外的代码
作用：退出当前方法，可用在方法内，return之后不能写代码
6.for循环与while循环的不同
不同点 : 在for循环中声明的循环变量无法在循环外部使用，而while循环却是在循环结构外部声明的循环变量，所以即便循环结束，也可以继续使用。但更推荐使用for循环，for循环的循环变量在循环结束后会直接被销毁，更合理的使用内存空间。
七、数组
1.概念
容器:将多个数据存储到一起，每个数据称为该容器的元素。比如:水杯，大水缸(司马光)、衣柜等。 数组的概念:是一种容器，可以同时存放同一种数据类型的多个数据值; 数组的特点: . 1.数组是-种引用数据类型; 2.数组当中的多个数据，类型必须统- +; 3.数组的长度在程序运行期间不可改变(存储数据长度固定:因为数组占用的内存必须是连续的，这样才能支持下标访问，如果硬要改变长度那就是数组扩容) (数组扩容的实质:在开辟一 块更大的内存空间，将之前的数组数据拷贝到新的内存中)。
2.数组的定义（使用）
动态数组创建(指定长度) :创建数组直接指定数组的长度 格式: 数据类型 [ ] 数组名称 = new数据类型[数组长度];
int[ ] array = new int[5];
注意：[]中5是数组array的长度数组的长度一旦给定就不能修改 1.其中数据类型代表：数组中盛放数据的数据类型 2.数组使用下标（角标）来访问元素（保存元素）下标从0开始
3.数组遍历
在操作数组时，经常需要依次问数组中的每个元素这种操作称作数组的遍历。
获取数组的长度：array.length
System.out.println("数组的长度"+array.length);
数组的遍历输出（数组操作的基础）
for (int i = 0; i < array.length; i++) {
System.out.println("数组的遍历："+array[i]);
}
4.空指针异常
NullPointerException
原因：数组已经不在指向堆内存了。
5.索引越界异常
Array IndexOutOfBoundsException
原因：你访问了不存在的 索引 。
6.冒泡排序
基本原理：对存放原始数据的数组，按从前到后的方向进行多次扫描，每次扫描称为一轮（遍）。当发现相邻的两个数据的次序与排序要求的大小次序不符合时，将这两个数据进行互换。
过程：从小到大
特点：
升序排序中每一轮比较会把最大的数沉到最后面，所以相互比较的次数，每一轮都会比前一轮少一次。
执行过程：
for (int i = 0; i < array.length-1; i++) {//比较的轮数(array.length-1)
for (int j = 0;jarray[j+1]){//相邻两位数比较，前一位比后一位大，位置互换
//位置互换
int a = array[j];
array[j]=array[j+1];
array[j+1]=a;
}
}
}
7.打印数组
System.out.println(Arrays.toString(数组名));
八、方法
1.定义
1.定义
方法是语句的集合，他们在疫情执行一个功能（方法是解决一类问题的步骤的有序组合方法包含于类或对象中方法在程序中被创建，在其他地方被引用）
修饰符 返回值类型 方法名（参数类型 参数名）{
方法体
return返回值；
}
方法包含一个方法头和一个方法体
（1.修饰符：是可选的，告诉编译器如何调用该方法定义了该方法的访问类型（public static...）
2.返回值类型：方法最终产生的数据结果是什么类型。方法可能会有返回值。如没有，则为void
3.方法名：第一个单词首字母小写（小驼峰）
4.参数类型：进入方法的数据是什么类型（有多个，用逗号隔开）
5.方法体：方法体包含若干行代码，该方法要实现的功能
6.返回值：方法执行后最终产生的数据结果）
定义一个方法的三要素： 1.返回值类型； 2.方法名称； 3.参数列表：多个参数； 4.注意：return后面的返回值，必须和方法名前的返回值类型保持对应。
2.优点
1.使程序变得更简短而清晰 2.有利于程序维护 3.可以提高程序开发的效率 4.提高了代码的重要性
3.命名规则
1.方法名字的第一个单词应该以小写字母作为开头，后面的单词用大写字母开头，不使用连接符 2.下划线可能出现在方法名称中用以分隔名称的逻辑组件
4.方法的三种调用格式
单独调用：方法名称（参数）； 打印调用：System.out.println(方法名称(参数)); 赋值调用：数据类型 变量名称=方法名称(参数);
方法使用的注意事项
1.定义在类中，不能互相嵌套 2.方法定义的前后顺序无所谓 3.方法定义之后不会自动执行，若需执行，一定要调用 4.方法如果有返回值，则必须写“return返回值；”不能没有 5.return后面的返回值数据，必须和方法的返回值类型对应 6.没有返回值的方法用void修饰，且不能写return返回值，只能写return; 7.没有返回值的方法最后一行发return可以省略不写 8.一个方法中可以有多个return语句，但必须保证只有一个执行且两个return不能连写
5.方法重载
访问修饰符 方法名 （参数类型 参数数据，...）{
//初始化代码
}
作用：只要记住唯一一个方法名称，就可以实现类似的多个功能
有关因素：参数个数不同参数类型不同参数的类型顺序不同
无关因素：参数名称（参数类型相同的前提下）；方法返回值
九、面向对象
1.包
1.包
包的概念：
为了更好 组织类，java提供了包机制，用于区别类名的命名空间
包的作用：
1.把功能相似或相同的类或接口组织在同一个包中，方便类的查找和使用
2.包采用了树形目录的存储方式。同一个包中的类名字是不同的，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。因此，包可以避免名字冲突。
3.包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。
包的命名规范：
1.包名由小写字母组成，不能以圆点开头或结尾
2.包名之前最好加上唯一的前缀，通常使用组织倒置的网络域名
3.包名后续部分依不同机构内部的规范不同而不同
如何导入包
import关键字：为了能够使用某个包的成员，我们需要在Java程序中明确导入该包。使用“import”语句可完成此功能。
1.语法（import 包名.类名）
2.用import关键字引入，使用通配符“*”
3.使用import关键字引入指定包中的指定类
注意：类文件中可以包含任意数量的import声明。import声明必须在包声明之后，类声明之前。
使用包的注意事项
1.一个类同时引用了两个来自不同包的同名类（必须通过完整类名来区分）
2.为确保规范，包名必须全小写，由域名倒置（com.daidu)
3.package和import的顺序时固定的（package必须位于第一行【忽略注释行】；只允许有一个package语句；其次是import；接着是类的声明）
面向对象思想概述：面向对象思想是一种程序设计思想/区别于面向过程思想，强调的是通过调用对象的行为来实现功能，而不是自己一步一步的去操作实现。
2.面向对象和面向过程的区别
面向过程：强调步骤
面向对象：强调对象
3.面向对象和面向过程的特点
1.面向对象思想是一种更符合我们思考习惯的思想，它可以将复杂的事情简单化，并将我们从执行者转成指挥者。
2.面向对象的三大基本特征（封装、继承、多态）
什么是类（类，是一组相关属性和行为的集合，是一个具有共同特点的集合。可看出一类事物的模板，使用事物属性特征和行为特征来描述该类事物。
属性：该事物的状态信息
行为：该事物能做什么）
4.什么是对象
（对象是一类事物的具体体现，对象是类的实例，必须具备该类事物的属性和行为。）
对象的创建和使用
通常情况下，一个类不能之间使用，需要根据类创建一个对象才能使用{
1.导包：指出需要使用的类在什么位置；关键字：import 包名称.类名称（和当前类属于同一个包的情况下，可以省略导包语句不写）
2.创建：格式：类名称 对象名=new类名称();
3.使用：使用成员变量：对象名.成员变量名
使用成员方法：对象名.成员方法名();
（注意：如果成员变量没有进行赋值，会有一个默认值，默认值和数组一样）}
成员变量和局部变量的区别：
1.定义的位置不一样（局部变量：在方法的内部
成员变量：在方法的外部，之间写在类中）
2.作用范围不一样：（局部变量：只有在方法中可以使用，出了方法就不能再用；
成员变量：只要再类的作用域中，哪里都可以用。）
3.默认值不一样（局部变量：没有默认值，如果要想使用，必须手动赋值
成员变量：有默认值，默认值的值和数组中的规则相同）
4.内存的位置不一样（局部变量：位于栈内存中；
成员变量：位于堆内存中；）
5.生命周期不一样（局部变量：随着方法进栈而生，随着方法出栈消失；
成员变量：随着对象创建而诞生，随着对象被垃圾回收而消失）
5.封装
特点：1.隐藏信息2.安全性3.赋值与取值
封装的概念：封装就是将一些细节信息隐藏起来，对外界不可见，只向外界提供一个简单编程接口
作用：
1.封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。 2.适当的封装可以让程式码更容易理解与维护，也加强了程式码的安全性。
优点：1.减少耦合2.可重用性3.精确控制4.安全性
封装在Java中的体现：1.方法是一种封装；2.关键字private是一种封装
private
1.是一种私有访问修饰符，作用范围只限于本类中
2.被private修饰的成员变量在本类当中可以直接访问，超出本类范围就不能直接访问了
3.想访问，只能间接访问
命名规则
必须叫setXxx或者是getXxx的命名规范
Getter
对于Getter来说，不能有参数，返回值类型和成员变量对应
Setter
对应Setter来说，不能有返回值，参数类型和成员变量对应
6.访问修饰符
访问控制修饰符：可以使用访问控制符来保护对类、变量、方法和构造方法的访问。（默认访问修饰符、私有访问修饰符-private、公有访问修饰符 -public、）
1.default（即缺省，什么也不写）：在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法 2.private：在同一类内可见。使用对象：变量、方法。注意：不能修饰类（外部类） 3.public：对所有类可见。使用对象：类、接口、变量、方法 4.protected：对同一内的类和所有子类可见。使用对象：变量、方法。注意：不能修饰类（外部类）
7.常用的非访问修饰符
1.static修饰符，用来修饰类方法和类变量
2.final修饰符，用来修饰类、方法和变量，final修饰的类不能够被继承，修饰的方法不能被继承重新定义，修饰的变量为常量，是不可修改的
3.abstract修饰符，用来创建抽象类和抽象方法
4.synchronized修饰符，主要用于线程的编程，synchronized关键字声明的方法同一时间只能被一个线程访问。synchronized修饰符可以应用于四个访问修饰符
5.volatile修饰符，volatile修饰的成员变量在每次被线程访问时，都强制从内存中重新读取成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。
8.类
定义一个完整的类
1.要用private修饰成员变量
2.每个成员变量都有一对 儿SetterGetter 方法
3.有构造方法:空参和有参
9.继承
继承的概念
1.继承是Java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。
2.继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。
继承的作用
1.子类拥有父类的属性和方法，减少重复的代码，维护性高
2.代码简洁，提高了代码的复用性
3.继承是多态的前提，没有继承就没有多态
4.继承的主要作用就是：共性抽取
继承关键字
1.class——定义类
2.interface——定义接口
3.extends——继承父类
extends和implements的区别
相同点
1.都属于Java中的继承
2.都发生在多个类中
不同点
1.extends只能单继承，implements可以实现多继承
2.extends继承父类时，父类中可以存在方法的默认实现而implements在实现接口时接口中不能有方法实现
3.extends发生在子类和父类之间，implements发生在实现类和接口之间
继承的特性
1.子类拥有父类非private的属性、方法
2.子类可以拥有自己的属性和方法，即子类可以对父类进行扩展
3.子类可以用自己的方式实现父类的方法（方法重写）
4.提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）
5.Java的继承时单继承，但是可以多代继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如A类继承B类，B类继承C类，所有按照关系就是C类是B类的父类，B类是A类的父类，这是Java继承区别于C++继承的一个特性
Java中最顶级的父类object
方法重写
@override
方法重载：
a.方法名相同
b.参数列表不同（类型不同，个数不同，顺序不同）
c.和返回值无关（方法重写（也叫覆盖））
概念：在继承关系中，方法的名称相同，参数列表也相同父类和子类的方法完全一样
a.方法名相同
b.参数列表相同
c.返回值类型“相同”
子类的返回值类型小于等于父类的返回值类型
d.修饰符“相同”
子类的修饰符大于等于父类的修饰符
public>protected>默认的>private
super和this
super的方法：
1.在子类的构造方法中，super调用父类的构造方法super()
2.在子类的成员方法中，super调用父类的成员变量super.成员变量
3.在子类的成员方法中，super调用父类的成员方法super.成员方法()
this的用法：
1.在子类的构造方法中，this调用子类的其他构造方法this()
2.在子类的成员方法中，this调用本类的成员变量this.成员变量
3.在子类的成员方法中，this调用本类的成员方法this.成员方法() //不这样写
10.抽象
抽象类（关键字abstract）
概念：在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象这样的类就是抽象类
特性
1.抽象类不能被实例化
2.由于抽象类不能实例化对象，所有抽象类必须被继承，才能被使用
3.在Java中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口
抽象方法：就是在修饰符和返回值之间加上abstract关键字，然后去掉大括号，直接分号结尾。
抽象类：抽象方法所在的类，必须在抽象类中，在class前加abstract即可（抽象类中可以有普通方法）
如何使用抽象类和抽象方法：
1.不能直接new抽象类对象
2.必须用一个类来继承抽象父类
3.子类必须覆盖重写父类当中所有的抽象方法： 覆盖重写（实现）：子类去掉抽象方法的abstract关键字，然后补上方法体大括号
4.创建子类对象进行使用
抽象方法必须在抽象类中（抽象类中可以没有抽象方法）抽象类中可以有普通构造方法
11.接口
Java中的接口是一种规范和约束
接口的声明：可见度：访问修饰符 关键字：interface
特性：
1.接口中每一个方法也是隐式抽象的，接口中的方法只会被隐式的指定为public abstract
2.接口中可以含有变量，但是接口中的变量只会被隐式的指定为public static final变量
3.接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法
接口和抽象类的区别
1.抽象类中的方法可以有方法体（能实现方法的具体功能）接口中的方法不行接口没有构造方法
2.抽象类中的成员变量可以是各种类型的，接口中只能是public static final类型的
3.接口中不能含有静态代码块已经静态方法（用static修饰）而抽象类可以有静态代码块和静态方法
4.一个类只能继承一个抽象类，而一个类却可以实现多个接口
接口和类的区别
1.接口不能用于实例化对象
2.接口没有构造方法
3.接口中所有的方法必须是抽象方法
4.接口中的变量全部都是全局静态常量
5.接口不是被类继承了，而是被类实现了
6.接口支持多继承
接口的实现
1.当类实现接口的时候，类要实现接口中所有的方法。否则，类必须声明为抽象的类
2.类使用implements关键字实现接口。在类声明中，Implements关键字放在class声明后面
12.多态（父类引用指向子类对象）
多态的概念
1.多态是同一个行为具有多个不同表现形式或形态的能力
2.多态就是同一个接口，使用不同的实例而执行不同操作
3.多态也就是同一个事件发生在不同的对象上产生不同的结果
多态的优点
1.降低类型之间的耦合关系 2.可替换性 3.可扩充性 4.接口性 5.灵活性 6.简化性
多态存在的必要条件（继承、重写、父类引用指向子类对象）
格式：父类名称 对象名=new 子类名称（）；
访问成久变量的两种方式:
1.直按通过对象名称访问成员变量:对象名。变量本看等号左边是谁， 优先用谁，没有则向上找 2.网校通过成员，方法访问成员变量:对象名。 方法名:看该方法属于谁， 优先用谁， 没有则向上找
多态编译看左执行看右（new的是谁就执行谁）；没有则往上找
13.异常
概念：
1.异常是阻止当前方法或作用域继续执行的问题。
2.从本质上来讲: Java异常是一个Java对象(继承Object)， 和一般的Java对象- -样，封装了一-些成员变量和操作, 我们可以像操作-般Java对象那样去操作Java异常对象
3.从代表的含义上来说: Java异常是一 种错误情况，是程序不希望出现的现象，但是由于程序本身的设计逻辑和运行的环境等因素，出现异常的情况不可避免，Java虚拟机针对不同的异常情况定义了很多异常类，当jvm运行程序发 现对应的异常时，将会向外面抛出异常
Exception类的层次
所有的异常类是从java.lang .Exception类继承的子类。 Exception类是Throwable类的子类。除了Exception类外，Throwable还有一 个子 类Error。
14.常见的内置异常类
| 异常类型 | 说明 |
|---|---|
| Exception | 异常层次结构的父类 |
| ArithmeticException | 算术错误情形，如以零作除数 |
| ArrayIndexOutOfBoundsException | 数组下标越界 |
| NullPointerException | 尝试访问null对象成员 |
| ClassNotFoundException | 不能加载所需的类 |
| llegalArgumentException | 方法接收到非法参数 |
| ClassCastException | 对象强制类型转换出错 |
| NumberFormatExcept | 数字格式转换异常，如把“abc"转 换成数字 |
15.抛出异常
throws/throw关键字
1.除了系统自动抛出异常外，有些问题需要程序员自行抛出异常 2.如果-个方法没有捕获到一个检查性异常，那么该方法必须使用throws关键字来声明。throws 关键字放在方法签名的尾部。 3.也可以使用throw关键字抛出一个异常， 无论它是新实例化的还是刚捕获到的。
十、java高级
概念：是java中提供的一种容器，可以存储多个数据。
集合当中不能放基本数据类型
集合类型主要有3种：set（集）、list（列表）和map（映射）
集合接口分为：Collection和Map、list、set
1.数组和集合的区别：
数组的长度是固定的，集合的长度可变；
数组中的元素的类型必须是同一种，可以是基本数据类型，也可以是引用数据类型： int[],String[],Student[];
集合可以存储任意引用类型对象，只能存储引用类型对象。
集合中存储的都是对象，而且对象的类型可以不一致。
2.单列集合（Collection）
Collection接口定义了单列集合规范 每次存储一个元素单个元素 单身集合 Collection< E>
3.双列集合（Map）
Map接口定义了双列集合的规范，每次存储一对儿元素
K代表键的类型 V代表值的类型
Key键 Value值
通过键可以找对应的值
1:键唯一(值可以重复)
2:键和值一映射一个键对应-个值
3 :靠键维护他们关系
Map的使用：
HashMap
4.遍历
迭代器：iterator
1.直接遍历
Iterator iterator = stu. iterator() ; System . out. printLn(iterator.next()); System. out . printn(iterator .next()); System . out. printLn(iterator.next()); System . out . println(iterator. next()); System . out. printLn(iterator.next());
2.for循环遍历
Iterator iterator = a. iterator(); for(inti=0;i
3.while循环遍历
while(iterator . hasNext()){
Integer s = iterator.next();
System. out. printLn(s);
}
hasNext（）判断下一个元素是否存在
4.增强for循环
for(Object 0 : stu){
System. out. printLn(o);
}
与Arraylist经常在实际开发中使用
5.泛型
概念：可以在类或方法中预支的使用未知的类型（意思就是集合中可放多个对象变成具体的一种对象）
用的最多的是：对象 String
好处：
1.避免了类型强转的麻烦
2.在编译阶段进行了语法检查，将运行期间问题提前到了编译器
注意：
泛型是数据类型的一部分
6.包装类
| 基本数据类型 | 包装类 |
|---|---|
| byte | Byte |
| boolean | Boolean |
| short | Short |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
| char | Characte |
7.list集合
元素有序
每一个元素都存在一个索引
元素可以重复
public void add(int index, E element); 将指定的元素,添加到该集合中的指定位置上。 public E get(int index); 返回集合中指定位置的元素。 public E remove(int index); 移除列表中指定位置的元素,返回的是被移除的元素。 public E set(int index, E element): 用指定元素替换集合中指定位置的元素,返回值的更新前的元素。
8.Set集合
元素无序
元素是通过链表进行储存的
元素不可重复
.add 添加 相同的后面的将前面的覆盖了所以不可重复
.clear 清空集合中所有元素
.addAll
9.Map集合
元素无序
元素通过键值对的方式进行储存
键不可重复，值可以重复
public V put(K key, v value) 把指定的键与指定的值添加到Map集合中。 public V remove(Object key); 把指定的键所对应的键值对元素在Map集合中删除,返回被删除元素的值. public V get(object key); 根据指定的键,在Map集合中获取对应的值。 public Setkeyset(); 获取Map集合中所有的键,存储到Set集合中。 public Set
通过key获取对应的值
获取所有的key
Setstus = stu.keySet()
获取值：
for (String s : stus) {
System. out. printLn(stu. get(s));
}
获取键:
for(String s : stus) {
System.out.println(s);
}
10.ArrayList集合概述
集合只能存储引用数据类型
ArrayList是顺序结构
特点：查询快、增删慢、线程不安全、效率高
（凡是遇到业务流程必有查询）
linkedLitst概述（红黑树）（面试）
linkedList底层数据结构是链表
特点：查询慢（与栈有关）、增删快、线程不安全、效率高
11.Java常用类
API概述（应用程序编程接口)
是一些预先定义的函数，目的是提供应用程序与开发人员基于某软件或硬件得以访问一组例程的能力，而又无需访问源码，或理解内部工作机制的细节。
Objiect
所有类的基类
所有类都直接或间接的继承
构造方法：public Object（）
常用方法：
| 方法名 | 作用 | 返回值 |
|---|---|---|
| hashCode() | 获取对象hash值 | int |
| toString(） | 将对象信息变为字符串返回 | String |
| equals(Object obj) | 判断两个内存地址是否一样 | boolean |
| getClass() | 获取类名 | Object |
（com.xinzhi.day01.Object）全限定类名称
String
有两帮助类StringBuffer、StringBudder
StringBuffer、StringBudder的区别：
StringBuffer是多线程，程线程安全，执行效率低
StringBudder是单线程，线程不安全，执行效率高
String与StringBuffer、StringBudder的区别：
1.String长度不可变StringBuffer、可变
2.String每次进行更改都会产生一个新的对象
StringBuffer不会产生新的对象而是在原有的对象上进行更改
str = "呵呵"+"，"+"哒"中有几个字符串
jdk1.5之前是5个
jdk1.8就是1个
final
1.被final修饰的变量不能修改其中的值所以称为常量
2.被final修饰的方法不能被重写
3.被final修饰的类不能被继承
StringBuffer
StringBuffer是用来解决String更在字符串造成的时间浪费和空间浪费
| 方法名 | 作用 | 返回值 |
|---|---|---|
| append(String str) | 追加字符串 | StringBuffer |
| insert(int offset,String str) | 指定位置追加字符串 | StringBuffer |
| deleteCharAt(int index) | 删除下标处的字符 | StringBuffer |
| delete(int start,int end) | 删除下标区间的字符 | StringBuffer |
| replace(int start,int end,String str) | 替换区间字符 | StringBuffer |
| reverse( ) | 反转字符串 | StringBuffer |
| substring(int start,int end) | 截取区间字符串从start开始到end结束(包头不包尾) | String |
| substring(int start) | 截取字符串 | String |
12.Date（时间类）
date类表示特定的瞬间，精确到毫秒。
public Date()
分配Date对象并初始化此对象，以表示分配它的时间
转化中文时间：
SimpLeDateFormat sdf = new SimpLeDateFornat("yyyy年MM月dd日HH:mm:ss ");
String dates = sdf .format(date);
System. out.printLn(dates) ;
public Date(0l)
分配Date对象并初始化此对象，以表示自从标准基准时间1970年
data.getTime（）
把日期时间转换成对应的时间毫秒值
13.CalendarDemo类（日历类）
Calendar C = Calendar . getInstance() ;
修改
C. set (CaLendar. YEAR , 2022); System . out . printLn(c . get (CaLendar. YEAR)+"年");
偏移量
C.add (CaLendar. YEAR, amount: -100) ; System . out . printLn(c . get (CaLendar. YEAR)+"年");
日历对象转成时期对象
Date time = c.getTime(); System. out . printLn(time) ;
14.装箱和拆箱
装箱：从基本类型转换为对应的包装类对象
拆箱：从包装类对象转换为对应的基本类型
自动装拆箱：
Integer e = 5; int f = e;
15.随机数
Random random = new Random( ) ;
int i = random . nextInt( bound: 3) ;
System. out. printLn(i);
十一、IO流
1.File类
1.File类
是文件和目录路径名的抽象表示形式。就是java中表示文件和目录的类。
写路径的时候反斜杠写两个正斜杠写一个
File类常用方法
| 方法 | 作用 | 返回值 |
|---|---|---|
| createNewFile（） | 创建名称的空文件，不创建文件夹 | boolean |
| isDirectory（） | 判断是否是目录 | boolean |
| isFile() | 判断是否是文件 | boolean |
| exists() | 判断文件或目录是否存在 | boolean |
| getAbsolutePath（） | 返回此对象表示的文件的绝对路径名 | String |
| getPath（） | 返回此对象表示的文件的相对路径名 | String |
| getName() | 返回此对象表示的文件或目录的名称 | String |
| lengthO | 返回文件的长度，单位为字节 | long |
2.IO流
概述
数据的传输，看作是一种数据的流动，叫做流。以内存为基准，分为输入输出流。
I：代表Input，输入
O：代表Out，输出
流的分类
1.以数据流动方向分为：输入流、输出流
2.以操作或者数据类型分：字节流、字符流
作用
即解决设备间数据传输问题
笔记本硬盘的转速：3000~5400
台式电脑硬盘的转速：3000~7200
顶级父类
| 输入流 | 输出流 | |
|---|---|---|
| 字节流 | 字节输入流（InputStream） | 字节输出流(OutputStream) |
| 字符流 | 字符输入流（Reader） | 字符输出流(Writer) |
3.字节流
字节流可以传输任意文件数据，在操作流的时候，我们要时刻明确，无论使用什么样的流对象，底层传输的始终为二进制数据。
字节输出流（OutputStream）
从内存中输出到其他设备
public void close（）在使用过程中一旦使用必须要关闭。
FileOutputStream
//使用File对象创建流对象 File file = new File( pathname: "a . txt"); File0utputstream outputStream = new File0utputStream(file); //使用文件名称直接创建流对象 FiLe0utputstream file0utputStream = new FiLe0utputStream( name: "b. txt");
public void write（int）
File0utputStream fos = new File0utputstream( name: "b. txt"); //每次可以写出一个字节数据 fos . write(97); fos .write(98); fos .write(99) ;
public void write（byte[] b）
//写出字节数组的方法 byte[] bytes = "欣知大数据" . getBytes(); fos . write(bytes);
public void write（byte[] b, int off, int len）
byte[] bytes = "ancdef".getBytes(); fos.Write(bytes,2,2); //写出从指定索引开始第几个字节
public FileOutputStream(File file, boolean append)
byte[] bytes = "白日依山尽“. getBytes();
//数据写出换行
fos . write(bytes);
fos . write("rn" . getBytes());|
fos . write("黄河入海流" . getBytes());
fos . write("rn" .getBytes());
fos . write("欲穷千里目”. getBytes());
fos . write("rn" . getBytes());
fos . write("更上一层楼" . getBytes());
//关闭资源
fos.close() ;
追加
public static void main(String[] args) throws IOException {
F iLe0utputStream fos = new F iLe0utputStream( name: "b. txt", append: true) ;
byte[] bytes = "cd" . getBytes();|
fos . write(bytes);
fos. close();
}
字节输入流（InputStream）
读取字节信息到内存当中
| public void close() | 关闭此输入流并释放与此流相关联的任何系统资源 |
|---|---|
| public abstract int read() | 从输入流读取数据的下- -个字节 |
| public int read(byte[] b) | 从输入流中读取一些字节数 ,并将它们存储到字节数组b中 |
FileInputStream
public static void main(String[] args) {
//使用File对象创建流对象
File file = new File("a.txt");
FileInputStream fos = new FileInputStream(file);
//使用文件名称创建流对象
FileInputStream fos = new FileInputStream("b.txt") ;
}
public void read（）
int b;
while ( (b=fis.read())!=-1){
System. out . printLn((char) b);
}
fis.close();
用数组读取
//定义个临时 数组
byte[] bytes = new byte[2];
int Len;
while ((Len=fil. read(bytes))!=-1){
for(inti=0;i
4.字符流
概念：以字符为单位读写数据。 作用： 专门用来处理文件。解决字节流读取不全的问题。 UTF-8与GBK： UTF-8：一个中文对应三个字节，idea中默认使用的是UTF-8编码； GBK：一个中文占两个字节，在windows中默认使用的是GBK。
字符输入流
代码展示：
//代码展示：
// 使用文件名称创建流对象
FileReader fr = new FileReader("read.txt");
// 定义变量，保存数据
int b ；
// 循环读取
while ((b = fr.read())!=‐1) {
System.out.println((char)b);
}
// 关闭资源 fr.close();
read(char[] cbuf):每次读取数组指定长度个字符到数组中，返回读取到的有效字符个数，读取到末尾时，返回 -1；
代码展示：
// 使用文件名称创建流对象
FileReader fr = new FileReader("read.txt");
// 定义变量，保存有效字符个数
int len ；
// 定义字符数组，作为装字符数据的容器
char[] cbuf = new char[2];
// 循环读取
while ((len = fr.read(cbuf))!=‐1) {
System.out.println(new String(cbuf，0，len));
}
// 关闭资源 fr.close();
字符输出流
字符流输出流.close与FileOutStream不同，如果不关闭，不会写出到指定文件，会保存到缓存区，.flush即可写到文件。
//代码展示：
FileWriter fw = new FileWriter("fw.txt");
// 写出数据
fw.write(97); // 写出第1个字符
fw.write('b'); // 写出第2个字符
注意：字符流输出流.close与FileOutStream不同，如果不关闭，不会写出到指定文件，会保存到缓存区，.flush即可写到文件。
fw.close();
write(char[] cbuf):写出字符数组：
代码展示：
// 使用文件名称创建流对象 FileWriter fw = new FileWriter("fw.txt");
// 字符串转换为字节数组 char[] chars = " 程序员".toCharArray();
// 写出字符数组 fw.write(chars); // 程序员
write(String str):写出字符串：
代码展示：
// 使用文件名称创建流对象 FileWriter fw = new FileWriter("fw.txt");
// 字符串 String msg = " 程序员";
// 写出字符数组 fw.write(msg); // 程序员
// 关闭资源 fos.close();
续写和换行：
代码展示：
// 使用文件名称创建流对象，可以续写数据
FileWriter fw = new FileWriter("fw.txt"，true);
// 写出字符串 fw.write(" ");
// 写出换行 fw.write("rn");
// 写出字符串 fw.write("程序员");
// 关闭资源 fw.close();
.flush和.close的区别：
因为内置缓冲区的原因，如果不关闭输出流，无法写出字符到文件中。但是关闭的流对象，是无法继续写出数据 的。如果我们既想写出数据，又想继续使用流，就需要 flush 方法了。
flush ：刷新缓冲区，流对象可以继续使用。
close ：关闭流，释放系统资源。关闭前会刷新缓冲区。
代码展示：
// 使用文件名称创建流对象
FileWriter fw = new FileWriter("fw.txt");
// 写出数据，通过flush
fw.write('刷');
// 写出第1个字符
fw.flush();
fw.write('新'); // 继续写出第2个字符，写出成功
fw.flush();
// 写出数据，通过close
fw.write('关'); // 写出第1个字符 fw.close();
fw.write('闭'); // 继续写出第2个字符,【报错】java.io.IOException: Stream closed
fw.close();
5.IO异常处理
之前的入门练习，我们一直把异常抛出，而实际开发中并不能这样处理，建议使用
try...catch...finally 代码块，处理异常部分：
//代码展示：
public class HandleException1 {
public static void main(String[] args) {
// 声明变量 FileWriter fw = null;
try {
//创建流对象
fw = new FileWriter("fw.txt");
// 写出数据
fw.write(" 程序员"); // 程序员
}catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (fw != null) {
fw.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
Java基础到这就结束了，看到这里想必各位朋友已经有一定的Java基础了，后续还会发文，请持续关注！
