零基础学Java 第4版

零基础学Java 第4版

暂无评价综合评分的显示会考虑用户真实性等多项因素,每部作品出现综合评分的时间不定。
免费试读
¥30.00¥12.99
今日特价截止至:2019-07-19 02:00:00了解详情

作品简介

Java是目前最流行的开发语言之一,也是目前提供职位最多的开发语言之一。本书站在零基础学习的角度,使初学者能尽快掌握Java语言程序设计的精髓而少走弯路。

本书一共分为四篇,共25章,循序渐进地讲述了Java语言的语法规则,以及Eclipse和MyEclipse开发环境的使用,从基本概念到具体实践、从入门知识到高阶主题、从语法语义到数据结构和算法都进行了详细的阐述,内容主要包括运算符、表达式、分支语句、循环语句、函数、数组、字符串、类、对象、包、继承、多态、封装、枚举、反射、标注、泛型、类加载器、动态代理、多线程、文件的操作和访问、数据的操作、数据的存储、Java数据结构、XML文件的创建和解析、数据库的连接、网络编程和界面的设计等知识点。

本书非常适合Java语言的初、中级学习者阅读,并可作为开发人员的参考手册。

作品目录

  1. 零基础学Java 第4版
  2. 前 言
  3. 第一篇 Java语言语法基础——面向过程知识
  4. 第1章 Java技术概览
  5. 1.1 Java技术
  6. 1.1.1 认识Java语言
  7. 1.1.2 认识Java平台
  8. 1.1.3 Java语言的功能
  9. 1.1.4 Java语言的优点
  10. 1.1.5 Java分布式应用和多线程的特点
  11. 1.1.6 Java程序的可靠性、安全性
  12. 1.1.7 Java小程序和应用程序
  13. 1.2 Windows下的“HelloWorld”应用程序
  14. 1.2.1 创建应用程序的软件环境
  15. 1.2.2 创建“HelloWorld”应用程序的步骤
  16. 1.3 深入探讨“HelloWorld”应用程序
  17. 1.3.1 注释源代码
  18. 1.3.2 实现类定义
  19. 1.3.3 详解main()方法
  20. 1.4 常见疑难解答
  21. 1.4.1 环境变量设置错误
  22. 1.4.2 语法错误
  23. 1.4.3 语义错误
  24. 1.4.4 运行时错误
  25. 1.4.5 初学者如何选择Java参考书
  26. 1.5 小结
  27. 1.6 习题
  28. 第2章 Java开发工具及环境设置
  29. 2.1 Java开发工具简介
  30. 2.1.1 下载并安装JDK
  31. 2.1.2 设定环境变量
  32. 2.1.3 验证JDK环境是否配置成功
  33. 2.2 JDK内置工具
  34. 2.2.1 JDK常用工具
  35. 2.2.2 JDK常用工具的使用实例
  36. 2.2.3 Java应用程序的发布工具
  37. 2.3 一个简单的Java应用程序
  38. 2.4 一个简单的Java Applet应用程序
  39. 2.4.1 编写一个Java Applet
  40. 2.4.2 编写承载Java Applet的HTML文件
  41. 2.4.3 Java Applet运行过程
  42. 2.5 Java程序员的编码规则
  43. 2.6 常见疑难解答
  44. 2.6.1 Java文件扩展名是否区分大小写
  45. 2.6.2 Javac xxx.java顺利通过,但Java xxx显示 “NoClassDefFoundError”
  46. 2.6.3 导致错误“Exception in thread main java.lang.NoSuchMethodError:main”的原因
  47. 2.7 小结
  48. 2.8 习题
  49. 第3章 Java语言中的数据类型与运算符
  50. 3.1 数制
  51. 3.1.1 基本概念
  52. 3.1.2 Java语言中的数制表现形式
  53. 3.2 数据类型
  54. 3.2.1 整型
  55. 3.2.2 字符型
  56. 3.2.3 浮点型
  57. 3.2.4 布尔型
  58. 3.3 变量
  59. 3.3.1 变量的声明
  60. 3.3.2 变量的含义
  61. 3.3.3 变量的分类
  62. 3.4 变量如何初始化
  63. 3.5 常量
  64. 3.6 运算符
  65. 3.6.1 算术运算符
  66. 3.6.2 关系运算符
  67. 3.6.3 逻辑运算符
  68. 3.6.4 位运算符
  69. 3.6.5 移位运算符
  70. 3.6.6 赋值运算符
  71. 3.6.7 三元运算符
  72. 3.6.8 逗号运算符
  73. 3.6.9 转型运算符
  74. 3.6.10 运算符的优先级别
  75. 3.7 常见疑难解答
  76. 3.7.1 如何将十进制转换成二进制
  77. 3.7.2 转型运算符会引起精度问题,为什么还要使用它
  78. 3.8 小结
  79. 3.9 习题
  80. 第4章 程序设计中的流程控制
  81. 4.1 编程风格
  82. 4.2 条件语句
  83. 4.2.1 简单条件语句
  84. 4.2.2 最简单的条件语句
  85. 4.2.3 适应多条件的条件语句
  86. 4.2.4 嵌套条件语句
  87. 4.2.5 如何使用条件语句
  88. 4.3 循环语句
  89. 4.3.1 for循环语句
  90. 4.3.2 while循环
  91. 4.3.3 do…while语句
  92. 4.4 中断与继续语句
  93. 4.4.1 中断控制语句
  94. 4.4.2 继续语句
  95. 4.5 分支语句
  96. 4.6 返回语句
  97. 4.7 常见疑难解答
  98. 4.7.1 普通循环是使用for语句还是while语句
  99. 4.7.2 一般的程序可否用分支语句来代替条件语句
  100. 4.8 小结
  101. 4.9 习题
  102. 第二篇 Java语言语法进阶——面向对象知识
  103. 第5章 数 组
  104. 5.1 数组概念的引入
  105. 5.1.1 实例的引入
  106. 5.1.2 数组的概念
  107. 5.1.3 用实例说明数组的用处
  108. 5.2 基本数据类型的数组
  109. 5.2.1 基本类型数组的声明
  110. 5.2.2 基本类型数组的初始化
  111. 5.3 由实例引出不同数组种类及其使用
  112. 5.3.1 认识一维数组
  113. 5.3.2 由实例引出一维数组及其使用
  114. 5.3.3 由实例引出二维数组及其使用
  115. 5.4 多维数组
  116. 5.4.1 多维数组的声明
  117. 5.4.2 初始化多维数组
  118. 5.4.3 使用多维数组
  119. 5.5 数组的综合实例
  120. 5.6 常见疑难解答
  121. 5.6.1 声明数组需要注意什么
  122. 5.6.2 数组在平时的程序代码中使用是否频繁
  123. 5.7 小结
  124. 5.8 习题
  125. 第6章 字符串的处理
  126. 6.1 认识字符串
  127. 6.1.1 代码中的字符串
  128. 6.1.2 String类和StringBuffer类的比较
  129. 6.2 字符串处理的类库种类
  130. 6.2.1 字符串的赋值
  131. 6.2.2 字符串处理类——String
  132. 6.2.3 字符串处理的方法
  133. 6.2.4 缓冲字符串处理类——StringBuffer
  134. 6.2.5 缓冲字符串StringBuffer类的构造器
  135. 6.2.6 缓冲字符串的处理
  136. 6.2.7 缓冲字符串类的特点
  137. 6.3 用实例演示如何处理字符串
  138. 6.4 如何格式化输出字符串
  139. 6.5 常见疑难解答
  140. 6.5.1 equals和“==”的区别
  141. 6.5.2 String类为何被定义成final约束
  142. 6.5.3 char类型如何转换成int类型,int类型如何转换成字符串
  143. 6.6 小结
  144. 6.7 习题
  145. 第7章 类 和 对 象
  146. 7.1 面向对象开发中的类
  147. 7.1.1 在Java中类的定义
  148. 7.1.2 Java中的类与现实世界的类
  149. 7.2 万事万物皆对象
  150. 7.2.1 什么是对象
  151. 7.2.2 操作对象
  152. 7.2.3 初始化对象
  153. 7.2.4 对象的成员方法
  154. 7.2.5 对象的成员变量
  155. 7.3 对象中访问控制符的重要性
  156. 7.3.1 什么是访问控制符
  157. 7.3.2 如何使用访问控制符及其重要性
  158. 7.4 Java中的基础类
  159. 7.4.1 Java的数学运算处理类Math
  160. 7.4.2 测试时间和日期的类Date
  161. 7.4.3 测试日历的类GregorianCalendar
  162. 7.4.4 日历处理的实例解析
  163. 7.5 用实例分析设计一个类的流程
  164. 7.5.1 如何在现实程序设计中提取一个类
  165. 7.5.2 设置器和访问器
  166. 7.5.3 总结
  167. 7.6 常见疑难解答
  168. 7.6.1 类在程序语言中起到了什么作用
  169. 7.6.2 设置器和访问器的作用
  170. 7.7 小结
  171. 7.8 习题
  172. 第8章 重 载 和 包
  173. 8.1 重载
  174. 8.1.1 什么是重载
  175. 8.1.2 用实例来说明重载的意义
  176. 8.2 包
  177. 8.2.1 什么是Java中的包
  178. 8.2.2 如何实现包
  179. 8.2.3 什么是类路径和默认包
  180. 8.2.4 包的作用域
  181. 8.2.5 静态导入
  182. 8.3 包的注释及嵌入文档
  183. 8.3.1 如何添加注释
  184. 8.3.2 类、方法、字段等注释的方法
  185. 8.4 常见疑难解答
  186. 8.4.1 包在实际编程中究竟有什么作用
  187. 8.4.2 一个文件中定义了两个class类是否生成一个.class文件
  188. 8.5 小结
  189. 8.6 习题
  190. 第9章 继承和多态
  191. 9.1 什么是继承
  192. 9.1.1 继承的引出
  193. 9.1.2 继承的概念
  194. 9.1.3 如何实现继承
  195. 9.1.4 如何设计继承
  196. 9.2 构造函数的使用
  197. 9.2.1 什么是构造函数
  198. 9.2.2 继承中构造函数的初始化
  199. 9.2.3 替代父类和本身的方式
  200. 9.2.4 Java中的单继承性
  201. 9.3 继承中的覆盖现象
  202. 9.4 类之间的关系
  203. 9.4.1 依赖
  204. 9.4.2 聚合
  205. 9.4.3 继承
  206. 9.5 继承层次图
  207. 9.6 多态
  208. 9.6.1 多态的产生
  209. 9.6.2 多态的概念
  210. 9.6.3 使用多态编写程序
  211. 9.6.4 覆盖的应用
  212. 9.6.5 重载与覆盖的实例对比
  213. 9.6.6 覆盖的多态性
  214. 9.6.7 传值引用和传址引用
  215. 9.7 通过实例熟悉多态用法
  216. 9.8 绑定
  217. 9.8.1 静态绑定
  218. 9.8.2 动态绑定
  219. 9.9 超类
  220. 9.9.1 什么是超类
  221. 9.9.2 equals方法的使用
  222. 9.9.3 通用编程
  223. 9.10 常见疑难解答
  224. 9.10.1 Java不支持多继承,如何处理一个类继承多个父类的情况
  225. 9.10.2 如果出现了带参数的构造函数,可否不在代码中写出来
  226. 9.10.3 动态和静态编译是什么
  227. 9.10.4 绑定与多态的联系是什么
  228. 9.10.5 多态与重载的区别是什么
  229. 9.11 小结
  230. 9.12 习题
  231. 第10章 接口与内部类
  232. 10.1 接口
  233. 10.1.1 接口概念的引入
  234. 10.1.2 接口的声明
  235. 10.1.3 接口的实现
  236. 10.1.4 接口的多重实现
  237. 10.1.5 接口的属性
  238. 10.1.6 接口的继承
  239. 10.2 内部类
  240. 10.2.1 使用内部类来访问对象
  241. 10.2.2 局部内部类
  242. 10.2.3 静态内部类
  243. 10.2.4 匿名内部类
  244. 10.3 常见疑难解答
  245. 10.3.1 匿名类如何在程序中使用
  246. 10.3.2 接口与继承有什么区别
  247. 10.4 小结
  248. 10.5 习题
  249. 第11章 抽象和封装
  250. 11.1 抽象的概念
  251. 11.1.1 什么是抽象
  252. 11.1.2 抽象的综合实例
  253. 11.2 抽象类
  254. 11.2.1 什么是抽象类
  255. 11.2.2 抽象类的实例
  256. 11.3 抽象与接口的区别
  257. 11.4 枚举
  258. 11.4.1 关于枚举的实现原理
  259. 11.4.2 枚举的简单应用
  260. 11.4.3 关于枚举的高级特性
  261. 11.5 反射
  262. 11.5.1 关于反射的基石——Class类
  263. 11.5.2 关于反射的基本应用
  264. 11.5.3 关于反射的高级应用
  265. 11.6 标注
  266. 11.6.1 标注的简单使用
  267. 11.6.2 关于JDK的内置标注
  268. 11.7 泛型
  269. 11.7.1 为什么要使用泛型
  270. 11.7.2 关于泛型的一些特性
  271. 11.7.3 关于泛型的通配符
  272. 11.8 类加载器
  273. 11.8.1 什么是类加载器
  274. 11.8.2 什么是类加载器的委派模型
  275. 11.9 动态代理
  276. 11.9.1 什么是代理
  277. 11.9.2 关于动态代理基础类
  278. 11.9.3 关于InvocationHandler接口
  279. 11.9.4 动态代理类的设计模式
  280. 11.10 封装的概念
  281. 11.10.1 一个封装的例子
  282. 11.10.2 在程序设计中为什么要使用封装
  283. 11.10.3 在程序设计中设计封装的注意点
  284. 11.11 结合实例讲述如何设计封装
  285. 11.12 常见疑难解答
  286. 11.12.1 抽象类和接口在概念上有什么区别
  287. 11.12.2 如何从设计理念上看待抽象类和接口
  288. 11.12.3 封装在现实开发中给程序员带来什么启发
  289. 11.12.4 封装在实际开发中的应用有哪些
  290. 11.13 小结
  291. 11.14 习题
  292. 第三篇 Java语言编程主题
  293. 第12章 线 程
  294. 12.1 线程的基本概念
  295. 12.1.1 进程及其使用环境
  296. 12.1.2 线程及其使用环境
  297. 12.2 线程的创建
  298. 12.2.1 如何创建线程
  299. 12.2.2 通过实例熟悉如何创建线程
  300. 12.2.3 线程的状态
  301. 12.3 线程的使用
  302. 12.3.1 线程的优先级
  303. 12.3.2 线程的休眠与唤醒
  304. 12.3.3 线程让步
  305. 12.3.4 线程同步
  306. 12.3.5 同步块
  307. 12.3.6 同步化方法
  308. 12.4 实例分析
  309. 12.4.1 生产者与消费者的程序设计及分析
  310. 12.4.2 多消费者的程序设计及分析
  311. 12.4.3 多生产者的程序设计及分析
  312. 12.5 常见疑难解答
  313. 12.5.1 Java中线程与线程之间怎么通信
  314. 12.5.2 什么是进程的死锁和饥饿
  315. 12.5.3 什么时候会涉及线程程序
  316. 12.5.4 多线程的死锁问题
  317. 12.5.5 多线程的缺点
  318. 12.6 小结
  319. 12.7 习题
  320. 第13章 异常的处理与内存的管理
  321. 13.1 异常的概念
  322. 13.1.1 异常的分类
  323. 13.1.2 异常的声明
  324. 13.1.3 异常的抛出throw
  325. 13.2 异常的捕获
  326. 13.2.1 捕获多个异常
  327. 13.2.2 自定义异常
  328. 13.2.3 运行期异常
  329. 13.2.4 执行finally子句
  330. 13.2.5 finally子句的必要性
  331. 13.3 内存的管理和回收
  332. 13.4 常见疑难解答
  333. 13.4.1 为什么要声明方法抛出异常
  334. 13.4.2 为什么抛出的异常一定是检查异常
  335. 13.5 小结
  336. 13.6 习题
  337. 第14章 Java输入与输出
  338. 14.1 输入与输出的重要性
  339. 14.2 Java重要的输入输出类
  340. 14.3 文件或目录信息的处理
  341. 14.3.1 File类常用的操作方法
  342. 14.3.2 文件处理方法的应用
  343. 14.3.3 文件和目录的操作
  344. 14.4 读取数据的媒介之一——流
  345. 14.4.1 什么是流
  346. 14.4.2 什么是输入流和输出流
  347. 14.4.3 字节输入流及输出流
  348. 14.4.4 使用文件字节输入流读取文件
  349. 14.4.5 使用文件字节输出流输出文件
  350. 14.5 多字节数据读取类——Filter类
  351. 14.5.1 Filter流的概念
  352. 14.5.2 处理字节类型以外的文件输入
  353. 14.5.3 处理字节类型以外的文件输出
  354. 14.5.4 增强的多字节输出流DataOutput
  355. 14.5.5 增强的多字节输入流DataInput
  356. 14.6 读取数据的媒介之二——字符流
  357. 14.6.1 字符流的概念
  358. 14.6.2 抽象字符输入流Reader类的使用
  359. 14.6.3 抽象字符输出流Writer类的使用
  360. 14.6.4 读取带缓存的BufferedReader字符流
  361. 14.6.5 带缓存的字符输出流BufferedWriter类
  362. 14.6.6 字符输入流FileReader类和FileWriter类的使用
  363. 14.6.7 如何用标准输入流System.in来获取数据
  364. 14.6.8 打印输入流PrintWriter类与PrintStream类的区别
  365. 14.6.9 随机文件访问RandomAccessFile类
  366. 14.7 利用对象序列化控制输入输出
  367. 14.7.1 什么是对象序列化
  368. 14.7.2 基本数据和对象数据读写ObjectInput接口与ObjectOutput接口
  369. 14.7.3 对象序列化处理ObjectOutputStream类
  370. 14.7.4 对象序列化处理ObjectInputStream类
  371. 14.8 常见疑难解答
  372. 14.8.1 字节流与字符流的主要区别
  373. 14.8.2 输入流与输出流如何区分,各有什么作用
  374. 14.8.3 什么是管道流
  375. 14.9 小结
  376. 14.10 习题
  377. 第15章 Java中对数据的处理
  378. 15.1 如何将基本数据类型转换为对象
  379. 15.1.1 为什么要将基本数据转换为对象
  380. 15.1.2 Wrapper类的构造函数
  381. 15.1.3 包装类的常用函数
  382. 15.1.4 基本数据的拆装箱操作
  383. 15.2 如何处理随机性的数据
  384. 15.2.1 Random类的基础知识
  385. 15.2.2 通过实例熟悉Random类的常用方法
  386. 15.3 如何对数据进行排列、整理
  387. 15.3.1 Arrays类的常用方法
  388. 15.3.2 实例分析
  389. 15.4 常见疑难解答
  390. 15.4.1 Random类函数在现实生活中有什么用处
  391. 15.4.2 数组的排列和整理数据在实际应用中有什么用处
  392. 15.5 小结
  393. 15.6 习题
  394. 第16章 数据结构接口
  395. 16.1 数据结构接口及实现
  396. 16.1.1 数据结构接口的实质
  397. 16.1.2 用实例来熟悉数据结构接口的实现
  398. 16.2 Collection集合接口与Iterator迭代器接口
  399. 16.2.1 熟悉Collection集合接口
  400. 16.2.2 List接口和Set接口
  401. 16.2.3 Map映射接口
  402. 16.2.4 Iterator迭代器接口
  403. 16.2.5 通过实例来认识迭代器的实现
  404. 16.3 常见疑难解答
  405. 16.3.1 Collection集合接口和Collections集合类的区别
  406. 16.3.2 ArrayList数组列表类和Vector存储类的区别
  407. 16.3.3 HashMap散列映射和Hashtable散列表的区别
  408. 16.3.4 数据结构的种类有哪些
  409. 16.3.5 List接口和Set接口的区别
  410. 16.4 小结
  411. 16.5 习题
  412. 第17章 Java中的数据结构
  413. 17.1 链表
  414. 17.1.1 什么是Java中的链表
  415. 17.1.2 用程序代码段实现对链表的添加
  416. 17.1.3 用程序代码段实现对链表的删除
  417. 17.2 数组列表类
  418. 17.2.1 什么是数组列表类
  419. 17.2.2 通过实例熟悉数组列表如何存储数据
  420. 17.3 散列表
  421. 17.3.1 什么是散列表
  422. 17.3.2 通过实例熟悉散列表如何存储数据
  423. 17.4 散列集
  424. 17.4.1 什么是散列集
  425. 17.4.2 通过实例熟悉散列集如何存储数据
  426. 17.5 树集
  427. 17.5.1 什么是树集
  428. 17.5.2 通过实例熟悉树集如何存储数据
  429. 17.6 映像
  430. 17.6.1 什么是映像
  431. 17.6.2 通过实例熟悉映像如何存储数据
  432. 17.7 常见疑难解答
  433. 17.7.1 哪些是线程安全的数据结构
  434. 17.7.2 Vector是什么样的数据结构
  435. 17.8 小结
  436. 17.9 习题
  437. 第18章 XML基础
  438. 18.1 XML和HTML
  439. 18.1.1 XML的产生
  440. 18.1.2 XML与HTML的比较
  441. 18.2 XML的编辑工具
  442. 18.3 创建XML文档
  443. 18.3.1 XML的声明
  444. 18.3.2 文档类型的声明
  445. 18.3.3 元素
  446. 18.3.4 注释
  447. 18.3.5 处理指令
  448. 18.3.6 空白处理
  449. 18.3.7 行尾处理
  450. 18.3.8 语言标识
  451. 18.3.9 一个简单的有关XML的实例
  452. 18.4 关于XML的高级知识
  453. 18.4.1 什么才是格式良好的XML文档
  454. 18.4.2 DTD文档的作用
  455. 18.4.3 DTD的结构
  456. 18.4.4 几个有关DTD的简单实例
  457. 18.5 关于XML文档的操作
  458. 18.5.1 下载Dom4J组件
  459. 18.5.2 安装和配置Dom4J组件
  460. 18.5.3 Dom4J组件的简单使用——解析XML文件
  461. 18.5.4 Dom4J组件的简单使用——创建XML文件
  462. 18.6 关于XML文档的高级操作
  463. 18.6.1 下载Sax类库
  464. 18.6.2 安装和配置Sax组件
  465. 18.6.3 Sax组件的简单使用——解析XML文件
  466. 18.7 常见疑难解答
  467. 18.7.1 XML与HTML的区别
  468. 18.7.2 XML有哪些显示数据的方式
  469. 18.8 小结
  470. 18.9 习题
  471. 第19章 开发工具的使用
  472. 19.1 Eclipse简介
  473. 19.1.1 下载并安装Eclipse
  474. 19.1.2 Eclipse界面介绍
  475. 19.2 如何使用Eclipse进行开发
  476. 19.2.1 如何新建一个Java工程
  477. 19.2.2 如何新建一个Java类
  478. 19.2.3 编写代码
  479. 19.3 如何使用MyEclipse进行开发
  480. 19.3.1 下载并安装MyEclipse
  481. 19.3.2 关于MyEclipse的一些常用操作
  482. 19.4 常见疑难解答
  483. 19.4.1 Eclipse和UltraEdit两个开发工具的优缺点
  484. 19.4.2 什么是IDE环境
  485. 19.4.3 有关Eclipse的编译报错的原因
  486. 19.5 小结
  487. 19.6 习题
  488. 第20章 Swing组件与布局管理器
  489. 20.1 什么是Swing编程
  490. 20.2 MVC设计模式基础
  491. 20.3 简单框架设计及实例
  492. 20.3.1 创建一个空白的框架
  493. 20.3.2 创建框架的其他工作
  494. 20.4 简单图形按钮控件的设计及实例
  495. 20.4.1 Swing中的按钮控件
  496. 20.4.2 按钮的模型
  497. 20.4.3 添加普通按钮
  498. 20.4.4 添加单选按钮
  499. 20.4.5 添加复选框
  500. 20.4.6 ToggleButton按钮
  501. 20.5 简单文本输入组件的设计及实例
  502. 20.5.1 文本域
  503. 20.5.2 密码域
  504. 20.5.3 文本区域
  505. 20.6 展示类组件的设计及实例
  506. 20.6.1 标签组件
  507. 20.6.2 选择组件
  508. 20.6.3 菜单组件
  509. 20.6.4 对话框的种类及用法
  510. 20.7 复杂布局管理器的种类及用法
  511. 20.7.1 箱式布局的设计
  512. 20.7.2 网格组布局的设计
  513. 20.7.3 流布局的设计
  514. 20.7.4 边界布局的设计
  515. 20.8 通过实例熟悉Swing编程
  516. 20.9 常见疑难解答
  517. 20.9.1 如何处理菜单的启用和禁用功能
  518. 20.9.2 如何编写快捷键的程序
  519. 20.10 小结
  520. 20.11 习题
  521. 第21章 JDBC及其应用
  522. 21.1 数据库基础知识
  523. 21.1.1 什么是数据库
  524. 21.1.2 数据库的分类及功能
  525. 21.1.3 关系数据库的设计
  526. 21.1.4 数据库设计技巧
  527. 21.2 JDBC的基础概念
  528. 21.2.1 JDBC驱动程序的分类
  529. 21.2.2 利用Java到数据库协议方式连接数据库
  530. 21.2.3 利用Java到本地API方式连接数据库
  531. 21.2.4 利用JDBC-ODBC方式连接数据库
  532. 21.3 关于SQL Server数据库基础操作
  533. 21.3.1 什么是支持SQL语言的数据库
  534. 21.3.2 通过SQL语言如何操作数据库
  535. 21.3.3 安装SQL Server
  536. 21.3.4 高级SQL类型
  537. 21.3.5 使用SQL创建数据库
  538. 21.4 JDBC基本编程
  539. 21.4.1 如何建立数据库
  540. 21.4.2 如何操作数据库
  541. 21.4.3 加载合适的数据库驱动程序
  542. 21.5 关于JDBC的高级操作
  543. 21.5.1 什么是事务处理
  544. 21.5.2 事务处理的过程演练
  545. 21.5.3 预查询
  546. 21.5.4 使用JDBC的注意事项
  547. 21.6 常见疑难解答
  548. 21.6.1 操作数据库的具体步骤是什么
  549. 21.6.2 数据库中的视图、图表、缺省值、规则、触发器、存储过程的意义
  550. 21.7 小结
  551. 21.8 习题
  552. 第22章 Applet设计
  553. 22.1 Applet的基本概念及生命周期
  554. 22.2 Applet的多媒体处理
  555. 22.2.1 声音处理
  556. 22.2.2 图像处理
  557. 22.3 浏览器与Applet的设计
  558. 22.3.1 如何将Applet嵌入浏览器
  559. 22.3.2 如何使用Applet类编程
  560. 22.3.3 如何用Applet控制浏览器
  561. 22.4 Applet的安全
  562. 22.5 一个Applet的综合实例分析
  563. 22.6 常见疑难解答
  564. 22.6.1 浏览器如何运行Applet
  565. 22.6.2 有关Applet无法在IE中显示问题的解答
  566. 22.7 小结
  567. 22.8 习题
  568. 第23章 网络编程基础
  569. 23.1 网络基础知识
  570. 23.2 TCP/IP协议和UDP协议
  571. 23.2.1 IP协议和IP地址
  572. 23.2.2 TCP协议和端口
  573. 23.2.3 客户端/服务器通信模型
  574. 23.2.4 UDP协议
  575. 23.3 端口与套接字
  576. 23.4 TCP程序设计基础
  577. 23.4.1 如何设计TCP程序
  578. 23.4.2 一个简单的例子
  579. 23.5 UDP程序设计基础
  580. 23.5.1 如何设计UDP程序
  581. 23.5.2 一个简单的例子
  582. 23.6 如何设计网络程序
  583. 23.6.1 单向通信综合实例
  584. 23.6.2 双向通信综合实例
  585. 23.7 常见疑难解答
  586. 23.7.1 TCP和UDP的区别
  587. 23.7.2 什么是TCP/IP协议,分为几层,什么功能
  588. 23.8 小结
  589. 23.9 习题
  590. 第四篇 Java语言程序设计实例与面试题剖析
  591. 第24章 学校管理系统
  592. 24.1 开发背景
  593. 24.2 需求分析
  594. 24.3 登录界面的设计
  595. 24.3.1 登录界面的分析
  596. 24.3.2 登录界面的代码实现
  597. 24.3.3 登录界面的运行
  598. 24.4 主菜单界面的设计
  599. 24.4.1 主菜单界面的分析
  600. 24.4.2 主菜单界面的代码实现
  601. 24.4.3 主菜单界面的运行
  602. 24.5 数据库系统的设计
  603. 24.5.1 数据库中表的创建
  604. 24.5.2 数据库中的代码段
  605. 24.6 学生信息系统界面的设计
  606. 24.6.1 学生类的设计
  607. 24.6.2 存储类的设计
  608. 24.6.3 学生信息系统界面的代码实现
  609. 24.7 教师信息系统界面的设计
  610. 24.7.1 教师类的设计
  611. 24.7.2 存储类的设计
  612. 24.7.3 教师信息系统界面的代码实现
  613. 24.8 领导信息系统界面的设计
  614. 24.8.1 领导类的设计
  615. 24.8.2 存储类的设计
  616. 24.8.3 领导信息系统界面的代码实现
  617. 24.9 小结
  618. 第25章 面 试 题
  619. 面试题1 Java的引用和C++的指针有什么区别
  620. 面试题2 类和对象有什么区别
  621. 面试题3 说明private、protected、public和default的区别
  622. 面试题4 Java可以用非0来代表true吗
  623. 面试题5 StringBuffer和StringBuilder存在的作用是什么
  624. 面试题6 二维数组的长度是否固定
  625. 面试题7 符合什么条件的数据集合可以使用foreach循环
  626. 面试题8 如何序列化和反序列化一个Java对象
  627. 面试题9 如何使用Java的线程池
  628. 面试题10 如何利用反射实例化一个类
  629. 面试题11 TCP协议的通信特点是什么
  630. 面试题12 请简述JDBC操作数据库的编程步骤
  631. 面试题13 如何使用连接池技术
  632. 面试题14 简述接口和抽象类的区别
  633. 面试题15 如何理解Java中的装箱和拆箱
  634. 面试题16 根据代码判断创建的对象个数
  635. 面试题17 分析循环程序的运行结果
  636. 面试题18 可以返回最大值的方法
  637. 面试题19 关于垃圾回收的疑问
  638. 面试题20 线程问题:找出代码中的错误
  639. 面试题21 关于ArrayList、Vector、LinkedList的问答题
