韩顺平循序渐进学Java零基础 第01-08章

Posted 2022-01-18 Spring-_-Bear

第01章 内容介绍

1. 内容介绍

2. 学习前的话

3. 就业方向

4. 开发场景

5. 应用领域

6. 内容梳理

第02章 Java概述

7. 程序举例

8. Java故事

9. Java特性

10. Sublime

11. Jdk介绍

• JVM 是一个虚拟的计算机，具有指令集并使用不同存储区域。负责执行指令，管理数据、内存、寄存器，包含在 JDK 中
• JDK = JRE + Java 开发工具（java、javac、javap、javadoc ······）
• JRE = JVM + Java 核心类库

12. 我的电脑

13. Jdk安装

14. 环境变量配置

15. Win7安装Jdk

16. Mac安装Jdk

17. 快速入门

18. 运行机制

19. 开发细节

20. 学习方法

21. 转义字符

22. 易犯错误

23. 注释介绍

24. 多行注释

25. 文档注释

26. 代码规范

27. DOS原理

28. 路径详解

29. DOS指令1

30. DOS指令2

31. DOS指令3

32. 本章作业1

33. 本章作业2

34. 内容梳理

第03章 变量

35. 变量原理

36. 变量概念

37. 变量入门

38. 变量细节

39. 加号使用

40. 数据类型

41. 整型使用

类型	字节数	范围
byte	1	-128 - 127
short	2	-32768 - 32767
int	4	-231 - 231-1
long	8	-263 - 263-1

42. 整型细节

43. 浮点数使用

类型	字节数	范围
float	4	-3.403E38 - 3.403E38
double	8	-1.798E308 - 1.798E308

• 浮点数组成：符号位 + 指数位 + 尾数位
• Java 浮点类型默认为 double 类型，定义 float 类型时需要在末尾加上 F 或 f

44. 浮点数细节1

45. 浮点数细节2

46. Java文档

47. 字符型使用

类型	字节数	范围
char	2	ISO 单一字符集

48. 字符型细节

49. 字符型本质

50. 常用编码

类型	字符占用字节数	汉字占用字节数
ASCII	1
Unicode	2	2
UTF - 8	1	3
GBK	1	2

51. 布尔类型

类型	字节数	范围
boolean	1	true or false

52. 自动类型转换基础

• char -> int -> long -> float -> double
• byte -> short -> int -> long -> float -> double

53. 自动类型转换基础细节1

• (byte，short) 和 char 之间不会自动类型转换
• byte、char、short 在进行运算时，当作 int 处理

54. 自动类型转换基础细节2

55. 强制类型转换基础

56. 强制类型转换细节

• char 类型可以保存 int 类型的常量值，但不能保存 int 型的变量值，需要强转

57. 类型转换练习

58. String和基本类型转换

59. String转基本类型细节

60. 本章作业1

61. 本章作业2

62. 本章小结

第04章 运算符

63. 算术运算符介绍

64. 算术运算符使用

int i = 1;
i = i++;
// output：1
System.out.println(i);

int i = 1;
i = ++i;
// output：2
System.out.println(i);

65. 算术运算符练习1

66. 算术运算符练习2

67. 算术运算符练习3

68. 算术运算符练习4

69. 关系运算符介绍

70. 关系运算符使用

71. 逻辑运算符介绍

72. 短路与逻辑与

73. 短路或逻辑或

74. 逻辑非逻辑异或

75. 逻辑运算符练习

76. 赋值运算符介绍

77. 赋值运算符细节

76. 三元运算符介绍

Object object = true ? new Integer(1) : new Double(2.0);
// 三元运算符需要看作一个整体，故输出 1.0；if - else 分支结构则输出 1
System.out.println(object);

79. 三元运算符细节
80. 三元运算符练习

81. 运算符优先级

运算顺序	操作符
	. () ; ,
