1. Java 程序的语法

1.1 标识符的命名规范

​ 标识符：给类或者变量类的方法属性命名都是标识符

​ 组成必须是：字母、数组、_、$、#、- 首字母不能是数字

1.2 约定

1. 类：首字母大写
2. 变量、方法名、属性首字母小写
3. 包全部小写（包 Package： 相对于操作系统文件夹）
4. 驼峰式命名
5. 见名知意

2. Java 的输入输出

​ System.in（输入）

​ System.out（输出）

3. 基本类型（8大）

3.1 整数：

3.2 小数：

3.3 字符：

3.4 布尔：

4. 数据类型的转换

4.1 自动类型转换

• 数据类型兼容
• 低的数据类型赋值给高的数据类型

4.2 强制类型转换

高的数据类型赋值低的数据类型

• 溢出
• 精度的丢失

5. 操作符

• 算术运算：+ - * / % ++ --（不建议 byte，short，char 进行操作，如果一定要操作，都默认转换成 int 操作）
• 比较运算符：== != > < >= <=
• 逻辑运算符：&& || ！ & |（返回 Boolean）
• 位运算：& | 《 》
• 三目运算：条件 ？ 值1 : 值2 （条件成立，返回值1，否则返回值2）

6. Java 流程控制语句

6.1 顺序结构

​ forEach：（加强型 for 循环）

​ for(String string : array)：for（数据类型 变量名 : 数组）

6.2 分支结构

/**
if else 主要用在区间段判断
switch 主要用在定值判断，switch 一般是与 break 配合使用
*/

if(条件) {
	条件true要执行的代码
} else if(表达式语句) {
    
} else {
	条件false要执行的代码
}

switch(变量) {
    // 变量的数据类型：只能是byte short int 或者 enum
	case 值1： 操作1;
	......
    // String 只能是仅代表1.7与以后的版本才可以放在switch中
	case 值n:  操作n;
	default:其他情况的操作;
}

6.3 循环结构

/**
while 与 do while 的区别：
一般 while 能做的操作do while 也能够实现
while 可能执行0次或者多次，但是 do while 至少执行一次
*/

while(条件) {
    循环语句
}

do{
}while(条件);

/**
中断循环：
break 中段本层循环，不能中断外一层
continue 中断本次循环
this 代表当前对象
*/

7. Java 面向对象

7.1 计算机语言发展

1. 机器语言：0 1
2. 汇编语言
3. 初级编程语言：passic，vb，vc，dephi，PHP，ASP
4. 高级语言：C#，C++，Java，Object-C

7.2 语言又分为两种

• 面向过程：vc

• 面向对象：Java，C++

面向过程是面向对象的基础，面向对象依赖于面向过程，他们之间不存在冲突

面向对象(OO)，面向对象的编程（OOP），面向对象的分析（OOS），面向对象的设计（OOD）

面向过程 → 侧重于业务流程的实现，算法的本身

面向对象 → 侧重于实现业务的事物，调用着程序的指挥官

面向对象：编程最小单位

8. Java 定义

8.1 Class（类）

​ 把具有相同属性与行为的一系列事物统称为一个类。例如：动物，鱼 <・)))><<

8.1.1 定义类的语法：

class 类名{
​	属性
​	数据类型 属性名;
​	......
​	数据类型 属性名;
    
​	// 行为也叫方法
	返回值类型 方法名（参数列表）{
​		方法体
	}
}

/**
类体：抽象的概念，具体相同属性与行为的一系列事物的总称；
类体 → 属性与行为
*/

8.2 引用类型

​ 类，接口，数组

8.3 属性的定义

​ 类的属性也可以称为类的成员变量，类的成员属性，域；Java 的数据类型 属性名

​ 类的属性如果不赋值，会有默认值，基本类型默认值都与0相关，引用类型默认值都是 null

8.4 方法（函数）

​ 是具有特定功能的封装

8.4.1 方法的定义：

返回值的类型 方法名（参数列表 形式参数）{
	方法体
}

8.5 返回值类型

​ 可以是 Java 的数据类型：基本类型，引用类型，void

8.6 对象

​ 是客观存在的，是类的实例；类是对象的模版（万物皆对象）

​ 创建对象：类名 对象名 = new 类名();

​ 调用对象的属性或者行为： .代表引用

​ 对象名.属性，对象名.行为（参数列表）;

8.7 类的属性

​ 成为类的成员属性，全局变量会有默认值

​ 默认值规则：byte，short，int，long 默认值：0

8.8 package（包）

​ 相当于操作系统里面的文件夹

​ 包主要是为了解决开发过程中类的命名冲突问题

​ 一般把完成特定功能的代码放在同一个包里

​ Java.lang ：Java 核心类包，默认都已经导入，不需要手工导入

​ Java.util：Java 的工具类包

9. Java 面向对象

面向过程：注重程序的流程，数据结构与算法，参与者就是它本身

面向对象：注重的事物的属性与行为，参与者更多是一个指挥者

9.1 extends（继承）

​ 继承是单继承：一个类只能有一个直接父类，但一个父类可以有多个子类