载入中

热门划线

  1. 全局变量可以不用进行初始化赋值工作,而局部变量必须要进行初始化赋值工作。4 人
  2. 数组是具有相同数据类型的数据集合4 人
  3. 在定义构造函数时,应将调用父类构造函数的代码“super()”,置于调用父类构造函数的方法内部的最顶端,因为首先必须初始化继承自父类的成员。4 人
  4. 传址引用主要是针对对象操作,它传递的是一个对象句柄的复制。也就形成了多个变量操作一个对象的局面,任何一个针对句柄操作的变量,都会影响到其他的变量。4 人
  5. 当声明一个方法为private、static、final,或者声明一个构造函数时,编译器清楚地知道是调用哪个方法,不存在与实际类型不匹配的现象,这就称为静态绑定。静态绑定不存在多态的问题。4 人
  6. Java作为一种高级语言具有许多优良特性,如跨平台、面向对象、分布式、多线程、安全性、健壮性、简单性等;3 人
  7. “notepad”3 人
  8. 同一类型的不同变量,可以声明在一行,也可以声明在不同行,如果在同一行中声明,不同的变量之间用逗号分隔,如下面的例子。3 人
  9. 两个操作数中位都为1的情况下,结果才为1,否则结果为0。3 人
  10. 动态绑定只用在程序运行的过程中,其会根据程序传递的参数不同,而调用不同的方法,这种绑定只有在程序运行期间才会发生,即动态绑定有着不确定性。动态绑定存在多态的问题。3 人

喜欢这本书的人也喜欢