R -> L	++ – ~ !
L -> R	* / %
L -> R	+ -
L -> R	<< >> >>>
L -> R	< > <= >= instanceof
L -> R	== !=
L -> R	&
L -> R	^
L -> R	|
L -> R	&&
L -> R	||
L -> R	? :
R -> L	= *= /= %=
R -> L	+= -= <<= >>=
R -> L	>>>= &= ^= |=

82. 标识符规则

83. 标识符练习

84. 标识符规范

85. 关键字保留字

• strictfp：strict float point (精确浮点) - strictfp关键字可应用于类、接口、方法。 使用 strictfp 关键字声明一个方法时，该方法中所有的 float 和 double 表达式都严格遵守 FP-strict 的限制，符合 IEEE-754 规范
• volatile 是 jvm 提供的轻量级同步机制。作用是: 1. 保证可见性 2. 禁止指令重排 3. 不保证原子性

86. 键盘输入

87. 四种进制介绍

88. 2进制转10进制

89. 8进制转10进制

90. 16进制转10进制

91. 10进制转2进制

92. 10进制转8进制

93. 10进制转16进制

94. 2进制转8进制

95. 2进制转16进制

96. 8进制转2进制

97. 16进制转2进制

98. 位运算思考题

99. 原码、反码和补码

100. 位运算详解1

101. 位运算详解2

• 算术右移：>> ：低位丢弃，符号位不变，高位补符号位
• 算术左移：<< ：符号位不变，低位补0
• 无符号右移：>> ：低位丢弃，高位补 0

102. 本章作业

103. 内容梳理

第05章 程序控制结构

104. 顺序控制

105. 单分支使用

106. 单分支流程图

107. 双分支使用

108. 双分支流程图

109. 双分支练习题

110. 多分支使用

111. 多分支练习1

112. 多分支练习2

113. 嵌套分支

114. 嵌套分支课后练习

115. switch基本语法

116. switch流程图

117. switch快速入门

118. switch细节

• switch 的 case 后跟常量或常量表达式，switch 中的表达式只能是以下类型中的一种：byte、short、char、int、enum、String

119. switch课堂练习1

120. switch课堂练习2

121. switch和if选择

122. for基本语法

123. for执行流程

124. for细节

125. for编程思想1

126. for编程思想2

127. while基本语法

128. while执行流程

129. while课堂练习

130. do-while语法

131. do-while执行流程

132. do-while练习1

133. do-while练习2

134. 多重循环执行流程

135. 多重循环练习1

136. 多重循环练习2

137. 空心金字塔

138. break需求

139. break执行流程

140. break快速入门

141. break细节

142. break课堂练习1

143. break课堂练习2

144. continue执行流程

145. continue快速入门

146. continue细节

147. return使用说明

148. 本章作业1

149. 本章作业2

150. 本章作业3

151. 本章作业4

152. 本章作业5

153. 本章作业6

154. 内容梳理

155. 听懂和会做

第06章 数组、排序和查找

156. 数组必要性

157. 数组快速入门

• 数组是引用类型，创建数组时使用了 new 关键字

158. 数组使用1

159. 数组使用2

160. 数组使用3

• 数组静态初始化

int[] array = 2,54,3,23;

161. 数组注意事项

• 创建数组后，若没有赋值，则有默认值

int[] a = new int[3];
// output: [0, 0, 0]
System.out.println(Arrays.toString(a));

162. 数组练习1

163. 数组练习2

164. 数组赋值机制1

• 基本数据类型赋值，赋值的是具体的数据
• 引用类型赋值，传递的是数组的地址

165. 数组赋值机制2

166. 数组拷贝

167. 数组翻转1

168. 数组翻转2

169. 数组扩容1

170. 数组扩容2

171. 数组缩减

172. 排序介绍

• 内部排序：将需要处理的所有数据都加载到内部存储器中进行排序（交换式排序法、选择式排序法和插入式排序法）
• 外部排序：数据量过大，无法全部加载到内存中，需要借助外部存储进行排序（合并排序法和直接合并排序法）

173. 冒泡排序思路

174. 冒泡排序实现

175. 查找