​ Java 中没有多继承，但是有多重继承，所有类的顶级父类是 Object 类

9.2 继承关系中，类的初始化顺序

1. 父类的静态 static
2. 子类的静态
3. 父类的普通（属性与方法） 代码
4. 父类的构造
5. 子类的普通
6. 子类的构造

9.3 overload（方法的重载）

• 发生在同一个类中
• 方法名相同
• 参数列表不同（个数不同，参数数据类型不同，个数与数据类型都不相同）
• 与返回值类型无关，与访问修饰符无关

9.4 override（继承方法的覆盖 / 重写）

​ 在继承关系中，子类对父类的方法的重新实现

• 方法名与父类相同
• 参数列表也相同
• 返回值类型也相同，或者可以隐式转换成父类的返回值类型

9.5 继承转型

• 向上转型：把子类对象转换成父类对象（是安全的，但子类对象的自身属性会被隐藏）
• 向下转型：把父类对象转换成子类对象
  • 不允许直接 new 父类赋值给子类的向下转型
  • 可以向上转型，再向下转型

9.6 混合类型转型

​ 只能骗过编译器，运行会发生转换异常

9.7 访问修饰符

修饰符：控制别的类对本类的属性与方法的访问权限

面向对象的封装，就是通过访问修饰符来控制访问权限

• 修饰符 数据类型 属性名；
• 修饰符 返回值类型 方法名（参数列表）{方法体}
• 修饰符 class 类名｛｝

1. public：公共权限
2. protected：受保护的
3. default / 不写：默认
4. private：私有的

9.8 instanceof（判断对象类型）

对象名 instanceof 类名：用来判断对象是否是类的实例

10. Java 中的常用方法

10.1 构造方法

​ Object() {}

• toString()：返回类的类路径 + @+hascode对应的16进制数
• equals(Object obj)：对象（Object）的比较 equals与==相同
• hascode() ： 返回内存地址的整数

10.2 字符串序列（String）

​ 构造：String() String(String s) String(byte s[]) String(char s[])

10.3 构造字符串对象

​ String s = "hello";

10.4 字面量值赋值

String s = new String("hello");

10.5 常用方法

10.6 Object 类

​ Object 是 Java 的祖先类，基类，金字塔最顶端的类，最小的细胞类

• 如果是基本类型（byte short int long char float double boolean）
  == 比较的内容（值）

• 如果比较是引用类型（类 接口 数组）

  == 比较的是内存地址

• equals 只能用于引用类型的比较

  比较的时候看当前对象的类里面有没有重写 equals 方法，如果没有重写 equals 方法，默认调用 Object 里面的 equal 方法

  如果重写 equals 方法，那么按照当前类中 equals 方法的逻辑进行比较

• 如果两个对象 equals() 返回true，那么 hashCode() 值会相同，但是两个对象 hashCode() 相同，两个对象未必能 equals() 相等

10.7 Java 重写

1. 继承关系中，子类对父类的方法重写实现
2. 方法名相同
3. 参数列表也相同
4. 返回值类型也相同或者可以隐式转换成父类的返回值类型
5. 访问修饰符的权限不能低于父类

10.8 final 关键字

​ final 修饰变量：就变成常量，不可以变

​ final 修饰方法：就变成最终方法，不可以被重写 override

​ final 修饰类：类就不可以被继承 （太监类）

10.9 StringBuffer 可变的字符串序列

​ append() ：往字符串追加内容

​ insert(位置,"内容") ：往字符串指定位置追加内容

​ delete(int start,int end)：删除字符串从 start 开始到 end - 1 位置上的字符串

​ reverse() ：让里面的内容反转

10.10 System

​ System.in：输入流

​ System.out ：输出流

10.11 获取控制台的输入对象

Scanner in = new Scanner(System.in);
// 遇到空格就不往后取内容
in.next(); 
// 遇到换行符才不往后取内容
in.nextLine();

10.12 GC（garbage Collect） 垃圾回收器

​ Java 程序垃圾是不需要程序员去手工回收，系统（JVM）在后台启动一个线程（守护线程） 每隔一定的时间，自动调用System.gc()方法，扫描系统中长时间

​ 未使用对象，或者对象指向null，自动回收这些对象。

​ 调用该对象的finalize()方法来释放占用的内容空间，当然程序员也可以手工调用System.gc()

10.13 java.util.Date 时间类

​ SimpleDateFormat 是一个以与语言环境有关的方式来格式化和解析日期的具体类

10.13.1 Date 时间格式

​ yyyy：四位年

​ MM：月

​ dd：日

​ hh：12进制时

​ HH：24进制时

​ mm：分

​ ss：秒

new SimpleDateFormat("yyyy-MM-dd HH:mm:ss") 
new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss")
new SimpleDateFormat("yy年MM月dd日 HH时:mm分:ss秒 ") 

10.14 Math 数学工具类

10.15 基本类型的包装类

​ 基本类型的包装类里面都提供了操作该基本类型的属性与方法

10.16 数组

​ Java 数组用来存储具有相同数据类型的若干个数据的集合，数组长度不可变

