1、每个场景就是一个实体来区分（Entity）这里很关键，我们后面会定义成泛型（T）
2、会通过上面定义的泛型T 用java反射获取到类对象，然后我们也必须知道parentid，id，list（所以，这三个关键属性的属性名，也需要传递进来）
3、继续用java反射获取T这个类对象中parentID,Id的值，然后进行业务逻辑处理比对，装载每个节点数据的子节点集赋值给T对象的List属性中
权限系统权限点设计（树形结构数据组装-JSON）：
https://blog.csdn.net/u010691807/article/details/98628237
之前我们做过一个权限点相关设计的东西，里面有一个关键点应用在于：
因为权限点的层级结构非固定这个特性，我们把数据组装的工作交由给了service层，在业务代码中完成的组装。（当然我们的工作中可能遇见各种各样类似的业务场景：比如，对分类的管理（一级二级三级菜单，城市区域管理，公司组织结构管理等都存在类似的层级性的管理））
额外知识扩展：
当层级结构固定的时候，比如：分类管理假如我们就分为固定3层，在用mybatis操作mysql数据库查询分类的示好，用mybatis提供的相关方法，我们可以直接返回一个具有层级关系的树结构数据回来直接使用（这里的sql是自关联的模式）
接着上面继续说，之前说到存在各种这样的逻辑现象，根据不同的操作对象，其实我们核心的点依然只有三个（进行关联的parentId, Id，以及存放当前节点的子节点数据集的对象（List））
若糖果类的id为1，那么糖果类下面的子节点就是各种好吃的糖（硬糖，软糖，口香糖。。。反正就是各种糖），这些子节点，就是 我们说的 List 数据集，隶属于 id为1的（糖果类）节点。
好了，上面我们已经说到了业务场景了。针对上面的，其实现在我们就是想做一个通用的小方法来组装树结构。
/*
* @Title: TreeUtil.java
*/
package com.kiki.kstore.util;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import org.apache.commons.collections4.CollectionUtils;
/**
* 封装一个共用的数结构组装工具
*
* @ClassName: TreeUtil
* @author kiki
* @date 2019年8月6日
* @version: V1.0
*/
public class TreeUtil<T> {
/**
*
* tree 组装树结构
*
* @param list
* 元数据
* @param parentId
* 父节点的id值
* @param t
* 父节点数据对象(也是通过这个得知实体Type)
* @param parentField
* T中的父节点属性名
* @param idField
* T中的关联节点属性名
* @param listField
* 存放集合数据的内容
* @throws Exception
* 参数 void 返回类型
*/
public void tree(List<T> list, Object parentId, T t, String parentField,
String idField, String listField) throws Exception {
List<T> resultList = new ArrayList<>();
for (T item : list) {
// Object pid = t.getClass().getMethod("getParentId").invoke(item);
Field f = t.getClass().getDeclaredField(parentField);
// setAccessible 实体中的属性是用private定义的，需要设置setAccessible 为true，才可以访问到对象
f.setAccessible(true);
// 获取属性值
Object pid = f.get(item);
System.out.println(pid);
if (Objects.equals(parentId, pid)) {
resultList.add(item);
}
}
if (CollectionUtils.isNotEmpty(resultList)) {
for (T item : resultList) {
Field f = t.getClass().getDeclaredField(idField);
f.setAccessible(true);
Object id = f.get(item);
tree(list, id, item, parentField, idField, listField);
}
}
// 给属性设置值
Field f = t.getClass().getDeclaredField(listField);
f.setAccessible(true);
f.set(t, resultList);
}
}
|
package com.kiki.kstore;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import org.apache.commons.collections4.CollectionUtils;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import com.alibaba.fastjson.JSON;
import com.kiki.kstore.entity.Permission;
import com.kiki.kstore.mapper.PermissionMapper;
import com.kiki.kstore.util.TreeUtil;
/**
*
* unit test
*
* @ClassName: PropertiesTest
* @author kiki
* @date 2019年8月6日
* @version: V1.0
*/
@MapperScan(basePackages = "com.kiki.info.mapper")
@RunWith(SpringRunner.class)
@SpringBootTest
public class PropertiesTest {
@Autowired
private PermissionMapper permissionMapper;
@Test
public void getList() throws Exception {
List<Permission> list = permissionMapper.getAll();
Permission permission = new Permission();
TreeUtil<Permission> util = new TreeUtil<>();
util.tree(list, 0, permission, "parentId", "id", "list");
System.out.println(JSON.toJSONString(permission));
}}
|
parentId，id,list 是Permission实体中的三个属性名(它们组成了基础的关系构成)。
归纳总结：
1、通过java反射，获取泛型类中，某个方法的返回结果（泛型对象T，方法名）
Object pid = t.getClass().getMethod("getParentId").invoke(item);
t表示泛型对象(这里是一个实体类)，
getParentId是t所指类中的方法名
item表示有数据的t实体对象
2、通过java反射，获取泛型类中某个属性的值（泛型对象T,属性名）
t是泛型对象
prentField是属性名称
Field f = t.getClass().getDeclaredField(parentField);
// setAccessible 实体中的属性是用private定义的，需要设置setAccessible 为true，才可以访问到对象
f.setAccessible(true);
// 获取属性值
Object pid = f.get(item);
|
3、通过java反射，给泛型类中的属性赋值
t是泛型对象
listField是属性名称
resultList是数据集，用来给listField这个属性赋值
// 给属性设置值
Field f = t.getClass().getDeclaredField(listField);
f.setAccessible(true);
f.set(t, resultList);
|
个人的理解：
学了泛型，我们可以做通用小工具，但就是因为“通用”这个特性，我们的所操作类基本不一样，才用到泛型；因此我们在这里，也离不开java反射知识的运用。
因为是通用小工具，有些关键参数肯定是具有通用性，这个必不可少（比如上面的那几个固有的参数：parentid,id,list） 它们在各自类中的属性名可能不一样，但是肯定有这样一个属性的。
本书为框架设计师和广大开发人员设计高质量的软件提供了权威的指南。书
中
介绍了在设计框架时的最佳实践，提供了自顶向下的规范，其
中
所描述的规范普遍适用于规模不同、可重用程度不同的框架和软件。这些规范历经.NET框架三个版本的长期开发，凝聚了数千名开发人员的经验和智慧。微软的各开发组正在使用这些规范开发下一代影响世界的软件产品。
第1章 概述 1
1.1 精心设计的框架所具备的品质 2
1.1.1 精心设计的框架是简单的 2
1.1.2 精心设计的框架设计代价高 3
1.1.3 精心设计的框架充满利弊权衡 3
1.1.4 精心设计的框架应该借鉴过去 4
1.1.5 精心设计的框架要考虑未来发展 4
1.1.6 精心设计的框架应具有良好的集成性 4
1.1.7 精心设计的框架是一致的 4
第2章 框架设计基础 6
2.1 渐进框架 7
2.2 框架设计的基本原则 10
2.2.1 场景驱动设计的原则 11
2.2.2 低门槛原则 17
2.2.3 自说明对象模型原则 20
2.2.4 分层架构原则 25
2.3 小结 27
第3章 命名规范 28
3.1 大小写约定 29
3.1.1 标识符的大小写规则 29
3.1.2 首字母缩写词的大小写 31
3.1.3 复合词和常用术语的大小写 33
3.1.4 是否区分大小写 35
3.2
通用
命名约定 35
3.2.1 单词的选择 36
3.2.2 使用单词缩写和首字母缩写词 37
3.2.3 避免使用语言特有的名字 38
3.2.4 为已有API的新版本命名 39
3.3 程序集和DLL的命名 42
3.4 名字空间的命名 43
3.5 类、结构和接口的命名 47
3.5.1
泛型类
型参数的命名 49
3.5.2 常用类型的命名 50
3.5.3 枚举类型的命名 51
3.6 类型成员的命名 53
3.6.1
方法
的命名 53
3.6.2
属性
的命名 54
3.6.3 事件的命名 55
3.6.4 字段的命名 57
3.7 参数的命名 57
3.8 资源的命名 58
3.9 小结 59
第4章 类型设计规范 60
4.1 类型和名字空间 62
4.2 类和结构之间的选择 67
4.3 类和接口之间的选择 69
4.4
抽象
类的设计 76
4.5 静态类的设计 78
4.6 接口的设计 79
4.7 结构的设计 81
4.8 枚举的设计 83
4.8.1 标记枚举的设计 89
4.8.2 给枚举添加
值
93
4.9 嵌套类型 94
4.10 小结 96
第5章 成员设计 97
5.1 成员设计的一般规范 97
5.1.1 成员重载 97
5.1.2 显式地实现接口成员 102
5.1.3
属性
和
方法
之间的选择 106
5.2
属性
的设计 112
5.2.1 索引
属性
的设计 113
5.2.2
属性
改变的通知事件 115
5.3 构造函数的设计 117
5.4 事件的设计 123
5.5 字段的设计 130
5.6 操作符重载 132
5.6.1 重载operator== 136
5.6.2 类型转换操作符 136
5.7 参数的设计 138
5.7.1 枚举和布尔参数之间的选择 140
5.7.2 参数的验证 142
5.7.3 参数的传递 145
5.7.4 参数数量可变的成员 147
5.7.5 指针参数 150
5.8 小结 152
第6章 为扩展性而设计 153
6.1 扩展机制 153
6.1.1 非密封类 153
6.1.2 保护成员 155
6.1.3 事件与回调函数 156
6.1.4 虚成员 158
6.1.5
抽象
(
抽象
类型与
抽象
接口) 160
6.2 基类 162
6.3 密封 163
6.4 小结 166
第7章 异常 167
7.1 抛
出
异常 171
7.2 为抛
出
的异常选择合适的类型 175
7.2.1 错误消息的设计 176
7.2.2 异常处理 177
7.2.3 对异常进行封装 182
7.3 标准异常类型的使用 184
7.3.1 Exception与SystemException 184
7.3.2 ApplicationException 184
7.3.3 InvalidOperationException 184
7.3.4 ArgumentException、ArgumentNullException及ArgumentOutOfRangeException 185
7.3.5 NullReferenceException、IndexOutOfRangeException及AccessViolationException 186
7.3.6 StackOverflowException 186
7.3.7 OutOfMemoryException 187
7.3.8 ComException、SEHException及其他CLR异常 188
7.3.9 ExecutionEngineException 188
7.4 自定义异常的设计 188
7.5 异常与性能 190
7.5.1 Tester-Doer模式 190
7.5.2 Try-Parse模式 191
7.6 小结 192
第8章 使用规范 193
8.1 数组 193
8.2 attribute 195
8.3 集合 198
8.3.1 集合参数 199
8.3.2 集合
属性
与返回
值
200
8.3.3 数组与集合之间的选择 204
8.3.4 自定义集合的实现 205
8.4 ICloneable 207
8.5 IComparableT与IEquatableT 208
8.6 IDisposable 210
8.7 对象 210
8.7.1 Object.Equals 210
8.7.2 Object.GetHashCode 212
8.7.3 Object.ToString 213
8.8 Uri 214
8.9 System.Xml的使用 216
8.10 相等性操作符 218
8.10.1
值
类型的相等性操作符 218
8.10.2 引用类型的相等性操作符 219
第9章 常用的设计模式 220
9.1 聚合组件 220
9.1.1 面向组件的设计 222
9.1.2 因子类型 224
9.1.3 聚合组件规范 224
9.2 Async模式 227
9.3 Dispose模式 232
9.3.1 基本Dispose模式 234
9.3.2 可终结类型 240
9.4 Factory模式 243
9.5 Optional Feature模式 247
9.6 Template Method模式 251
9.7 超时 252
9.8 结束语 254
附录A C#编程风格约定 255
A.1
通用
风格约定 255
A.1.1 花括号的使用 255
A.1.2 空格的使用 257
A.1.3 缩进的使用 259
A.2 命名约定 259
A.3 注释 260
A.4 文件的组织 261
附录B 通过FxCop来实施设计规范 263
B.1 FxCop是什么？ 263
B.2 FxCop的发展过程 264
B.3 FxCop的工作原理 265
B.4 FxCop规范的覆盖范围 265
B.4.1 与命名规范有关的FxCop规则 265
B.4.2 与类型设计规范有关的FxCop规则 274
B.4.3 与成员的设计有关的FxCop规则 277
B.4.4 与为扩展性而设计有关的FxCop规则 284
B.4.5 与异常有关的FxCop规则 285
B.4.6 与使用规范有关的FxCop规则 287
B.4.7 与设计模式有关的FxCop规则 291
附录C API规范样例 292
术语表 299
推荐读物 303
索引 305
public static void main(String[] args) throwsIntrospectionException {SysUser obj= newSysUser();obj.setId(1L);obj.setUserName("测试");obj.setCreatedDate(LocalDateTime.now());Class> clazz = SysUser.cla...
记录一次
反射
的使用，第一次真正运用到实际工作
中
，发现
反射
是真的强大！写了
一个
通用
类，主要是便于和 db 的交互操作，使用到了
泛型
T 对象，但是有一步需要
获取
该对象的
属性
id
值
(前提是所有赋
值
给 T 对象的对象自己都有
一个
相同类型的 id)，再做一点逻辑处理，如果是具体对象来调用这个
泛型
，则可以正常 getId() 得到该对象的
属性
值
，但是对于如果是
泛型
方法
里面要通过 T 这个
泛型
对象来 ge...
通过大量的比喻、类比、对比和图示等多种讲解方式，学习效果好
对
Java
语言的每个语法都提供了
一个
或多个例程讲解
大量使用流程图表示程序的执行过程，使用结构图表示程序的内部状态
每章最后都给
出
了典型的练习题，让读者及时练习，巩固提高，并提供了参考答案
第1篇
Java
语言基本语法
第1章 让自己的第
一个
Java
程序跑起来 2
教学视频：19分钟
1.1 想要用
Java
改变这个世界吗？ 2
1.1.1
Java
有什么优势？ 2
1.1.2
Java
在哪儿？ 3
1.2 准备好开始
Java
之旅 3
1.2.1 下载JDK 4
1.2.2 安装JDK 5
1.2.3 配置环境变量 6
1.2.4 测试环境是否安装成功 8
1.2.5 如果失败了怎么办？ 9
1.3 让自己的第
一个
程序运行起来 10
1.3.1 编写自己的Hello World源程序 10
1.3.2 编译自己的HelloWorld程序 11
1.3.3 让代码运行起来 13
1.4 初探Hello World 14
1.4.1 类（Class）：
Java
世界
中
一类物体 14
1.4.2
方法
（Method）：物体的功能 15
1.4.3 main()
方法
：所有
Java
程序执行的起点 15
.1.5 名词解释 16
1.5.1 JDK和
Java
平台 16
1.5.2
Java
编译器（
Java
Compiler） 17
1.5.3
Java
类库（
Java
Class Libraries） 17
1.5.4
Java
虚拟机（
Java
Virtual Machine） 17
1.5.5 HelloWorld的整个流程 17
1.6 小结：我们学会了编译和运行
一个
Java
程序！ 18
1.7 习题 19
第2章 搭建自己的集成开发环境 20
教学视频：31分钟
2.1 安装集成开发环境 20
2.1.1 集成开发环境有哪些 20
2.1.2 安装Eclipse 21
2.2 Eclipse界面介绍 23
2.2.1 启动Eclipse 23
2.2.2 Eclipse的Perspective 24
2.2.3 Eclipse的菜单 25
2.2.4 Eclipse的工具条 25
2.2.5 Eclipse辅助视图区 25
2.2.6 Eclipse
中
Package Explorer 26
2.2.7 Eclipse
中
的源代码编辑器 26
2.2.8 Eclipse的
设置
窗口 26
2.2.9 Eclipse
中
的其他视图 27
2.3 如何使用Eclipse 28
2.3.1 在Eclipse
中
创建自己的第
一个
项目 28
2.3.2 在Eclipse
中
编写HelloWorld程序 29
2.3.3 通过Eclipse运行Hello World 31
2.4 小结：Eclipse——功能很强大 32
2.5 习题 32
第3章
Java
中
的基本
数据
类型和运算符 33
教学视频：1小时5分钟
3.1
Java
中
的基本
数据
类型 33
3.1.1 基本
数据
类型——编程语言
中
的
数据
原子 33
3.1.2
Java
中
的基本上
数据
类型介绍 34
3.1.3 基本
数据
类型
值
域 34
3.2
Java
运算符 36
3.2.1 变量的概念 36
3.2.2 插曲：
Java
中
的语句 37
3.2.3 创建
一个
变量和变量名的规范 37
3.2.4
Java
中
的基本运算符和表达式 39
3.2.5
Java
中
的布尔运算符 43
3.3 基本
数据
类型运算的难点 47
3.3.1 强制类型转换——小数哪里去了 48
3.3.2 类型的转换在运算
中
悄悄进行 50
3.3.3 强制类型转换最优先 52
3.3.4 等号其实不简单 52
3.3.5 小心使用浮点数进行比较 53
3.3.6 boolean和char 55
3.3.7 不要使用还没有创建
出
来的变量 57
3.3.8 String——char串起的项链 58
3.3.9 转义符——看不见写得
出
61
3.4 小结：基本
数据
类型——
Java
中
一切
数据
和运算的基础 63
3.5 习题 65
第4章
Java
中
的程序执行流程 67
教学视频：1小时57分钟
4.1 顺序执行 67
4.2 使用if-else让程序懂得判断 68
4.2.1 if语句 68
4.2.2 if语句的嵌套 71
4.2.3 if-else语句 73
4.2.4 if-else语句嵌套 75
4.3 使用while进行循环 76
4.3.1 使用while语句 76
4.3.2 使用do-while语句 79
4.4 使用for进行循环 80
4.4.1 自增和自减操作 80
4.4.2 for语句 82
4.4.3 for语句省略形式 84
4.5 语句
中
不能不说的事 84
4.5.1 小心复杂语句
中
创建的变量 85
4.5.2 别让循环次数给弄懵了 86
4.5.3 循环的嵌套 87
4.6 continue关键字与break关键字 88
4.6.1 continue关键字 88
4.6.2 break关键字 89
4.7 使用switch进行跳转 90
4.8 大例子 94
4.8.1 从控制台读取
数据
94
4.8.2 结账程序
中
的循环 96
4.9 小结：
Java
不是
一个
直肠子 98
4.10 习题 99
第5章 数组 100
教学视频：35分钟
5.1 什么是数组 100
5.1.1 假设：如果需要逐个定义变量 100
5.1.2 数组初探 101
5.1.3 数组——物以类聚 104
5.1.4 数组元素的
值
内有乾坤 105
5.1.5 创建数组的简洁语法 106
5.2 数组的“名”与“实” 107
5.2.1 “名”与“实”分离的数组 107
5.2.2 一“实”多“名”的数组 109
5.2.3 一“实”多“名”带来的困惑 111
5.3 多维数组 114
5.3.1 什么是多维数组 114
5.3.2 多维数组的实质 115
5.4 数组大练兵 123
5.4.1 轻松查询全班成绩 123
5.4.2 轻松查询全校成绩不在话下 124
5.4.3 杨辉三角 125
5.5 小结：方便快速的数组 129
5.6 习题 129
第2篇
Java
语言高级语法
第6章
Java
的类（Class）和对象（Object） 132
教学视频：59分钟
6.1 驾驶汽车向类（Class）的世界进发 132
6.1.1 汽车带来的问题 132
6.1.1 类的组成 134
6.1.3 使用自定义的Car类 136
6.1.4 类和对象 139
6.1.5 源文件的存放 141
6.1.5 理解引用 143
6.1.7 null关键字 145
6.2 巧妙使用类
中
的
属性
147
6.2.1 在类
中
给每个变量
一个
初始
值
147
6.2.2 定义自己的引用 147
6.2.3 使用点操作符的技巧 148
6.2.4 类的数组 149
6.3 小结：
Java
其实是个类和对象的世界 152
6.4 习题 153
第7章
Java
中
的
方法
——给汽车丰富多彩的功能 154
教学视频：2小时55分钟
7.1
方法
：让汽车动开动 154
7.1.1 引
出
问题：开动汽车 154
7.1.2 那么，
方法
到底是什么呢？ 155
7.1.3
方法
调用过程初探 156
7.2
Java
普通
方法
的组成部分 157
7.2.1 访问控制符：public 158
7.2.2 返回
值
和关键字void 158
7.2.3
方法
名（Method Name） 159
7.2.4 参数列表（Parameter List） 159
7.2.5
方法
体（Method Body） 160
7.2.6
方法
串串烧 160
7.3
方法
的参数：让汽车加速 161
7.3.1
方法
的参数：让汽车可以加速 161
7.3.2 带参数的
方法
有何不同？ 162
7.3.3 让
方法
有多个参数 163
7.4 返回
值
：汽车超速了吗？ 164
7.4.1 写
一个
有返回
值
的
方法
164
7.4.2 调用有返回
值
的
方法
165
7.4.3 发生了什么？如何使用
方法
的返回
值
？ 166
7.4.4 使用return结束
方法
166
7.5
方法
重载（overload）：给汽车加速添个限制 168
7.5.1 什么是
方法
的签名 168
7.5.2 什么是重载？为什么要重载？ 168
7.5.3 给汽车加个重载的
方法
169
7.5.4 测试一下 169
7.5.5 重载容易引发误解的两个地方——返回类型和形参名 170
7.5.6 重载
中
的最难点——参数匹配原则 171
7.6 使用类的实例作为
方法
参数 172
7.6.1 超车
方法
：使用类实例做参数 172
7.6.2 调用这个
方法
173
7.6.3 发生了什么 174
7.7 加餐：局部变量和实例变量 175
7.7.1 什么是局部变量（Local Variable） 175
7.7.2 什么是实例变量（Instance Variable） 177
7.8 this关键字：指向对象自己的引用 177
7.8.1 发现问题：当实例变量和局部变量重名 177
7.8.2 经常深藏不露的this关键字 178
7.8.3 在
方法
中
调用
方法
179
7.9 构造
方法
（Constructor） 181
7.9.1 构造（Constructor）
方法
初探 181
7.9.2 如何使用构造
方法
182
7.9.3 留个无参数的构造
方法
——给重要
属性
赋初始
值
183
7.9.4 在构造
方法
中
调用构造
方法
184
7.10
方法
大汇总 185
7.10.1 本例
中
用到的类 186
7.10.2 使用例程将本章的知识穿起来 189
7.11 小结：多方位理解
Java
方法
191
7.12 习题 192
第8章
Java
中
的包（Package）命名习惯和注释 193
教学视频：43分钟
8.1
Java
中
的包（Package） 193
8.1.1
Java
中
的包 193
8.1.2 在Eclipse
中
使用包 194
8.1.3 天上掉下个package 197
8.1.4 包带来了什么？ 197
8.2 import语句：化繁为简 200
8.2.1 import语句 200
8.2.2 一网打尽包
中
所有类 201
8.2.3 import语句带来的小问题 202
8.2.4 默认引入的包 204
8.3 命名习惯大回顾 204
8.4
Java
中
的注释 205
8.4.1 使用双斜杠的单行注释 205
8.4.2 多行注释 206
8.4.3
Java
doc注释 206
8.5 小结：包让
Java
的类更清晰优雅 208
8.6 习题 209
第9章 再看数组、字符串和main()
方法
210
教学视频：29分钟
9.1 数组也是类 210
9.1.1 得到数组的长度 210
9.1.2 加餐：不可改变的final变量 211
9.1.3 多维数组的长度 212
9.1.4 一维数组的clone()
方法
212
9.1.5 当数组类型不再是基本
数据
类型 214
9.1.6 多维数组的clone()
方法
217
9.2 老朋友String类 220
9.2.1 遍历String
中
的字符 220
9.2.2
获取
字符串
中
的一部分 222
9.2.3 判断两个字符串是否相等 223
9.2.4 判断字符串的开头和结尾 225
9.2.5 分割字符串 225
9.2.6 在字符串
中
查找子字符串或字符 226
9.2.7 替换字符串
中
的内容 226
9.2.8 String对象——磐石刻字 227
9.3 String类的最佳拍档——StringBuffer类 227
9.3.1 StringBuffer：专业操纵字符 228
9.3.2 String和StringBuffer
一个
都不能少 229
9.4 最熟悉的陌生人：main()
方法
229
9.4.1 main()
方法
的参数 229
9.4.2 static关键字 232
9.4.3 当
方法
遇到static关键字 233
9.5 小结：学会使用类
中
的
方法
235
9.6 习题 236
第10章 继承和多态 237
教学视频：1小时55分钟
10.1 继承——最优的解决方案 237
10.1.1 饭前水果：实例变量的访问控制符 237
10.1.2 一切还是从汽车开始 238
10.1.3 一类车，
一个
类 241
10.1.4 分开也有麻烦 244
10.1.5 使用继承——问题迎刃而解 245
10.1.6 使用Bus类 248
10.1.7
Java
中
的单继承 248
10.1.8
Java
中
的类图 249
10.1.9 万类之祖——Object类 250
10.2 子类对象？父类对象？ 251
10.2.1 父随子行 251
10.2.2 当构造
方法
遇到继承 254
10.2.3 记得给类
一个
无参数的构造
方法
255
10.2.4 调用父类
中
的构造
方法
256
10.2.5 对象也会“变脸” 258
10.2.6 遵守语法，正确“变脸” 262
10.3 覆盖——与继承如影随形 264
10.3.1 当
方法
不再
通用
264
10.3.2 覆盖——让众口不再难调 265
10.3.3 覆盖——到底调用了哪个
方法
270
10.3.4 覆盖的语法不简单 272
10.3.5 更复杂的使用覆盖的情况 274
10.3.6 覆盖——不得不打开的潘多拉魔盒 276
10.3.7 使用super调用父类
中
的
方法
和
属性
278
10.4 多态（Polymorphism）以及其他 279
10.4.1 多态——运行方知结果 280
10.4.2 重载也不简单 280
10.4.3 使用多态构建车队 283
10.5 在多态的环境
中
拨开迷雾 284
10.5.1 神秘的Class类 284
10.5.2 覆盖不再神秘 285
10.5.3 instanceof运算符——让对象告诉你它的类是谁 286
10.6 小结：继承和多态让世界丰富多彩 287
10.7 习题 290
第11章 修饰符（Qualifier） 291
教学视频：26分钟
11.1 插曲：类的组成部分的名字 291
11.2 类
中
的修饰符 292
11.2.1 无修饰符类 292
11.2.2 类的可见性 293
11.2.3 final——让类不可被继承 295
11.2.4 理解final关键字 296
11.2.5 总结：类的修饰符 297
11.3
方法
的修饰符 297
11.3.1
方法
的访问控制符 298
11.3.2 public：没有限制的修饰符 299
11.3.3 protected：仅对子类和同包的类可见 300
11.3.4 默认控制符：仅在本包
中
可见 301
11.3.5 private：仅对本类可见 303
11.3.6 理解4个访问控制符 304
11.3.7 访问控制符可见性汇总 306
11.3.8 访问控制符带来的覆盖问题 306
11.3.9 final：不允许
方法
被覆盖 310
11.3.10 重温静态
方法
311
11.3.11 静态
方法
——类范围里的概念 312
11.3.12 静态
方法
何以为“静态” 314
11.4 变量的修饰符 316
11.4.1 变量
方法
皆成员 317
11.4.2 变量的访问控制符 317
11.4.3 使用private修饰类的成员变量 318
11.4.4 使用private，然后呢？ 320
11.4.5 变量的覆盖 322
11.4.6 使用final修饰成员变量 325
11.4.7 静态成员变量 326
11.4.8 局部变量的修饰符 326
11.4.9 当final遇到引用类型成员变量 327
11.5 小结：修饰符作用大 328
11.6 习题 330
第12章 接口 331
教学视频：29分钟
12.1 自行车带来的问题 331
12.1.1 记录马路上的车辆 331
12.1.2 引发问题的自行车 335
12.1.3 仔细分析recordTransport()
方法
338
12.2 初用接口 339
12.2.1 准备好需要用到的类 339
12.2.2 认识接口的代码组成 340
12.2.3 什么是接口 341
12.2.4 使用接口仅需一步——实现接口 342
12.2.5 接口——让类集多重类型于一身 344
12.2.6 简化recordTransport()
方法
347
12.3 再探接口 349
12.3.1 重温上节
中
的程序 349
12.3.2 面向接口编程 351
12.3.3 话说“
抽象
” 353
12.3.4 接口大瘦身 355
12.3.5 实现多个接口 355
12.3.6 接口
中
的变量 357
12.3.7 接口的继承 358
12.3.8 匹配
抽象
方法
中
的类型 359
12.3.9 空接口 361
12.4 小结：接口的难点在于何时使用 362
12.5 习题 364
第13章
抽象
类和内部类 365
教学视频：26分钟
13.1
抽象
类（Abstract Class） 365
13.1.1 不知道怎么打招呼的Person类 365
13.1.2 当类
中
有了
抽象
方法
367
13.1.3
抽象
类语法详解 368
13.1.4 理解
抽象
类的作用 369
13.2 内部类的分类（Inner Class） 370
13.2.1 成员内部类 370
13.2.2 局部内部类 372
13.3 成员内部类 374
13.3.1 使用成员内部类 374
13.3.2 成员内部类的修饰符 375
13.3.3 在类外部使用内部类 376
13.3.4 非静态内部类的特性 378
13.3.5 外部类访问成员内部类
中
的
属性
382
13.3.6 静态成员内部类 383
13.4 局部内部类 384
13.4.1 局部内部类之“局部” 385
13.4.2 局部内部类之“内部类” 386
13.4.3 使用局部内部类 388
13.5 匿名内部类（Anonymous inner classes） 389
13.5.1 准备工作 389
13.5.2 匿名内部类的语法 389
13.5.3 通过接口使用匿名类 390
13.5.4 通过
抽象
类使用匿名类 391
13.6 类，这样一路走来 391
13.7 小结：丰富多彩的类 395
13.8 习题 397
第14章
Java
的异常处理机制 398
教学视频：36分钟
14.1 认识异常 398
14.1.1 异常什么时候发生 398
14.1.2 异常是什么 401
14.1.3
Java
异常机制的流程 401
14.2 抛
出
异常 403
14.2.1 异常类的父类——Throwable 403
14.2.2 在代码
中
使用throw抛
出
一个
异常 404
14.2.3 在
方法
声明
中
使用throws 407
14.2.4 构造自定义异常类 409
14.2.5 使用自定义异常类 410
14.3 异常的传递 411
14.3.1 抛
出
最确切的异常类型 411
14.3.2
Java
异常的传递 412
14.3.3 图说
Java
异常的传递 414
14.4 异常的处理 418
14.4.1 把异常捉住 418
14.4.2 图说异常处理流程 421
14.4.3 多类异常，一并处理 424
14.4.4 try-catch-finally语句 426
14.4.5 try-finally语句 431
14.4.6 好好利用catch语句 432
14.5 异常的类型 433
14.5.1 3个类的继承关系 433
14.5.2 必须处理的Exception类 434
14.5.3 灵活掌握的RuntimeException类 434
14.5.4 不用处理的Error类 435
14.6 小结：终止错误的蔓延 435
14.7 习题 437
第15章 多线程编程 438
教学视频：1小时14分钟
15.1 线程——执行代码的机器 438
15.1.1 线程——执行代码的基本单位 438
15.1.2 演奏会模型 440
15.2
Java
中
的线程编程 443
15.2.1 线程类Thread 443
15.2.2 覆盖Thread类的run()
方法
444
15.2.3 使用Runnable接口 446
15.2.4 两个线程 448
15.3 深入学习Thread类 449
15.3.1 线程的名字 449
15.3.2 得到当前的线程 451
15.3.3 让线程“沉睡” 453
15.4 多个线程的故事 457
15.4.1
一个
有多个线程的程序 457
15.4.2 复印社模型 459
15.4.3
一个
简单的复印社例程 461
15.5 多个线程的同步 463
15.5.1 线程同步之synchronized关键字 463
15.5.2 深入学习synchronized关键字 468
15.5.3 静态同步
方法
469
15.5.4 非静态的同步
方法
472
15.5.5 银行的麻烦——账户乱套了 474
15.5.6 多角度理解同步
方法
481
15.5.7 闲话同步
方法
的使用 484
15.5.8 同步代码块 485
15.5.9 锁（Lock） 486
15.5.10 线程同步之wait()和notify()
方法
488
15.5.11 wait和notify的顺序 491
15.6 小结：线程——代码执行器 494
15.7 习题 495
第3篇
Java
语言编程进阶
第16章 如何学习本篇 498
教学视频：15分钟
16.1 多想多写多练 498
16.2 术业有专攻 498
16.3 拆分问题，逐个击破 500
16.4 阅读
Java
doc 500
16.5 小结：大练兵马上开始 506
16.6 习题 507
第17章 编程常用知识 508
教学视频：18分钟
17.1 再谈对象的比较 508
17.1.1 hashcode()
方法
508
17.1.2 equals()
方法
509
17.1.3 对象的比较equals()
方法
509
17.2
Java
中
的集合类框架 510
17.2.1 集合类框架
中
的接口 510
17.2.2 List接口 511
17.2.3 使用ArrayList 512
17.2.4 Set接口 516
17.2.5 使用HashSet类 517
17.2.6 List与Set 518
17.3
泛型
简介 518
17.3.1 没有
泛型
时的程序 519
17.3.2 使用
泛型
——避免强制类型转 520
17.4 Map接口 522
17.4.1 认识Map 522
17.4.2 使用HashMap 523
17.5 字符集和编码 524
17.5.1 字符集 524
17.5.2 编码 525
17.5.3 关于字符集的小程序 526
17.6 小结：编程需要打好基础 529
17.7 习题 530
第18章
Java
文件编程和
Java
文件I/O 531
教学视频：9分钟
18.1
Java
中
的文件编程 531
18.1.1 File类 531
18.1.2 创建和删除文件 532
18.1.3 列
出
文件和文件夹 533
18.1.4 重命名文件 535
18.2
Java
的I/O编程 536
18.2.1 理解
Java
中
的Stream 536
18.2.2 向文件
中
写入
数据
538
18.2.3 从文件
中
读取
数据
539
18.2.4 从控制台读取
数据
541
18.2.5 使用输
出
流写入
数据
543
18.2.6 使用输入流读取
数据
545
18.3 小结：
Java
中
的文件类和输入输
出
机制 546
18.4 习题 547
第19章
Java
Socket编程 548
教学视频：8分钟
19.1 IP地址和端口号 548
19.1.1 IP地址——计算机的标识 548
19.1.2 端口号——通信的窗口 549
19.1.3 网络，IP地址和端口号 551
19.2
Java
TCP编程 551
19.2.1
数据
传输协议 552
19.2.2 TCP的
数据
传输模式 552
19.2.3 第
一个
TCP小程序 553
19.3
Java
UDP编程 557
19.3.1 UDP的
数据
传输模式 557
19.3.2 使用UDP协议收发
数据
558
19.3.3 TCP和UDP的区别 560
19.4 小结：让程序伸向整个网络 561
19.5 习题 561
第20章
Java
Swing编程 562
教学视频：14分钟
20.1
Java
Swing编程简介 562
20.1.1 图形用户界面编程简介 562
20.1.2 组件 563
20.1.3 布局管理器（Layout Manager） 563
20.1.4 事件处理（Event Handling） 564
20.2 Swing基本组件 565
20.2.1 窗口（JFrame） 565
20.2.2 Swing的线程 567
20.2.3 Swing组件的鼻祖——JComponent 567
20.2.4 Swing面板类 568
20.2.5 Swing
中
的标签 568
20.2.6 Swing
中
的文本框 570
20.2.7 Swing
中
的文本域 571
20.2.8 Swing
中
的组合框 572
20.2.9 Swing
中
的按钮 573
20.3 Swing的布局管理器 574
20.3.1 最简单的FlowLayout 574
20.3.2 东南西北
中
之BorderLayout 574
20.3.3 平均分割之——GridLayout 576
20.3.4 最强大的布局管理器——GridBagLayout 577
20.3.5 使用多个布局管理器 579
20.4 Swing的事件处理 581
20.4.1 事件的传递和封装 581
20.4.2 事件监听器——事件的处理者 582
20.4.3 Swing事件处理的机制 584
20.4.4 事件监听器的编写 586
20.4.5 如何学习更多的事件 588
20.5 小结：从此不再依赖控制台 588
20.6 习题 588
第21章 编程，需要的是想象力和恒心 589
教学视频：13分钟
21.1 编程的前奏 589
21.1.1 细数手
中
的积木 589
21.1.2 发挥想象力 590
21.1.3 确定程序的功能 591
21.2 聊天窗口程序 591
21.2.1 聊天程序设计 591
21.2.2 设计程序运行效果 593
21.2.3 UDP消息收发模块 595
21.2.4 图形用户界面模块 598
21.2.5 消息处理模块 600
21.2.6
一个
更
通用
的聊天程序 601
21.3 小结：编程是必不可少的锻炼 602
21.4 习题 602
第22章 JDBC入门 603
教学视频：11分钟
22.1 JDBC的基本API 603
22.1.1 JDBC是什么 603
22.1.2 DriverManager——驱动管理器 605
22.1.3 Connection接口 606
22.1.4 Statement接口 606
22.1.5 PreparedStatement接口 606
22.1.6 ResultSet接口 607
22.1.7 JDBC-ODBC桥 607
22.2
一个
操作
数据
库的简单程序 608
22.2.1 程序的执行结果 608
22.2.2 程序设计与模块划分 609
22.2.3 准备好
数据
源 610
22.2.4
数据
库操作模块的实现 610
22.2.5 图形用户界面模块的实现 611
22.3 小结：强大的JDBC标准 613
22.4 习题 613
需求：定义
一个
Boss类，其
中
有
一个
属性
为
一个
泛型类
对象，通过
反射
获取
该对象的某个
属性
1 定义
一个
Boss类（getGeneraticTypeName
方法
用于
获取
泛型
T的名为“name”、“、age”的
属性
值
）：
package Reflect;
* @Classname Boss
* @Description TODO
* @Date 2022/5/4 14:20
* @Created by jiawe
public class Boss<T> {
通过外部文件配置，在不修改源码情况下，来控制程序，符合设计模式的ocp原则（开闭原则：不修改源码，开扩容功能）
2. 允许程序在执行期借助于ReflectionAPI取得任何类的内部信息，并能操作对象的
属性
及
方法
。
3. 实现：
加载完类之后，堆
中
产生
一个
Class类型对象，此对象包含了类的完整结构信息，通过这个对象得到类的结构，从而实现调用类。
5.
反射
机制的功能：
5.1 运行时判断任意
一个
对象所属的类
5.2 运行时构造任意
一个
类的对象
5.3 运行时得到任意
Field[] declaredFields = xxxx.class.getDeclaredFields();
for (Field declaredField : declaredFields) {
declaredField.setAccessible(true);
//主要代码
Ty...
一、
泛型
的概念●所谓
泛型
，就是允许在定义类、接口时通过
一个
标识表示类
中
某个
属性
的类型或者是某个
方法
的返回
值
及参数类型。这个类型参数将在使用时(例如，继承或实现这个接口，用这个类型声明变量、创建对象时)确定(即传入实际的类型参数，也称为类型实参)。●从JDK1.5以后，
Java
引入 了“参数化类型( Parameterized type) ”的概念，允许我们在创建集合时再指定集合元素的类型，正如: ...
import org.apache.poi.ss.formula.functions.T;
import
java
.lang.reflect.ParameterizedType;
import
java
.lang.reflect.Type;
import
java
.lang.reflect.TypeVariable;
import
java
.lang.refl...
<groupId>commons-beanutils</groupId>
<artifactId>commons-beanutils</artifactId>
<version>1.9.3</version>
</dependency&g