176. 二维数组入门

177. 二维数组内存布局

178. 二维数组使用1

179. 二维数组使用2

• Java 中二维数组每行的元素个数可以不一致

int[][] array = new int[3][];
array[0] = new int[3];
array[1] = new int[2];
array[2] = new int[6];

180. 二维数组使用3

181. 二维数组练习1

182. 杨辉三角

183. 二维数组细节

184. 二维数组练习2

185. 本章作业1

186. 本章作业2

187. 本章作业3

188. 本章作业4

189. 本章作业5

190. 内容梳理

191. 专业和编程

第07章 面向对象编程(基础部分)

192. 类与对象引出

193. 类与对象概述

194. 面向对象快速入门

195. 对象内存布局

196. 属性概念

197. 属性注意细节

198. 创建对象访问属性

199. 对象分配机制

200. 对象创建过程

• 栈：一般存放基本数据类型（局部变量）
• 堆：存放对象（数组）
• 方法区：常量池（字符串）、类加载信息

201. 对象机制练习

202. 方法快速入门1

203. 方法快速入门2

204. 方法调用机制

205. 方法的妙用

206. 方法的定义

207. 方法的使用细节1

208. 方法的使用细节2

209. 方法的使用细节3

210. 方法练习题1

211. 方法传参机制1

212. 方法传参机制2

213. 方法传参机制3

214. 克隆对象

215. 递归解决什么问题

216. 递归执行机制1

217. 递归执行机制2

218. 递归执行机制3

219. 递归执行机制4

220. 递归斐波那契

221. 猴子吃桃

222. 老鼠出迷宫1

223. 老鼠出迷宫2

224. 老鼠出迷宫3

225. 老鼠出迷宫4

226. 汉诺塔

227. 八皇后

228. 重载介绍

229. 重载快速入门

230. 重载使用细节

• 方法重载方法签名必须不同，返回值不是方法签名的一部分

231. 重载课堂练习1

232. 重载课堂练习2

233. 重载课堂练习3

234. 可变参数使用

235. 可变参数细节

• 可变参数的实参可以是 0 个或是多个，其本质就是数组
• 形参列表中可以同时有普通形参和可变参数，但必须保证可变参数是形参列表的最后一个参数
• 一个方法的形参列表只能出现一个可变参数

236. 可变参数练习

237. 作用域基本使用

• 类的属性有默认值，局部变量没有默认值

238. 作用域使用细节1

239. 作用域使用细节2

240. 构造器基本介绍

241. 构造器快速入门

242. 构造器使用细节1

• 构造器完成对象的初始化，并不是创建对象；调用构造器时堆中已经分配了对象的空间，构造器只是负责对对象进行初始化

243. 构造器使用细节2

244. 构造器课堂练习

245. 对象创建流程详解

1. 加载类信息，生成 .class 对象
2. 在堆中为对象分配空间
3. 完成对象的默认初始化
4. 构造器完成对象的初始化

246. 引出this

247. this入门

• JVM 会给每个对象分配 this，代表当前对象；哪个对象调用，this 指向它

248. this本质

249. this小结

250. this使用细节

• this 不能在类定义的外部使用，只能在类定义的方法中使用

251. this课堂练习

252. 本章作业1

253. 本章作业2

254. 本章作业3

255. 本章作业4

256. 本章作业5

257. 本章作业6

258. 本章作业7

259. 本章作业8

260. 本章作业9

261. 本章作业10

262. 本章作业11

263. 内容梳理

第08章 面向对象编程(中级部分)

264. IDEA介绍

265. IDEA下载安装

266. IDEA使用1

267. IDEA使用2

268. IDEA使用3

269. IDEA快捷键1

• 自动补全 alt + /
• 查看类结构：ctrl + H

270. IDEA快捷键2

271. IDEA快捷键3

272. IDEA模板

273. 包基本结束

274. 包原理

275. 包快速入门

276. 包命名

277. 常用的包

278. 包的使用细节

279. 访问修饰符规则