10. 16.1 一维数组的定义

一个一维数组里面每个元素都是一个一维数组 int nums[] = {1,2,3,4,5,6,7,8,9};

• 动态定义

  • 申明： 数据类型[] 变量名（数组名）；

  • 初始化：数组名 = new 数据类型[length];

  • 数据类型[] 变量名（数组名） = new 数据类型[length]；

• 静态定义

  • 数据类型[] 数组名 =｛数据1，......数据n｝

10.16.2 二维数组的定义

int nums = {{1,2,3},{4,5,6},{7,8}};

易出现异常

​ ArrayIndexOutOfBoundsException：数组下标越界异常

11. 排序算法

11.1 冒泡排序

# 排序数字
8,7,6,3,5,2,4,1

# 首轮
7,8,6,3,5,2,4,1
7,6,8,3,5,2,4,1
7,6,3,8,5,2,4,1
7,6,3,5,8,2,4,1
7,6,3,5,2,8,4,1
7,6,3,5,2,4,8,1
7,6,3,5,2,4,1,8

# 第二轮
6,7,3,5,2,4,1,8
6,3,7,5,2,4,1,8
6,3,5,7,2,4,1,8
6,3,5,2,7,4,1,8
6,3,5,2,4,7,1,8
6,3,5,2,4,1,7,8

# 末轮
8,7,6,3,5,2,4,1

11.2 选择排序

'''
首轮
max=8
index=0
'''
8,7,6,3,5,2,4,1

'''
第二轮
max=7
index=1
'''
8,7,6,3,5,2,4,1

'''
第三轮
max=6
index=2
'''
8,7,6,3,5,2,4,1

'''
末轮
max=1
index=7
'''
8,7,6,5,4,3,2,1   

11.3 查找算法

• 全部遍历
• 二分查找（折半查找）：适合已经排好序的数组

12. abstract 抽象

12.1 抽象方法

一个方法没有方法体｛｝

访问修饰符 abstract

返回值类型 方法名（参数列表）；

这个时候方法就必须申明为抽象方法（用关键字 abstract 修饰）

12.2 abstract 抽象类

访问修饰符（default protected public） abstract class 类名｛｝

12.3 抽象类

1. 可以有抽象方法，也可以没有抽象方法
2. 抽象类可以有构造方法，但是不能 new 操作
3. 抽象类中可以有成员变量（属性）成员方法
4. 抽象类中可以有常量
5. 抽象类可以继承其他的类
6. 如果一个类继承一个抽象的类，要不继续声明为抽象类，要么重写抽象类中的所有抽象方法
7. 抽象类用来被继承的，只能单继承，抽象类与子类存在 instanceof 关系

12.4 接口（interface）

1. 接口是一种特殊的抽象，接口中的方法全部都是抽象的
2. 接口中方法默认都是 public abstract 都是抽象的
3. 接口中不能有成员变量方法
4. 接口中可以有常量，默认都是public final
5. 接口没有构造，不能实例化
6. 接口不能继承类
7. 接口可以继承接口，接口与接口的继承多继承
8. 接口是用来被实现的，一个类可以实现多个接口，一个类可以实现多个接口主要是为了弥补 Java 单继承缺陷

12.5 抽象类与接口对比

13. Java 的集合类框架

13.1 数组

​ 数组定长的定义后大小不可以变化的

13.2 Collection：集合类框架的顶端接口

13.2.1 常用方法

13.2.2 Collection 子接口

​ List 接口：有序的，可以重复的集合接口

13.2.3 常用实现类

• ArrayList，LinkedList，Stack，Vector

  • ArrayList 取数据块，插入慢
  • LinkedList 取数据慢，插入快
  • ArrayList 与 Vector：Vector多线程安全的

• Set：无序的，不可以重复的集合

  • 常用实现类 HashSet，TreeSet，HashSet

  • 去重：先调用当前对象的 hashCode 去集合里面找，如果没有相同的就会放入集合，如果有相同的继续调用 equals()，如果有 equals 就不放入，如果没有相同的就放入

• Map 接口： 键值对存储

  • key（键）是一个 Set 集合，不可以重复值；value（值） 是一个可重复的集合
  • 常用实现类：HashMap，HashTable，TreeMap

13.2.4 List 常用的方法

• get(index,Object obj)：在指定位置上添加元素
• toArray()：把集合转换成数组

14. Java 泛型

指定参数或者集合的数据类型

• 用法

  List<数据类型> list = new ArrayList();

• 泛型好处

  • 指定存放的数据类型，提升安全性
  • 指定存放的数据类型，取数据时候减少强制类型的转换，减少出错的概率，同时提升程序的运行效率

15. Java 的异常处理（Exception）

15.1 Throwable 类

​ 子类 Error 是程序错误，不可以运行或者内存溢出，断电，程序是无法捕获的

​ Exception 程序运行过程中输入输出计算结果不当发生

15.2 异常处理五大关键字

15.3 自定义异常处理

1. 声明一个异常类（写一个类 extends Exception{}）
2. 可能发生异常的方法都声明可能抛出自定义类
3. 再调用抛出的异常