2.1 Java 重要特点
2.2 什么是 JDK，JRE
2.2.1 JDK 基本介绍
2.2.2 JRE 基本介绍
2.2.3 JDK、JRE 和 JVM 的包含关系
2.3 Java 开发注意事项和细节说明
一个源文件中最多只能有一个public类。其它类的个数不限，也可以将main方法写在非public类中，然后指定运行非public类，这样入口方法就是非public的main方法
2.4 Java 转义字符
2.4.1 Java 常用的转义字符
2.5 注释(comment)
2.5.1 Java 中的注释类型
2.6 DOS 命令(了解)
2.6.1 相关的知识补充: 相对路径， 绝对路径
2.6.2 常用的 dos 命令
3.5 程序中 +号的使用
3.6 数据类型 每一种数据都定义了明确的数据类型，在内存中分配了不同大小的内存空间(字节)。
3.7 整数类型
3.7.3 整型的类型
3.7.4 整型的使用细节
3.8 浮点类型
3.8.3 浮点型的分类
3.8.4 说明一下
3.8.5 浮点型使用细节
3.9 Java API 文档
3.10 字符类型(char)
3.10.3 字符类型使用细节
3.11 ASCII 码介绍(了解)
3.12 Unicode 编码介绍(了解)
3.13 UTF-8 编码介绍(了解)
3.14 布尔类型：boolean
例如：
3.15 基本数据类型转换
3.15.1 自动类型转换
3.15.2 自动类型转换注意和细节
例如：
3.17 基本数据类型和 String 类型的转换
3.17.1 介绍和使用
4.1 运算符介绍
4.1.1运算符介绍
运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。
4.2 算术运算符
4.2.3案例演示
// % 取模 ,取余
// 在 % 的本质 看一个公式!!!! a % b = a - a / b * b
// -10 % 3 => -10 - (-10) / 3 * 3 = -10 + 9 = -1
// 10 % -3 = 10 - 10 / (-3) * (-3) = 10 - 9 = 1
// -10 % -3 = (-10) - (-10) / (-3) * (-3) = -10 + 9 = -1
System.out.println(10 % 3); //1
System.out.println(-10 % 3); // -1
System.out.println(10 % -3); //1
System.out.println(-10 % -3);//-1
4.2.5面试题
public class ArithmeticOperatorExercise01 {
//编写一个 main 方法
public static void main(String[] args) {
int i = 1;//i->1
i = i++; //规则使用临时变量: (1) temp = i; (2) i = i + 1; (3) i = temp;
System.out.println(i); // 1
int j = 1;
j = ++j; //规则使用临时变量: (1) j = j + 1; (2) temp = j; (3) j = temp;
System.out.println(j); //2
解析：
4.3 关系运算符(比较运算符)
4.3.2 关系运算符一览
4.3.4 细节说明
4.4 逻辑运算符
4.4.2 逻辑运算符一览
分为两组学习
4.4.5 && 和 & 使用区别
4.4.8 || 和 | 使用区别
4.4.12 练习题 1 请写出每题的输出结果
4.4.13 练习题 2 请写输出结果
4.5 赋值运算符
4.5.2 赋值运算符的分类
基本赋值运算符 = ，例如：int a = 10;
复合赋值运算符 += ，-= ，*= ， /= ，%= 等
4.5.4 赋值运算符特点
4.7 运算符优先级
4.8.2 标识符的命名规范 [ 更加专业 ]
4.10 保留字
4.11 键盘输入语句
4.11.1 介绍
在编程中，需要接收用户输入的数据，就可以使用键盘输入语句来获取。Input.java , 需要一个 扫描器(对象), 就是 Scanner
4.11.2 步骤 ：
4.11.3 案例演示：
要求：可以从控制台接收用户信息，【姓名，年龄，薪水】
import java.util.Scanner;//表示把 java.util 下的 Scanner 类导入
public class Input {
//编写一个 main 方法
public static void main(String[] args) {
//演示接受用户的输入
//步骤
//Scanner 类 表示 简单文本扫描器，在 java.util 包
//1. 引入/导入 Scanner 类所在的包
//2. 创建 Scanner 对象 , new 创建一个对象,体会
// myScanner 就是 Scanner 类的对象
Scanner myScanner = new Scanner(System.in);
//3. 接收用户输入了， 使用 相关的方法
System.out.println("请输入名字");
//当程序执行到 next 方法时，会等待用户输入~~~
String name = myScanner.next(); //接收用户输入字符串
System.out.println("请输入年龄");
int age = myScanner.nextInt(); //接收用户输入 int
System.out.println("请输入薪水");
double sal = myScanner.nextDouble(); //接收用户输入 double
System.out.println("人的信息如下:");
System.out.println("名字=" + name + " 年龄=" + age + " 薪水=" + sal);
}
}
4.12 进制
4.12.1 进制介绍
4.15 二进制转换成十进制示例
4.16 八进制转换成十进制示例
4.17 十六进制转换成十进制示例
规则：从最低位(右边)开始，将每个位上的数提取出来，乘以 16 的(位数-1)次方，然后求和。
4.18 十进制转换成二进制
4.19 十进制转换成八进制
规则：将该数不断除以 8，直到商为 0 为止，然后将每步得到的余数倒过来，就是对应的八进制。
4.20 十进制转换成十六进制
规则：将该数不断除以 16，直到商为 0 为止，然后将每步得到的余数倒过来，就是对应的十六进制。
4.21 二进制转换成八进制
规则：从低位开始,将二进制数每三位一组，转成对应的八进制数即可。
案例：请将 ob11010101 转成八进制
ob11(3)010(2)101(5) => 0325
4.22 二进制转换成十六进制
规则：从低位开始，将二进制数每四位一组，转成对应的十六进制数即可。
4.23 八进制转换成二进制
规则：将八进制数每 1 位，转成对应的一个 3 位的二进制数即可。
4.24 十六进制转换成二进制
规则：将十六进制数每 1 位，转成对应的 4 位的一个二进制数即可。
4.27 原码、反码、补码
例子：
4.28 位运算符
4.28.1 java 中有 7 个位运算(&、|、^、~、>>、<<和 >>>)
4.28.2 还有 3 个位运算符 >>、<< 和 >>> , 运算规则:
4.28.3 应用案例
4.29 本章作业
5.1 程序流程控制介绍
5.2 顺序控制
5.3 分支控制 if-else
5.3.1 分支控制 if-else 介绍
5.3.2单分支
5.4.1 双分支
5.4.4 多分支
多分支的流程图
案例演示 2
5.6 switch 分支结构
5.6.1 基本语法
5.6.2 switch 分支结构流程图
5.6.4 switch 注意事项和细节讨论
5.6.5 switch 课堂练习
//思路分析
//1. 这道题，可以使用 分支来完成， 但是要求使用 switch
//2. 这里我们需要进行一个转换, 编程思路 :
// 如果成绩在 [60,100] , (int)(成绩/60) = 1
// 如果成绩在 [0,60) , (int)(成绩/60) = 0
//代码实现
double score = 1.1;
//使用 if-else 保证输入的成绩有有效的 0-100
if( score >= 0 && score <= 100) {
switch ((int)(score / 60)) {
case 0 :
System.out.println("不合格");
break;
case 1 :
System.out.println("合格");
break;
}
} else {
System.out.println("输入的成绩在 0-100");
}
//思路分析
//1. 创建 Scanner 对象， 接收用户输入
//2. 使用 int month 接收
//3. 使用 switch 来匹配 ,使用穿透来完成，比较简洁
Scanner myScanner = new Scanner(System.in);
System.out.println("输入月份");
int month = myScanner.nextInt();
switch(month) {
case 3:
case 4:
case 5:
System.out.println("这是春季");
break;
case 6:
case 7:
case 8:
System.out.println("这是夏季");
break;
case 9:
case 10:
case 11:
System.out.println("这是秋季");
break;
case 1:
case 2:
case 12:
System.out.println("这是冬季");
break;
default :
System.out.println("你输入的月份不对(1-12)");
}
5.6.6 switch 和 if 的比较
5.7 for 循环控制
5.7.3 for 循环流程图
5.7.5 for 循环练习题
public class ForExercise {
//编写一个 main 方法
public static void main(String[] args) {
//打印 1~100 之间所有是 9 的倍数的整数，统计个数 及 总和.[化繁为简,先死后活]
//老韩的两个编程思想(技巧)
//1. 化繁为简 : 即将复杂的需求，拆解成简单的需求，逐步完成 编程 = 思想 --练习-> 代码
//2. 先死后活 : 先考虑固定的值，然后转成可以灵活变化的值
//思路分析
//打印 1~100 之间所有是 9 的倍数的整数，统计个数及总和
//化繁为简
//(1) 完成 输出 1-100 的值
//(2) 在输出的过程中，进行过滤，只输出 9 的倍数 i % 9 ==0
//(3) 统计个数 定义一个变量 int count = 0; 当 条件满足时 count++;
//(4) 总和 , 定义一个变量 int sum = 0; 当条件满足时累积 sum += i;
//先死后活
//(1) 为了适应更好的需求，把范围的开始的值和结束的值，做出变量
//(2) 还可以更进一步 9 倍数也做成变量 int t = 9;
int count = 0; //统计 9 的倍数个数 变量
int sum = 0; //总和
int start = 10;
int end = 200;
int t = 5; //倍数
for(int i = start; i <= end; i++) {
if( i % t == 0) {
System.out.println("i=" + i);
count++;
sum += i;//累积
}
}
System.out.println("count=" + count);
System.out.println("sum=" + sum);
}
}
5.8 while 循环控制
5.8.2 while 循环执行流程分析
5.9.3 do…while 循环执行流程图
5.10.4 经典的打印金字塔
public class Stars {
//编写一个 main 方法
public static void main(String[] args) {
/*
*
* *
* *
********
思路分析
化繁为简
1. 先打印一个矩形
*****
*****
*****
*****
*****
2. 打印半个金字塔
* //第 1 层 有 1 个*
** //第 2 层 有 2 个*
*** //第 3 层 有 3 个*
**** //第 4 层 有 4 个*
***** //第 5 层 有 5 个*
3. 打印整个金字塔
* //第 1 层 有 1 个* 2 * 1 -1 有 4=(总层数-1)个空格
*** //第 2 层 有 3 个* 2 * 2 -1 有 3=(总层数-2)个空格
***** //第 3 层 有 5 个* 2 * 3 -1 有 2=(总层数-3)个空格
******* //第 4 层 有 7 个* 2 * 4 -1 有 1=(总层数-4)个空格
********* //第 5 层 有 9 个* 2 * 5 -1 有 0=(总层数-5)个空格
4. 打印空心的金字塔 [最难的]
* //第 1 层 有 1 个* 当前行的第一个位置是*,最后一个位置也是*
* * //第 2 层 有 2 个* 当前行的第一个位置是*,最后一个位置也是*
* * //第 3 层 有 2 个* 当前行的第一个位置是*,最后一个位置也是*
* * //第 4 层 有 2 个* 当前行的第一个位置是*,最后一个位置也是*
********* //第 5 层 有 9 个* 全部输出*
先死后活
5 层数做成变量 int totalLevel = 5;
*/
int totalLevel = 20; //层数
for(int i = 1; i <= totalLevel; i++) { //i 表示层数
//在输出*之前，还有输出 对应空格 = 总层数-当前层
for(int k = 1; k <= totalLevel - i; k++ ) {
System.out.print(" ");
}
//控制打印每层的*个数
for(int j = 1;j <= 2 * i - 1;j++) {
//当前行的第一个位置是*,最后一个位置也是*, 最后一层全部 *
if(j == 1 || j == 2 * i - 1 || i == totalLevel) {
System.out.print("*");
} else { //其他情况输出空格
System.out.print(" ");
}
}
//每打印完一层的*后，就换行 println 本身会换行
System.out.println("");
}
}
}
5.11 跳转控制语句-break
5.11.1 看下面一个需求
5.11.6 注意事项和细节说明：
5.12 跳转控制语句-continue
5.12.1 基本介绍：
5.13 跳转控制语句-return
return 使用在方法，表示跳出所在的方法，在讲解方法的时候，会详细的介绍，这里我们简单的提一下。注意：如果 return 写在 main 方法，则退出程序。
6.1 为什么需要数组
6.1.1 数组介绍
6.1.2 数组快速入门
可以通过 数组名.length 得到数组的大小/长度
6.2 数组的使用
注意：int a[ ] = new int [5] 和 int[ ] a = new int [5] 是等价的。
6.2.1 使用方式 2-动态初始化
6.2.2 使用方式 3-静态初始化
6.3 数组使用注意事项和细节
6.5 数组赋值机制
6.6 数组拷贝
6.7 数组反转
方式 1：通过找规律反转
public class ArrayReverse {
//编写一个 main 方法
public static void main(String[] args) {
//定义数组
int[] arr = {11, 22, 33, 44, 55, 66};
//规律
//1. 把 arr[0] 和 arr[5] 进行交换 {66,22,33,44,55,11}
//2. 把 arr[1] 和 arr[4] 进行交换 {66,55,33,44,22,11}
//3. 把 arr[2] 和 arr[3] 进行交换 {66,55,44,33,22,11}
//4. 一共要交换 3 次 = arr.length / 2
//5. 每次交换时，对应的下标 是 arr[i] 和 arr[arr.length - 1 -i]
//代码
//优化
int temp = 0;
int len = arr.length; //计算数组的长度
for( int i = 0; i < len / 2; i++) {
temp = arr[len - 1 - i];//保存
arr[len - 1 - i] = arr[i];
arr[i] = temp;
}
System.out.println("===翻转后数组===");
for(int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + "\t");//66,55,44,33,22,11
}
}
}
方式 2：使用逆序赋值方式
public class ArrayReverse02 {
//编写一个 main 方法
public static void main(String[] args) {
//定义数组
int[] arr = {11, 22, 33, 44, 55, 66};
//使用逆序赋值方式
//1. 先创建一个新的数组 arr2 ,大小 arr.length
//2. 逆序遍历 arr ,将 每个元素拷贝到 arr2 的元素中(顺序拷贝)
//3. 建议增加一个循环变量 j -> 0 -> 5
int[] arr2 = new int[arr.length];
//逆序遍历 arr
for(int i = arr.length - 1, j = 0; i >= 0; i--, j++) {
arr2[j] = arr[i];
}
//4. 当 for 循环结束，arr2 就是一个逆序的数组 {66, 55, 44,33, 22, 11}
//5. 让 arr 指向 arr2 数据空间, 此时 arr 原来的数据空间就没有变量引用
// 会被当做垃圾，销毁
arr = arr2;
System.out.println("====arr 的元素情况=====");
//6. 输出 arr 看看
for(int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + "\t");
}
}
}
6.9 排序的介绍
6.10 冒泡排序法
冒泡排序（Bubble Sorting）的基本思想是：通过对待排序序列从后向前（从下标较大的元素开始），依次比较相邻元素 的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就象水底下的气泡一样逐渐向上冒。
public class BubbleSort {
//编写一个 main 方法
public static void main(String[] args) {
int[] arr = {24, 69, 80, 57, 13, -1, 30, 200, -110};
int temp = 0; //用于辅助交换的变量
//将多轮排序使用外层循环包括起来即可
for( int i = 0; i < arr.length - 1; i++) {//外层循环是 4 次
for( int j = 0; j < arr.length - 1 - i; j++) {//4 次比较-3 次-2 次-1 次
//如果前面的数>后面的数，就交换
if(arr[j] > arr[j + 1]) {
temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
System.out.println("\n==第"+(i+1)+"轮==");
for(int j = 0; j < arr.length; j++) {
System.out.print(arr[j] + "\t");
}
}
}
6.12 查找
6.12.1 介绍：
在 java 中，我们常用的查找有两种:
6.12.2 案例演示：
有一个数列：白眉鹰王、金毛狮王、紫衫龙王、青翼蝠王猜数游戏：从键盘中任意输入一个名称，判断数列中是否 包含此名称【顺序查找】 要求: 如果找到了，就提示找到，并给出下标值。
import java.util.Scanner;
public class SeqSearch {
//编写一个 main 方法
public static void main(String[] args) {
/*
思路分析
1. 定义一个字符串数组
2. 接收用户输入, 遍历数组，逐一比较，如果有，则提示信息，并退出
*/
//定义一个字符串数组
String[] names = {"白眉鹰王", "金毛狮王", "紫衫龙王", "青翼蝠王"};
Scanner myScanner = new Scanner(System.in);
System.out.println("请输入名字");
String findName = myScanner.next();
//遍历数组，逐一比较，如果有，则提示信息，并退出
//这里老师给大家一个编程思想/技巧, 一个经典的方法
int index = -1;
for(int i = 0; i < names.length; i++) {
//比较 字符串比较 equals, 如果要找到名字就是当前元素
if(findName.equals(names[i])) {
System.out.println("恭喜你找到 " + findName);
System.out.println("下标为= " + i);
//把 i 保存到 index
index = i;
break;//退出
}
}
if(index == -1) { //没有找到
System.out.println("sorry ,没有找到 " + findName);
}
}
}
6.14 二维数组的使用
6.14.2 使用方式 1: 动态初始化
6.14.3 使用方式 2: 动态初始化
6.14.4 使用方式 3: 动态初始化-列数不确定
public class TwoDimensionalArray03 {
//编写一个 main 方法
public static void main(String[] args) {
//创建 二维数组，一个有 3 个一维数组，但是每个一维数组还没有开数据空间
int[][] arr = new int[3][];
for(int i = 0; i < arr.length; i++) {//遍历 arr 每个一维数组
//给每个一维数组开空间 new
//如果没有给一维数组 new ,那么arr[i]就是 null
arr[i] = new int[i + 1];
//遍历一维数组，并给一维数组的每个元素赋值
for(int j = 0; j < arr[i].length; j++) {
arr[i][j] = i + 1;//赋值
}
}
System.out.println("=====arr 元素=====");
//遍历 arr 输出
for(int i = 0; i < arr.length; i++) {
//输出 arr 的每个一维数组
for(int j = 0; j < arr[i].length; j++) {
System.out.print(arr[i][j] + " ");
}
System.out.println();//换行
}
}
}
6.14.5 使用方式 4: 静态初始化
6.15 二维数组的应用案例
使用二维数组打印一个 10 行杨辉三角
public class YangHui {
//编写一个 main 方法
public static void main(String[] args) {
/*
规律
1.第一行有 1 个元素, 第 n 行有 n 个元素
2. 每一行的第一个元素和最后一个元素都是 1
3. 从第三行开始, 对于非第一个元素和最后一个元素的元素的值. arr[i][j]
arr[i][j] = arr[i-1][j] + arr[i-1][j-1]; //必须找到这个规律
*/
int[][] yangHui = new int[12][];
for(int i = 0; i < yangHui.length; i++) {//遍历 yangHui 的每个元素
//给每个一维数组(行) 开空间
yangHui[i] = new int[i+1];
//给每个一维数组(行) 赋值
for(int j = 0; j < yangHui[i].length; j++){
//每一行的第一个元素和最后一个元素都是 1
if(j == 0 || j == yangHui[i].length - 1) {
yangHui[i][j] = 1;
} else {//中间的元素
yangHui[i][j] = yangHui[i-1][j] + yangHui[i-1][j-1];
}
}
}
//输出杨辉三角
for(int i = 0; i < yangHui.length; i++) {
for(int j = 0; j < yangHui[i].length; j++) {//遍历输出该行
System.out.print(yangHui[i][j] + "\t");
}
System.out.println();//换行.
}
}
}
6.16 二维数组使用细节和注意事项
6.17 二维数组课堂练习
7.1 类与对象
7.1.5 类与对象的关系示意图
7.1.6 类与对象的关系示意图
7.1.8 类和对象的区别和联系
7.1.9 对象在内存中存在形式（重要，必须搞清楚）
7.1.10 属性/成员变量/字段
注意事项和细节说明：
7.1.13 类和对象的内存分配机制
看一个练习题，并分析画出内存布局图，进行分析
最后一句会报 NullPointerException 异常。
7.2 成员方法
7.2.3 方法的调用机制原理：(重要!-示意图!!!)
7.2.5 成员方法的好处
7.2.7 注意事项和使用细节
public class MethodDetail02 {
//编写一个 main 方法
public static void main(String[] args) {
A a = new A();
//a.sayOk();
a.m1();
}
}
class A {
//同一个类中的方法调用：直接调用即可
public void print(int n) {
System.out.println("print()方法被调用 n=" + n);
}
public void sayOk() { //sayOk 调用 print(直接调用即可)
print(10);
System.out.println("继续执行 sayOK()~~~");
}
//跨类中的方法 A 类调用 B 类方法：需要通过对象名调用
public void m1() {
//创建 B 对象, 然后在调用方法即可
System.out.println("m1() 方法被调用");
B b = new B();
b.hi();
System.out.println("m1() 继续执行:)");
}
}
class B {
public void hi() {
System.out.println("B 类中的 hi()被执行");
}
}
7.3 成员方法传参机制(非常非常重要)
public class MethodParameter01 {
//编写一个 main 方法
public static void main(String[] args) {
int a = 10;
int b = 20; //创建 AA 对象 名字 obj
AA obj = new AA();
obj.swap(a, b); //调用 swap
System.out.println("main 方法 a=" + a + " b=" + b);//a=10 b=20
}
}
class AA {
public void swap(int a,int b){
System.out.println("\na 和 b 交换前的值\na=" + a + "\tb=" + b);//a=10 b=20
//完成了 a 和 b 的交换
int tmp = a;
a = b;
b = tmp;
System.out.println("\na 和 b 交换后的值\na=" + a + "\tb=" + b);//a=20 b=10
}
}
7.3.2 引用数据类型的传参机制
在看一个案例，下面的方法会对原来的对象有影响吗？
p=null 和 p = new Person(); 对应示意图
7.4 方法递归调用(非常非常重要，比较难)
7.4.4 递归重要规则
7.4.5 课堂练习
public class RecursionExercise01 {
//编写一个 main 方法
public static void main(String[] args) {
T t1 = new T();
int n = 7;
int res = t1.fibonacci(n);
if(res != -1) {
System.out.println("当 n="+ n +" 对应的斐波那契数=" + res);
}
//桃子问题
int day = 0;
int peachNum = t1.peach(day);
if(peachNum != -1) {
System.out.println("第 " + day + "天有" + peachNum + "个桃子");
}
}
}
class T {
/*
请使用递归的方式求出斐波那契数 1,1,2,3,5,8,13...给你一个整数 n，求出它的值是多
思路分析
1. 当 n = 1 斐波那契数 是 1
2. 当 n = 2 斐波那契数 是 1
3. 当 n >= 3 斐波那契数 是前两个数的和
4. 这里就是一个递归的思路
*/
public int fibonacci(int n) {
if( n >= 1) {
if( n == 1 || n == 2) {
return 1;
} else {
return fibonacci(n-1) + fibonacci(n-2);
}
} else {
System.out.println("要求输入的 n>=1 的整数");
return -1;
}
}
/*
猴子吃桃子问题：有一堆桃子，猴子第一天吃了其中的一半，并再多吃了一个！
以后每天猴子都吃其中的一半，然后再多吃一个。当到第 10 天时，
想再吃时（即还没吃），发现只有 1 个桃子了。问题：最初共多少个桃子？
思路分析 逆推
1. day = 10 时 有 1 个桃子
2. day = 9 时 有 (day10 + 1) * 2 = 4
3. day = 8 时 有 (day9 + 1) * 2 = 10
4. 规律就是 前一天的桃子 = (后一天的桃子 + 1) *2
5. 递归
*/
public int peach(int day) {
if(day == 10) {//第 10 天，只有 1 个桃
return 1;
} else if ( day >= 1 && day <=9 ) {
return (peach(day + 1) + 1) * 2;//规则，自己要想
} else {
System.out.println("day 在 1-10"); return -1;
}
}
}
7.4.6 递归调用应用实例-迷宫问题
public class MiGong {
//编写一个 main 方法
public static void main(String[] args) {
//思路
//1. 先创建迷宫，用二维数组表示 int[][] map = new int[8][7];
//2. 先规定 map 数组的元素值: 0 表示可以走 1 表示障碍物
int[][] map = new int[8][7];
//3. 将最上面的一行和最下面的一行，全部设置为 1
for(int i = 0; i < 7; i++) {
map[0][i] = 1;
map[7][i] = 1;
}
//4.将最右面的一列和最左面的一列，全部设置为 1
for(int i = 0; i < 8; i++) {
map[i][0] = 1;
map[i][6] = 1;
}
map[3][1] = 1;
map[3][2] = 1;
map[2][2] = 1; //测试回溯
//输出当前的地图
System.out.println("=====当前地图情况======");
for(int i = 0; i < map.length; i++) {
for(int j = 0; j < map[i].length; j++) {
System.out.print(map[i][j] + " ");//输出一行
}
System.out.println();
}
//使用 findWay 给老鼠找路
T t1 = new T();
//下右上左
t1.findWay(map, 1, 1);
System.out.println("\n====找路的情况如下=====");
for(int i = 0; i < map.length; i++) {
for(int j = 0; j < map[i].length; j++) {
System.out.print(map[i][j] + " ");//输出一行
}
System.out.println();
}
}
}
class T {
//使用递归回溯的思想来解决老鼠出迷宫
//老韩解读
//1. findWay 方法就是专门来找出迷宫的路径
//2. 如果找到，就返回 true ,否则返回 false
//3. map 就是二维数组，即表示迷宫
//4. i,j 就是老鼠的位置，初始化的位置为(1,1)
//5. 因为我们是递归的找路，所以我先规定 map 数组的各个值的含义
// 0 表示可以走 1 表示障碍物 2 表示可以走 3 表示走过，但是走不通是死路
//6. 当 map[6][5] =2 就说明找到通路,就可以结束，否则就继续找.
//7. 先确定老鼠找路策略 下->右->上->左
public boolean findWay(int[][] map , int i, int j) {
if(map[6][5] == 2) {//说明已经找到
return true;
} else {
if(map[i][j] == 0) {//当前这个位置 0,说明表示可以走
//我们假定可以走通
map[i][j] = 2;
//使用找路策略，来确定该位置是否真的可以走通
//下->右->上->左
if(findWay(map, i + 1, j)) {//先走下
return true;
} else if(findWay(map, i, j + 1)){//右
return true;
} else if(findWay(map, i-1, j)) {//上
return true;
} else if(findWay(map, i, j-1)){//左
return true;
} else {
map[i][j] = 3;
return false;
}
} else { //map[i][j] = 1 , 2, 3
return false;
}
}
}
}
7.4.7 递归调用应用实例-汉诺塔
HanoiTower.java
public class HanoiTower {
//编写一个 main 方法
public static void main(String[] args) {
Tower tower = new Tower();
tower.move(64, 'A', 'B', 'C');
}
}
class Tower {
//方法
//num 表示要移动的个数, a, b, c 分别表示 A 塔，B 塔, C 塔
public void move(int num , char a, char b ,char c) {
//如果只有一个盘 num = 1
if(num == 1) {
System.out.println(a + "->" + c);
} else {
//如果有多个盘，可以看成两个 , 最下面的和上面的所有盘(num-1)
//(1)先移动上面所有的盘到 b, 借助 c
move(num - 1 , a, c, b);
//(2)把最下面的这个盘，移动到 c
System.out.println(a + "->" + c);
//(3)再把 b 塔的所有盘，移动到 c ,借助 a
move(num - 1, b, a, c);
}
}
}
7.4.8 递归调用应用实例-八皇后问题[同学们先尝试做，后面老师评讲.]
7.5 方法重载(OverLoad)
7.5.1 基本介绍
java 中允许同一个类中，多个同名方法的存在，但要求 形参列表不一致！
比如：System.out.println(); 其中 out 是 PrintStream 类型
7.5.2 重载的好处
7.5.4 注意事项和使用细节
7.6 可变参数
7.6.1 基本概念
java 允许将同一个类中多个同名同功能但参数个数不同的方法，封装成一个方法。
就可以通过可变参数实现
7.6.2 基本语法
访问修饰符 返回类型 方法名(数据类型… 形参名) { }
7.6.3 快速入门案例(VarParameter01.java)
看一个案例：类 HspMethod，方法 sum 【可以计算 2 个数的和，3 个数的和 ， 4、5， 。。】
public class VarParameter01 {
//编写一个 main 方法
public static void main(String[] args) {
HspMethod m = new HspMethod();
System.out.println(m.sum(1, 5, 100)); //106
System.out.println(m.sum(1,19)); //20
}
}
class HspMethod {
//可以计算 2 个数的和，3 个数的和 ， 4. 5， 。。
//老韩解读
//1. int... 表示接受的是可变参数，类型是 int ,即可以接收多个 int(0-多)
//2. 使用可变参数时，可以当做数组来使用 即 nums 可以当做数组
//3. 遍历 nums 求和即可
public int sum(int... nums) {
//System.out.println("接收的参数个数=" + nums.length);
int res = 0;
for(int i = 0; i < nums.length; i++) {
res += nums[i];
}
return res;
}
}
7.6.4 注意事项和使用细节
public class VarParameterDetail {
//编写一个 main 方法
public static void main(String[] args) {
//细节: 可变参数的实参可以为数组
int[] arr = {1, 2, 3};
T t1 = new T();
t1.f1(arr);
}
}
class T {
public void f1(int... nums) {
System.out.println("长度=" + nums.length);
}
//细节: 可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后
public void f2(String str, double... nums) {
}
//细节: 一个形参列表中只能出现一个可变参数
//下面的写法是错的.
// public void f3(int... nums1, double... nums2) {
// }
}
7.7 作用域
7.7.1 基本使用
7.7.2 注意事项和细节使用
7.8 构造方法/构造器
7.8.2 基本语法
7.8.3 基本介绍
7.8.5 注意事项和使用细节
7.9 对象创建的流程分析
7.9.1 看一个案例
7.10 this 关键字
7.10.2 深入理解 this
7.10.3 this 的注意事项和使用细节
7.11 本章作业
public class Homework01 {
//编写一个main方法
public static void main(String[] args) {
A01 a01 = new A01();
double[] arr = {1, 1.4, -1.3, 89.8, 123.8 , 66}; //;{};
Double res = a01.max(arr);
if(res != null) {
System.out.println("arr的最大值=" + res);
} else {
System.out.println("arr的输入有误, 数组不能为null, 或者{}");
}
}
}
/*
编写类A01，定义方法max，实现求某个double数组的最大值，并返回
思路分析
1. 类名 A01
2. 方法名 max
3. 形参 (double[])
4. 返回值 double
先完成正常业务，然后再考虑代码健壮性
*/
class A01 {
public Double max(double[] arr) {
//老韩先判断arr是否为null,然后再判断 length 是否>0
if( arr!= null && arr.length > 0 ) {
//保证arr至少有一个元素
double max = arr[0];//假定第一个元素就是最大值
for(int i = 1; i < arr.length; i++) {
if(max < arr[i]) {
max = arr[i];
}
}
return max;//double
} else {
return null;
}
}
}
public class Homework06 {
//编写一个main方法
public static void main(String[] args) {
Cale cale = new Cale(2, 10);
System.out.println("和=" + cale.sum());
System.out.println("差=" + cale.minus());
System.out.println("乘=" + cale.mul());
Double divRes = cale.div();
if(divRes != null) {
System.out.println("除=" + divRes);
}
}
}
/*
编程创建一个Cale计算类，在其中定义2个变量表示两个操作数，
定义四个方法实现求和、差、乘、商(要求除数为0的话，要提示) 并创建两个对象，分别测试
*/
class Cale {
double num1;
double num2;
public Cale(double num1, double num2) {
this.num1 = num1;
this.num2 = num2;
}
//和
public double sum() {
return num1 + num2;
}
//差
public double minus() {
return num1 - num2;
}
//乘积
public double mul() {
return num1 * num2;
}
//除法
public Double div() {
//判断
if(num2 == 0) {
System.out.println("num2 不能为0");
return null;
} else {
return num1 / num2;
}
}
}
8.3.4 课堂练习
8.3.5 IDEA 常用快捷键
第11点也可以用 alt + enter
8.3.6 模板/自定义模板
8.4 包
8.4.2 包的三大作用
8.4.3 包基本语法
8.4.4 包的本质分析(原理)
8.4.5 快速入门
8.4.6 包的命名
8.4.7 常用的包
8.4.8 如何引入包
package com.hspedu.pkg;
import java.util.Arrays;
//注意:
//老韩建议：我们需要使用到哪个类，就导入哪个类即可，不建议使用 *导入
//import java.util.Scanner; //表示只会引入 java.util 包下的 Scanner
//import java.util.*;//表示将 java.util 包下的所有类都引入(导入)
public class Import01 {
public static void main(String[] args) {
//使用系统提供 Arrays 完成 数组排序
int[] arr = {-1, 20, 2, 13, 3};
//比如对其进行排序
//传统方法是，自己编写排序(冒泡)
//系统是提供了相关的类，可以方便完成
Arrays.sort(arr);
//输出排序结果
for (int i = 0; i < arr.length ; i++) {
System.out.print(arr[i] + "\t");
}
}
}
8.4.9 注意事项和使用细节
8.5 访问修饰符
8.5.1 基本介绍
8.5.2 种访问修饰符的访问范围
8.5.3 使用的注意事项
8.6 面向对象编程三大特征
8.6.1 基本介绍
面向对象编程有三大特征：封装、继承和多态。
8.6.2 封装介绍
8.6.3 封装的理解和好处
8.6.4 封装的实现步骤 (三步)
8.7.1 将构造器和 setXxx 结合
看一个案例
//有三个属性的构造器
public Person(String name, int age, double salary) {
// this.name = name;
// this.age = age;
// this.salary = salary;
//我们可以将 set 方法写在构造器中，这样仍然可以验证
setName(name);
setAge(age);
setSalary(salary);
}
8.8 面向对象编程-继承
8.8.2 继承基本介绍和示意图
8.8.3 继承的基本语法
8.8.5 继承给编程带来的便利
8.8.6 继承的深入讨论/细节问题
8.8.7 继承的本质分析(重要)
package com.hspedu.extend_;
/**
* 讲解继承的本质
*/
public class ExtendsTheory {
public static void main(String[] args) {
Son son = new Son();//内存的布局
//?-> 这时请大家注意，要按照查找关系来返回信息
//(1) 首先看子类是否有该属性
//(2) 如果子类有这个属性，并且可以访问，则返回信息
//(3) 如果子类没有这个属性，就看父类有没有这个属性(如果父类有该属性，并且可以访问，就返回信息..)
//(4) 如果父类没有就按照(3)的规则，继续找上级父类，直到 Object...
System.out.println(son.name);//返回就是大头儿子
//System.out.println(son.age);//返回的就是 39
//System.out.println(son.getAge());//返回的就是 39
System.out.println(son.hobby);//返回的就是旅游
}
}
class GrandPa { //爷类
String name = "大头爷爷";
String hobby = "旅游";
}
class Father extends GrandPa {//父类
String name = "大头爸爸";
private int age = 39;
public int getAge() {
return age;
}
}
class Son extends Father { //子类
String name = "大头儿子";
}
子类创建的内存布局：
如果Father里的age是private，即使GrandPa里也有age，是public，访问age的时候一样到Father就会停止，不会继续查看GrandPa里是否有age。
8.8.8 课堂练习
由于B()函数里调用了this函数，所以没有super函数，但B(String name)函数有super()。
8.9 super 关键字
8.9.1 基本介绍
super 代表父类的引用，用于访问父类的属性、方法、构造器。
8.9.2 基本语法
8.9.3 super 给编程带来的便利/细节
8.9.4 super 和 this 的比较
8.10 方法重写/覆盖(override)
8.10.1 基本介绍
8.10.3 注意事项和使用细节
8.10.4 课堂练习
8.11 面向对象编程-多态
8.11.1 先看一个问题
8.11.2 多[多种]态[状态]基本介绍
方法或对象具有多种形态。是面向对象的第三大特征，多态是建立在封装和继承基础之上的。
8.11.3 多态的具体体现
方法的多态
重写和重载就体现多态
对象的多态 (核心，困难，重点)
package com.hspedu.poly_.objectpoly_;
public class Animal {
public void cry() {
System.out.println("Animal cry() 动物在叫....");
}
}
package com.hspedu.poly_.objectpoly_;
public class Cat extends Animal {
public void cry() {
System.out.println("Cat cry() 小猫喵喵叫...");
}
}
package com.hspedu.poly_.objectpoly_;
public class Dog extends Animal {
public void cry() {
System.out.println("Dog cry() 小狗汪汪叫...");
}
}
package com.hspedu.poly_.objectpoly_;
public class PolyObject {
public static void main(String[] args) {
//体验对象多态特点
//animal 编译类型就是 Animal , 运行类型 Dog
Animal animal = new Dog();
//因为运行时 , 执行到该行时，animal 运行类型是 Dog,所以 cry 就是 Dog 的 cry
animal.cry(); //小狗汪汪叫
//animal 编译类型 Animal,运行类型就是 Cat
animal = new Cat();
animal.cry(); //小猫喵喵叫
}
}
8.11.5 多态注意事项和细节讨论
package com.hspedu.poly_.detail_;
public class Animal {
String name = "动物";
int age = 10;
public void sleep(){
System.out.println("睡");
}
public void run(){
System.out.println("跑");
}
public void eat(){
System.out.println("吃");
}
public void show(){
System.out.println("hello,你好");
}
}
package com.hspedu.poly_.detail_;
public class Cat extends Animal {
public void eat(){//方法重写
System.out.println("猫吃鱼");
}
public void catchMouse(){//Cat 特有方法
System.out.println("猫抓老鼠");
}
}
package com.hspedu.poly_.detail_;
public class Dog extends Animal {//Dog 是 Animal 的子类
}
package com.hspedu.poly_.detail_;
public class PolyDetail {
public static void main(String[] args) {
//向上转型: 父类的引用指向了子类的对象
//语法：父类类型引用名 = new 子类类型();
Animal animal = new Cat();
Object obj = new Cat();//可以吗? 可以 Object 也是 Cat 的父类
//向上转型调用方法的规则如下:
//(1)可以调用父类中的所有成员(需遵守访问权限)
//(2)但是不能调用子类的特有的成员
//(#)因为在编译阶段，能调用哪些成员,是由编译类型来决定的
//animal.catchMouse();错误
//(4)最终运行效果看子类(运行类型)的具体实现, 即调用方法时，按照从子类(运行类型)开始查找方法
//，然后调用，规则我前面我们讲的方法调用规则一致。
animal.eat();//猫吃鱼..
animal.run();//跑
animal.show();//hello,你好
animal.sleep();//睡
//老师希望，可以调用 Cat 的 catchMouse 方法
//多态的向下转型
//(1)语法：子类类型 引用名 =（子类类型）父类引用;
//问一个问题? cat 的编译类型 Cat,运行类型是 Cat
Cat cat = (Cat) animal;
cat.catchMouse();//猫抓老鼠
//(2)要求父类的引用必须指向的是当前目标类型的对象
Dog dog = (Dog) animal; //可以吗？
System.out.println("ok~~");
}
}
向下转型图解：
animal本来就指向cat对象，所以对animal向下转型为cat是没有问题的，用cat类型指向cat对象。
属性没有重写之说！属性的值看编译类型：
package com.hspedu.poly_.detail_;
public class PolyDetail02 {
public static void main(String[] args) {
//属性没有重写之说！属性的值看编译类型
Base base = new Sub();//向上转型
System.out.println(base.count);// ？ 看编译类型 10
Sub sub = new Sub();
System.out.println(sub.count);//? 20
}
}
class Base { //父类
int count = 10;//属性
}
class Sub extends Base {//子类
int count = 20;//属性
}
instanceOf 比较操作符，用于判断对象的运行类型是否为 XX 类型或 XX 类型的子类型：
package com.hspedu.poly_.detail_;
public class PolyDetail03 {
public static void main(String[] args) {
BB bb = new BB();
System.out.println(bb instanceof BB);// true
System.out.println(bb instanceof AA);// true
//aa 编译类型 AA, 运行类型是 BB
//BB 是 AA 子类
AA aa = new BB();
System.out.println(aa instanceof AA);
System.out.println(aa instanceof BB);
Object obj = new Object();
System.out.println(obj instanceof AA);//false
String str = "hello";
//System.out.println(str instanceof AA);
System.out.println(str instanceof Object);//true
}
}
class AA {} //父类
class BB extends AA {}//子类
8.11.6 课堂练习
8.11.7 java 的动态绑定机制(非常非常重要.)
package com.hspedu.poly_.dynamic_;
public class DynamicBinding {
public static void main(String[] args) {
//a 的编译类型 A, 运行类型 B
A a = new B();//向上转型
System.out.println(a.sum());//?40 -> 30
System.out.println(a.sum1());//?30-> 20
}
}
class A {//父类
public int i = 10;
//动态绑定机制:
public int sum() {//父类 sum()
return getI() + 10;//20 + 10
}
public int sum1() {//父类 sum1()
return i + 10;//10 + 10
}
public int getI() {//父类 getI
return i;
}
}
class B extends A {//子类
public int i = 20;
// public int sum() {
// return i + 20;
// }
public int getI() {//子类 getI()
return i;
}
// public int sum1() {
// return i + 10;
// }
}
8.11.8 多态的应用
package com.hspedu.poly_.polyarr_;
public class PloyArray {
public static void main(String[] args) {
//应用实例:现有一个继承结构如下：要求创建 1 个 Person 对象、
// 2 个 Student 对象和 2 个 Teacher 对象, 统一放在数组中，并调用每个对象 say 方法
Person[] persons = new Person[5];
persons[0] = new Person("jack", 20);
persons[1] = new Student("mary", 18, 100);
persons[2] = new Student("smith", 19, 30.1);
persons[3] = new Teacher("scott", 30, 20000);
persons[4] = new Teacher("king", 50, 25000);
//循环遍历多态数组，调用 say
for (int i = 0; i < persons.length; i++) {
//老师提示: person[i] 编译类型是 Person ,运行类型是是根据实际情况由 JVM 来判断
System.out.println(persons[i].say());//动态绑定机制
//这里使用 类型判断 + 向下转型.
if(persons[i] instanceof Student) {//判断 person[i] 的运行类型是不是 Student
Student student = (Student)persons[i];//向下转型
student.study(); //小伙伴也可以使用一条语句 ((Student)persons[i]).study();
} else if(persons[i] instanceof Teacher) {
Teacher teacher = (Teacher)persons[i];
teacher.teach();
} else if(persons[i] instanceof Person){
//
} else {
System.out.println("你的类型有误, 请自己检查...");
}
}
}
}
8.12 Object 类详解
8.12.1 equals 方法
查看jdk源码之前需要配置如下，不过系统已经默认自动帮你配置了：
8.12.2 如何重写 equals 方法
应用实例: 判断两个 Person 对象的内容是否相等，如果两个 Person 对象的各个属性值都一样，则返回 true，反之 false。
package com.hspedu.object_;
public class EqualsExercise01 {
public static void main(String[] args) {
Person person1 = new Person("jack", 10, '男');
Person person2 = new Person("jack", 20, '男');
System.out.println(person1.equals(person2));//假
}
}
//判断两个 Person 对象的内容是否相等，
//如果两个 Person 对象的各个属性值都一样，则返回 true，反之 false
class Person{ //extends Object
private String name;
private int age;
private char gender;
//重写 Object 的 equals 方法
public boolean equals(Object obj) {
//判断如果比较的两个对象是同一个对象，则直接返回 true
if(this == obj) {
return true;
}
//类型判断
if(obj instanceof Person) {//是 Person，我们才比较
//进行 向下转型, 因为我需要得到 obj 的 各个属性
Person p = (Person)obj;
return this.name.equals(p.name) && this.age == p.age && this.gender == p.gender; }
//如果不是 Person ，则直接返回 false
return false;
}
}
8.12.4 hashCode 方法
8.12.5 toString 方法
package com.hspedu.object_;
public class ToString_ {
public static void main(String[] args) {
/*
Object 的 toString() 源码
(1)getClass().getName() 类的全类名(包名+类名 )
(2)Integer.toHexString(hashCode()) 将对象的 hashCode 值转成 16 进制字符串
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
*/
Monster monster = new Monster("小妖怪", "巡山的", 1000);
System.out.println(monster.toString() + " hashcode=" + monster.hashCode());
System.out.println("==当直接输出一个对象时，toString 方法会被默认的调用==");
System.out.println(monster); //等价 monster.toString()
}
}
class Monster {
private String name;
private String job;
private double sal;
public Monster(String name, String job, double sal) {
this.name = name;
this.job = job;
this.sal = sal;
}
//重写 toString 方法, 输出对象的属性
//使用快捷键即可 alt+insert -> toString
@Override
public String toString() { //重写后，一般是把对象的属性值输出，当然程序员也可以自己定制
return "Monster{" + "name='" + name + '\'' +
", job='" + job + '\'' +
", sal=" + sal +
'}';
}
@Override
protected void finalize() throws Throwable {
System.out.println("fin..");
}
}
8.12.6 finalize 方法
package com.hspedu.object_;
//演示 Finalize 的用法
public class Finalize_ {
public static void main(String[] args) {
Car bmw = new Car("宝马");
//这时 car 对象就是一个垃圾,垃圾回收器就会回收(销毁)对象, 在销毁对象前，会调用该对象的 finalize 方法
//程序员就可以在 finalize 中，写自己的业务逻辑代码(比如释放资源：数据库连接,或者打开文件..)
//如果程序员不重写 finalize,那么就会调用 Object 类的 finalize, 即默认处理
//如果程序员重写了 finalize, 就可以实现自己的逻辑
bmw = null;
System.gc();//主动调用垃圾回收器
System.out.println("程序退出了....");
}
}
class Car {
private String name;
//属性, 资源。。
public Car(String name) {
this.name = name;
}
//重写 finalize
@Override
protected void finalize() throws Throwable {
System.out.println("我们销毁 汽车" + name );
System.out.println("释放了某些资源...");
}
}
8.13 断点调试(debug)
8.13.1 一个实际需求
8.13.3 断点调试的快捷键
小技巧：将光标放在某个变量上，可以看到最新的数据。
老韩小技巧：断点可以在 debug 过程中，动态的下断点
8.15 本章作业