• 修饰符只能用来修饰类或类的成员

280. 访问修饰符细节

281. 封装介绍

282. 封装步骤

283. 封装快速入门

284. 封装与构造器

285. 封装课堂练习

286. 为什么需要继承

287. 继承原理图

288. 继承快速入门

289. 继承使用细节1

• 子类继承了父类所有的方法和属性，但父类的私有属性不能在子类中直接访问

290. 继承使用细节2

• 当创建子类的对象时，无论使用子类的哪个构造器，默认情况下总会去调用父类的无参构造器，如果父类没有提供无参构造器，则必须在子类中使用 super 去显式调用父类的构造器完成父类的初始化工作，否则编译不会通过

291. 继承使用细节3

• super() 和 this() 都只能放在构造器的第一行，因此这两个方法不能同时存在一个构造器中

292. 继承使用细节4

• Object 类的所有方法

293. 继承使用细节5

294. 继承本质详解

295. 继承课堂练习1

296. 继承课堂练习2

297. 继承课堂练习3

298. super基本语法

• super 代表父类的引用，用于访问父类的属性、方法、构造器
• 使用 super 不能访问父类的 private 成员

299. super使用细节1

300. super使用细节2

301. super使用细节3

区别点	this	super
方法	访问本类属性，没有则依次查找父类	直接依次查找父类属性
属性	访问本类方法，没有则依次查找父类	直接依次查找父类方法
构造器	行首调用本类其它构造器	行首调用父类指定构造器
特殊	表示当前对象	表示子类中访问父类的对象

302. 方法重写介绍

303. 方法重写细节

• 子类重写父类的方法时，返回类型可以是父类返回类型的子类
• 子类不能缩小父类方法的访问权限

304. 重写课堂练习1

305. 重写课堂练习2

306. 养宠物引出多态

307. 方法的多态

• 重载与重写也体现了多态

308. 对象的多态

309. 多态快速入门

310. 向上转型

311. 向下转型

312. 属性重写问题

313. 多态课堂练习1

314. 多态课堂练习2

315. 动态绑定机制

• 当调用对象方法的时候，该方法会和该对象的内存地址 / 运行类型动态绑定
• 当调用对象属性时，不存在动态绑定，在哪儿声明在哪使用

316. 多态数组1

317. 多态数组2

318. 多态参数

319. 运算符

	作用
==	判断基本类型时判断值是否相等；判断引用类型时判断是否引用到同一个对象
equals()	只能判断引用类型是否引用到同一个对象，子类往往重写

320. 查看Jdk源码

321. 子类重写equals

322. equals课堂练习1

323. equals课堂练习2

324. equals课堂练习3

325. hashCode

   /**
    * Returns a hash code value for the object. This method is
    * supported for the benefit of hash tables such as those provided by
    * @link java.util.HashMap.
    * <p>
    * The general contract of @code hashCode is:
    * <ul>
    * <li>Whenever it is invoked on the same object more than once during
    *     an execution of a Java application, the @code hashCode method
    *     must consistently return the same integer, provided no information
    *     used in @code equals comparisons on the object is modified.
    *     This integer need not remain consistent from one execution of an
    *     application to another execution of the same application.
    * <li>If two objects are equal according to the @code equals(Object)
    *     method, then calling the @code hashCode method on each of
    *     the two objects must produce the same integer result.
    * <li>It is <em>not</em> required that if two objects are unequal
    *     according to the @link java.lang.Object#equals(java.lang.Object)
    *     method, then calling the @code hashCode method on each of the
    *     two objects must produce distinct integer results.  However, the
    *     programmer should be aware that producing distinct integer results
    *     for unequal objects may improve the performance of hash tables.
    * </ul>
    * <p>
    * As much as is reasonably practical, the hashCode method defined by
    * class @code Object does return distinct integers for distinct
    * objects. (This is typically implemented by converting the internal
    * address of the object into an integer, but this implementation
    * technique is not required by the
    * Java&trade; programming language.)
    *
    * @return  a hash code value for this object.
    * @see     java.lang.Object#equals(java.lang.Object)
    * @see     java.lang.System#identityHashCode
    */
   public native int hashCode();

326. toString

   /**
    * Returns a string representation of the object. In general, the
    * @code toString method returns a string that
    * "textually represents" this object. The result should
    * be a concise but informative representation that is easy for a
    * person to read.
    * It is recommended that all subclasses override this method.
    * <p>
    * The @code toString method for class @code Object
    * returns a string consisting of the name of the class of which the
    * object is an instance, the at-sign character `@code @', and
    * the unsigned hexadecimal representation of the hash code of the
    * object. In other words, this method returns a string equal to the
    * value of:
    * <blockquote>
    * <pre>
    * getClass().getName() + '@' + Integer.toHexString(hashCode())
    * </pre></blockquote>
    *
    * @return  a string representation of the object.
    */
   public String toString() 
       return getClass().getName() + "@" + Integer.toHexString(hashCode());
   

327. finalize

   /**
    * Called by the garbage collector on an object when garbage collection
    * determines that there are no more references to the object.
    * A subclass overrides the @code finalize method to dispose of
    * system resources or to perform other cleanup.
    * <p>
    * The general contract of @code finalize is that it is invoked
    * if and when the Java&trade; virtual
    * machine has determined that there is no longer any
    * means by which this object can be accessed by any thread that has
    * not yet died, except as a result of an action taken by the
    * finalization of some other object or class which is ready to be
    * finalized. The @code finalize method may take any action, including
    * making this object available again to other threads; the usual purpose
    * of @code finalize, however, is to perform cleanup actions before
    * the object is irrevocably discarded. For example, the finalize method
    * for an object that represents an input/output connection might perform
    * explicit I/O transactions to break the connection before the object is
    * permanently discarded.
    * <p>
    * The @code finalize method of class @code Object performs no
    * special action; it simply returns normally. Subclasses of
    * @code Object may override this definition.
    * <p>
    * The Java programming language does not guarantee which thread will
    * invoke the @code finalize method for any given object. It is
    * guaranteed, however, that the thread that invokes finalize will not
    * be holding any user-visible synchronization locks when finalize is
    * invoked. If an uncaught exception is thrown by the finalize method,
    * the exception is ignored and finalization of that object terminates.
    * <p>
    * After the @code finalize method has been invoked for an object, no
    * further action is taken until the Java virtual machine has again
    * determined that there is no longer any means by which this object can
    * be accessed by any thread that has not yet died, including possible
    * actions by other objects or classes which are ready to be finalized,
    * at which point the object may be discarded.
    * <p>
    * The @code finalize method is never invoked more than once by a Java
    * virtual machine for any given object.
    * <p>
    * Any exception thrown by the @code finalize method causes
    * the finalization of this object to be halted, but is otherwise
    * ignored.
    *
    * @throws Throwable the @code Exception raised by this method
    * @see java.lang.ref.WeakReference
    * @see java.lang.ref.PhantomReference
    * @jls 12.6 Finalization of Class Instances
    */
   protected void finalize() throws Throwable  

328. 断点调试介绍

329. 断点调试案例1

330. 断点调试案例2

331. 断点调试案例3

332. 断点调试案例4

333. 断点调试案例5

334. 断点调试案例6

335. 零钱通介绍

336. 零钱通菜单

337. 零钱通明细

338. 零钱通收益

339. 零钱通消费

340. 零钱通退出确认

341. 零钱通金额校验

342. 零钱通OPP版

343. 本章作业1

344. 本章作业2

345. 本章作业3

346. 本章作业4

347. 本章作业5

348. 本章作业6

349. 本章作业7

350. 本章作业8

351. 本章作业9

352. 本章作业10

353. 本章作业11

354. 本章作业12

355. 本章作业13

356. 本章作业14

357. 本章作业15

358. 本章作业16

359. 本章作业17

360. 内容梳理

361. 不要让堕性毁了你