Java开发从入门到精通 pdf epub mobi txt 电子书 下载 2025

简体网页||繁体网页

☆☆☆☆☆

扶松柏，陈小玉 著

图书标签:

• Java
• 编程
• 开发
• 入门
• 精通
• 软件开发
• 计算机
• 技术
• 书籍
• 教程

出版社： 人民邮电出版社

ISBN：9787115420275

版次：1

商品编码：12034362

品牌：异步图书

包装：平装

开本：16开

出版时间：2016-09-01

页数：548

正文语种：中文

编辑推荐

本书的特色是实现了入门知识、实例演示、范例演练、技术解惑、综合实战5大部分内容的融合，让读者看得懂、用得上、学得会。
一本书的容量，讲解了入门类、范例类和项目实战类三类图书的内容。

丰富的配套资源 学习更高效
459个实例，更多的实践演练机会
781分钟视频讲解，降低学习难度
306个拓展实例，真正地举一反三
107个技术解惑，破解学习难点

“技术讲解”→范例演练”→“技术解惑”贯穿全书，全面掌握Java语言开发

技术讲解：通过153个实例，循序渐进地讲解了Java开发的各个知识点。
范例演练：306个拓展范例和1个综合案例，使读者真正具有项目实战能力。
技术解惑：把容易混淆的概念单独讲解和剖析，帮助读者绕过学习中的陷阱。

QQ群+网站论坛实现教学互动，形成互帮互学的朋友圈
网站论坛：读者答疑／学习辅导／PPT资源下载读者
QQ群：疑惑快速解答／和作者直接交流

内容简介

本书由浅入深地详细讲解了Java的开发技术，并通过具体实例的实现过程演练了各个知识点的具体使用流程。本书共20章，第1～2章讲解了Java技术的基础知识，包括Java印象和首段Java程序；第3～9章分别讲解了Java语法、条件语句、循环语句、数组、面向对象等知识，这些内容都是Java开发技术的核心知识；第10～14章分别讲解了集合、类库、泛型、异常处理、I/O和文件处理的基本知识，这些内容是Java开发技术的重点和难点；第15～19章是典型应用内容，分别讲解了数据库编程、网络与通信编程、多线程等内容；第20章通过一个综合实例的实现过程，介绍了Java技术在综合项目中的使用流程。本书内容循序渐进，以“技术解惑”和“范例演练”贯穿全书，引领读者全面掌握Java语言。
本书不但适用于Java的初学者，也适用于有一定Java基础的读者，还可以作为大专院校相关专业的师生学习用书和培训学校的教材。

作者简介

扶松柏，上海大学计算机科学技术学院硕士，通信工程博士，精通Java、C语言、C++程序开发，擅长底层技术和应用程序的结合。具有丰富的Java开发经验和编程心得。

目录

第1章　Java之印象　1
（视频总计19分钟，技术解惑3个）
1．1　初步认识Java　2
1．1．1　都在谈论Java　2
1．1．2　Java的特点　2
1．1．3　Java中的一些名词解释　3
1．2　面向对象　4
1．2．1　什么是面向对象　4
1．2．2　Java的面向对象编程　4
1．2．3　UML统一建模语言　5
1．2．4　对象建模技术　7
1．2．5　面向对象分析　8
1．2．6　面向对象设计　10
1．2．7　Java的面向对象特性　12
1．3　技术解惑　13
1．3．1　卓越者的总结　13
1．3．2　对初学者的3条建议　14
1．3．3　理解Java的垃圾回收
机制　14
第2章　第一段Java程序　15
（视频总计20分钟，技术解惑8个）
2．1　搭建Java开发平台　16
2．1．1　安装JDK　16
2．1．2　配置开发环境　18
2．2　编写第一段Java程序　18
2．2．1　编写一段Java代码　18
2．2．2　编译Java程序　19
2．2．3　运行Java代码　19
2．3　使用IDE工具　20
2．3．1　最受欢迎的工具—
Eclipse　20
2．3．2　官方推出的工具—
Netbeans　23
2．3．3　商业工具——JBuilder　29
2．4　Java的运行机制　29
2．4．1　编译型/解释型运行机制　29
2．4．2　程序运行机制　29
2．5　技术解惑　30
2．5．1　遵循源文件命名规则　30
2．5．2　忽视系统文件的扩展名　30
2．5．3　环境变量的问题　31
2．5．4　大小写的问题　31
2．5．5　main()方法的问题　31
2．5．6　注意空格问题　32
2．5．7　到底用不用IDE工具　32
2．5．8　区分JRE和JDK　32
第3章　Java语法　33
（视频总计72分钟，实例21个，拓展实例42个，技术解惑4个）
3．1　量　34
3．1．1　常量　34
3．1．2　变量　35
3．2　数据类型　37
3．2．1　简单数据类型值的范围　37
3．2．2　字符型　38
3．2．3　整型　39
3．2．4　浮点型　39
3．2．5　布尔型　40
3．3　运算符　41
3．3．1　算术运算符　41
3．3．2　关系运算符和逻辑运算符　44
3．3．3　位运算符　45
3．3．4　条件运算符　46
3．3．5　赋值运算符　47
3．3．6　运算符的优先级　48
3．4　标识符和关键字　49
3．4．1　标识符　49
3．4．2　关键字　50
3．5　字符串　50
3．5．1　字符串的初始化　50
3．5．2　String类　51
3．5．3　StringBuffer类　53
3．6　类型转换　54
3．6．1　自动类型转换　54
3．6．2　强制转换　55
3．7　技术解惑　55
3．7．1　定义常量时的注意事项　55
3．7．2　char类型中单引号的意义　56
3．7．3　正无穷和负无穷的问题　56
3．7．4　移位运算符的限制　56
第4章　条件语句　58
（视频总计28分钟，实例6个，拓展实例12个，技术解惑4个）
4．1　if语句详解　59
4．1．1　if语句　59
4．1．2　if语句的延伸　60
4．1．3　多个条件判断的if语句　61
4．2　switch语句详解　62
4．2．1　switch语句的形式　62
4．2．2　无break的情况　63
4．2．3　case没有执行语句　64
4．2．4　default可以不在末尾　64
4．3　条件语句演练　65
4．3．1　正确使用switch语句　65
4．3．2　正确使用if语句　66
4．3．3　switch语句的执行顺序　67
4．4　技术解惑　68
4．4．1　if-else语句的意义　68
4．4．2　使用switch语句时的几个
注意事项　68
4．4．3　何时用switch语句比较好　69
4．4．4　switch语句和if…else if
语句的选择　69
第5章　循环语句　70
（视频总计24分钟，实例8个，拓展实例16个，技术解惑2个）
5．1　Java循环语句　71
5．1．1　for循环　71
5．1．2　while循环语句　73
5．1．3　do-while循环语句　75
5．2　跳转语句　76
5．2．1　break语句的应用　76
5．2．2　return语句的应用　78
5．2．3　continue跳转语句　79
5．3　技术解惑　79
5．3．1　使用for循环的技巧　79
5．3．2　跳转语句的选择技巧　80
第6章　特殊数据—数组　82
（视频总计33分钟，实例8个，拓展实例16个，技术解惑4个）
6．1　简单的一维数组　83
6．1．1　声明一维数组　83
6．1．2　创建一维数组　83
6．1．3　初始化一维数组　84
6．2　二维数组　85
6．2．1　声明二维数组　85
6．2．2　创建二维数组　85
6．2．3　初始化二维数组　86
6．3　三维数组　88
6．3．1　声明三维数组　88
6．3．2　创建三维数组的方法　88
6．3．3　初始化三维数组　88
6．4　操作数组　89
6．4．1　复制数组　89
6．4．2　比较数组　90
6．4．3　搜索数组中的元素　90
6．4．4　排序数组　91
6．4．5　填充数组　91
6．5　深入理解数组　93
6．5．1　动态数组　93
6．5．2　foreach循环　94
6．5．3　数组的内理　94
6．6　技术解惑　96
6．6．1　数组内是同一类型的数据　96
6．6．2　动态初始化数组的规则　96
6．6．3　引用类型　96
6．6．4　数组必须初始化　97
第7章　Java的面向对象（上）　98
（视频总计35分钟，实例7个，拓展实例14个，技术解惑5个）
7．1　类　99
7．1．1　定义类　99
7．1．2　定义属性　99
7．1．3　定义方法　100
7．1．4　定义构造器　100
7．2　修饰符　101
7．2．1　public修饰符　101
7．2．2　private私有修饰符　101
7．2．3　protected保护修饰符　102
7．2．4　其他修饰符　103
7．3　方法详解　103
7．3．1　方法的所属性　104
7．3．2　传递方法参数　104
7．3．3　长度可变的方法　105
7．3．4　构造方法　106
7．3．5　递归方法　106
7．4　使用this　107
7．5　使用类和对象　108
7．5．1　创建和使用对象　108
7．5．2　使用静态变量和静态
方法　109
7．6　抽象类和抽象方法　109
7．6．1　抽象类和抽象方法基础　110
7．6．2　抽象类必须有一个抽象
方法　111
7．6．3　抽象类的作用　112
7．7　软件包　113
7．7．1　定义软件包　113
7．7．2　在Eclipse定义软件包　113
7．7．3　在程序里插入软件包　114
7．8　技术解惑　115
7．8．1　Java传递引用类型的
实质　115
7．8．2　掌握this的好处　116
7．8．3　推出抽象方法的原因　117
7．8．4　什么时候用抽象类　117
7．8．5　static修饰的作用　118
第8章　Java的面向对象（中）　119
（视频总计31分钟，实例7个，拓展实例14个，技术解惑6个）
8．1　类的继承　120
8．1．1　父类和子类　120
8．1．2　调用父类的构造方法　121
8．1．3　访问父类的属性和方法　121
8．1．4　多重次继承　122
8．1．5　重写父类的方法　124
8．2　重写和重载　125
8．2．1　重写　125
8．2．2　重载　127
8．2．3　联合使用重写与重载　128
8．3　隐藏和封装　128
8．3．1　Java中的封装　128
8．3．2　使用访问控制符　129
8．3．3　Java中的包　130
8．3．4　import　132
8．4　接口　132
8．4．1　定义接口　133
8．4．2　接口里的量和方法　133
8．4．3　实现接口　134
8．4．4　引用接口　135
8．4．5　接口的继承　136
8．4．6　接口和抽象类　137
8．5　技术解惑　138
8．5．1　重写方法的两点注意事项　138
8．5．2　重写和重载的区别　138
8．5．3　举例理解类的意义　138
8．5．4　Java包的一些规则　138
8．5．5　探讨Package和import的
机制　139
8．5．6　Java接口编程的机理　140
第9章　Java的面向对象（下）　141
（视频总计39分钟，实例6个，拓展实例12个，技术解惑10个）
9．1　构造器详解　142
9．1．1　初始化构造器　142
9．1．2　构造器重载　143
9．1．3　调用父类构造器　143
9．2　多态　144
9．2．1　何谓多态　144
9．2．2　演示Java中的多态　146
9．3　引用类型　147
9．3．1　4种引用类型　147
9．3．2　instanceof运算符　150
9．3．3　引用变量的强制类型
转换　151
9．4　组合　152
9．5　初始化块　154
9．5．1　何谓初始化块　154
9．5．2　静态初始化块　155
9．6　包装类　156
9．7　深入详解final修饰符　157
9．7．1　用final修饰变量　158
9．7．2　final方法　159
9．8　内部类　160
9．8．1　何谓内部类　160
9．8．2　非静态内部类　160
9．8．3　成员内部类　162
9．8．4　局部内部类　162
9．8．5　静态内部类　163
9．8．6　匿名内部类　164
9．8．7　匿名类和内部类中的
this　166
9．8．8　总结Java内部类　167
9．9　枚举类　170
9．9．1　枚举类的方法　170
9．9．2　手动实现枚举类　170
9．9．3　枚举类型　172
9．10　技术解惑　174
9．10．1　构造器和方法的区别　174
9．10．2　this在构造器中的妙用　175
9．10．3　分析子类构造器调用父类
构造器的几种情况　175
9．10．4　要避免编译错误　175
9．10．5　强制类型转换不是
万能的　176
9．10．6　继承和组合的选择　176
9．10．7　分析发生异常的原因　176
9．10．8　用final修饰基本类型和
引用类型变量之间的
区别　176
9．10．9　类的4种权限　177
9．10．10　手工实现枚举类的缺点　177
第10章　集合　178
（视频总计51分钟，实例8个，拓展实例16个，技术解惑8个）
10．1　Java集合概述　179
10．2　Collection接口和Iterator接口　180
10．2．1　基础知识介绍　180
10．2．2　Collection接口和Iterator
接口　181
10．3　Set接口　182
10．3．1　基础知识介绍　182
10．3．2　使用HashSet　185
10．3．3　使用TreeSet类　186
10．3．4　使用EnumSet类　188
10．4　List接口　190
10．4．1　基本知识介绍　190
10．4．2　使用List接口和ListIterator
接口　192
10．4．3　使用ArrayList和
Vector类　193
10．5　Map接口　194
10．5．1　基本知识介绍　194
10．5．2　使用HashMap和Hashtable
实现类　198
10．5．3　使用SortedMap接口和
TreeMap实现类　199
10．5．4　使用WeakHashMap类　201
10．5．5　使用IdentityHashMap类　202
10．5．6　使用EnumMap类　202
10．6　Queue接口　203
10．6．1　LinkedList类　203
10．6．2　PriorityQueue类　205
10．7　集合工具类Collections　205
10．7．1　排序操作　205
10．7．2　查找和替换操作　206
10．8　其他集合类　207
10．8．1　Stack类　207
10．8．2　属性类Properties　208
10．9　技术解惑　211
10．9．1　Collection集合元素的改变
问题　211
10．9．2　深入理解HashSet　211
10．9．3　使用类EnumSet时的注意
事项　211
10．9．4　ArrayList和Vector的
区别　212
10．9．5　TreeMap判断两个元素
相等的标准　212
10．9．6　分析几种Map类的
性能　212
10．9．7　LinkedList、ArrayList、
Vector性能问题的研究　212
10．9．8　用swap()方法把集合中
两个位置的内容进行
交换　212
第11章　常用的类库　214
（视频总计54分钟，实例15个，拓展实例30个，技术解惑5个）
11．1　StringBuffer类　215
11．1．1　StringBuffer类基础　215
11．1．2　使用StringBuffer类　215
11．2　Runtime类　217
11．2．1　Runtime类　217
11．2．2　使用Runtime类　218
11．3　程序国际化　219
11．3．1　国际化基础　219
11．3．2　Locale类　219
11．3．3　ResourceBundle类　220
11．3．4　处理动态文本　221
11．3．5　使用类代替资源文件　222
11．4　System类　222
11．4．1　System类基础　223
11．4．2　垃圾对象的回收　223
11．5　Date类　224
11．5．1　使用Date类　224
11．5．2　使用Calendar类　225
11．5．3　使用DateFormat类　225
11．5．4　使用SimpleDate
Format类　226
11．6　Math类　227
11．7　Random类　228
11．8　NumberFormat类　229
11．9　BigInteger类　230
11．10　BigDecimal类　231
11．11　克隆对象　233
11．12　Arrays类　233
11．13　接口Comparable　234
11．13．1　Comparable接口基础　234
11．13．2　使用Comparable接口　235
11．13．3　使用Comparator接口　236
11．14　Observable类和Observer
接口　237
11．15　正则表达式　239
11．15．1　正则表达式基础　239
11．15．2　使用Pattern类和
Matcher类　240
11．15．3　String类和正则表达式　240
11．16　Timer类和TimerTask类　241
11．16．1　Timer类　241
11．16．2　TimerTask类　242
11．17　技术解惑　243
11．17．1　StringBuffer和String
选择的异同　243
11．17．2　通过System类获取本机
的全部环境属性　243
11．17．3　分析对象的生命周期　244
11．17．4　如果没有实现Comparable
接口会出现异常　244
11．17．5　体验正则表达式的
好处　245
第12章　泛型　246
（视频总计28分钟，实例6个，拓展实例12个，技术解惑5个）
12．1　泛型基础　247
12．1．1　泛型的好处　247
12．1．2　类型检查　247
12．1．3　使用泛型　249
12．2　泛型详解　249
12．2．1　定义泛型接口和类　250
12．2．2　派生子类　250
12．2．3　并不存在泛型类　251
12．3　类型通配符　252
12．3．1　设置类型通配符的上限　252
12．3．2　设置类型形参的上限　254
12．4　泛型方法　254
12．4．1　定义泛型方法　254
12．4．2　设置通配符下限　257
12．5　泛型接口　258
12．6　泛型继承　259
12．6．1　以泛型类为父类　259
12．6．2　以非泛型类为父类　260
12．7　运行时类型识别　260
12．8　强制类型转换　261
12．9　擦除　262
12．9．1　擦除基础　262
12．9．2　擦除带来的错误　264
12．10　技术解惑　265
12．10．1　彻底分析Java语言中
泛型的本质　265
12．10．2　泛型方法和类型通配符的
区别　265
12．10．3　泛型类的继承规则　266
12．10．4　类型擦除和泛型特性的
联系　266
12．10．5　使用泛型应该遵循的原则
和注意事项　267
第13章　异常处理　268
（视频总计24分钟，实例8个，拓展实例16个，技术解惑4个）
13．1　什么是异常　269
13．1．1　认识异常　269
13．1．2　Java的异常处理机制　269
13．1．3　Java提供的异常处理类　271
13．2　异常处理方式　272
13．2．1　使用try…catch处理
异常　272
13．2．2　处理多个异常　273
13．2．3　将finally关键字使用在
异常中　273
13．2．4　访问异常信息　275
13．3　抛出异常　276
13．3．1　使用throws抛出异常　276
13．3．2　使用throw抛出异常　277
13．4　自定义异常　278
13．4．1　Throwable类介绍　278
13．4．2　使用Throwable类自定义
异常　280
13．5　分析Checked异常和Runtime
异常的区别　281
13．5．1　机制上　282
13．5．2　逻辑上　282
13．6　异常处理的陋习　283
13．6．1　丢弃异常　283
13．6．2　不指定具体的异常　284
13．6．3　占用资源不释放　285
13．6．4　不说明异常的详细信息　285
13．6．5　过于庞大的try块　285
13．6．6　输出数据不完整　285
13．7　异常处理语句的规则　286
13．8　技术解惑　288
13．8．1　用嵌套异常处理是更合理
的方法　288
13．8．2　区别throws关键字和throw
关键字　288
13．8．3　异常类的继承关系　288
13．8．4　子类Error和Exception　288
第14章　I/O与文件处理　289
（视频总计63分钟，实例15个，拓展实例30个，技术解惑8个）
14．1　Java I/O简介　290
14．2　File类　290
14．2．1　File类中的方法　290
14．2．2　使用File类操作文件　291
14．3　RandomAccessFile类　293
14．3．1　RandomAccessFile类的
常用方法　294
14．3．2　使用RandomAccess
File类　294
14．4　字节流与字符流　295
14．4．1　节流类和字符流类　295
14．4．2　使用字节流　295
14．4．3　使用字符流　299
14．5　字节转换流　301
14．6　内存操作流　302
14．7　管道流　303
14．8　打印流　304
14．8．1　基础知识　304
14．8．2　使用打印流　305
14．9　System类　306
14．9．1　System．out　306
14．9．2　System．err　306
14．9．3　System．in　307
14．9．4　输入/输出重定向　308
14．10　BufferedReader类　309
14．10．1　BufferedReader类基础　309
14．10．2　使用BufferedReader类　310
14．11　Scanner类　311
14．11．1　Scanner类基础　311
14．11．2　使用Scanner类　312
14．12　数据操作流　314
14．12．1　DataOutputStream类　314
14．12．2　DataInputStream类　315
14．13　合并流　316
14．14　压缩流　317
14．14．1　ZIP压缩输入/输出流
简介　317
14．14．2　ZipOutputStream类　317
14．14．3　ZipFile类　320
14．14．4　ZipInputStream类　321
14．15　回退流　321
14．16　字符编码　322
14．16．1　得到本机的编码显示　323
14．16．2　产生乱码　323
14．17　对象序列化　324
14．17．1　Serializable接口　324
14．17．2　对象输出流
ObjectOutputStream　324
14．17．3　对象输入流
ObjectInputStream　325
14．17．4　Externalizable接口　326
14．17．5　关键字transient　327
14．17．6　序列化一组对象　328
14．18　新增的I/O　329
14．18．1　新I/O概述　329
14．18．2　使用Buffer　330
14．18．3　使用Channel　332
14．19　技术解惑　334
14．19．1　使用File．separator表示
分隔符　334
14．19．2　综合演练创建和删除文件
的操作　334
14．19．3　File类的复杂用法　335
14．19．4　字节流和字符流的区别　335
14．19．5　System．err和System．out
选择　337
14．19．6　使用I/O实现一个简单的
菜单效果　337
14．19．7　对象序列化和对象反序列
化操作时的版本兼容性
问题　339
14．19．8　不能让所有的类都实现
Serializble接口　339
第15章　AWT的奇幻世界　340
（视频总计49分钟，实例10个，拓展实例20个，技术解惑6个）
15．1　GUI和AWT　341
15．2　容器　344
15．2．1　容器基础　344
15．2．2　容器中的常用组件　345
15．3　布局管理器　347
15．3．1　布局利器FlowLayout　347
15．3．2　布局利器BorderLayout　348
15．3．3　布局利器GridLayout　350
15．3．4　GridBagLayout布局
管理器　351
15．3．5　布局利器CardLayout　356
15．3．6　BoxLayout布局管理器　358
15．3．7　布局利器Null　360
15．4　AWT的常用组件　361
15．4．1　AWT中的组件　361
15．4．2　AWT中的对话框　363
15．5　事件处理　365
15．5．1　Java的事件模型　365
15．5．2　事件和事件监听器　366
15．5．3　事件适配器　371
15．6　AWT的菜单　372
15．6．1　菜单条、菜单和菜单项　372
15．6．2　右键菜单　374
15．7　绘图　376
15．7．1　类Component中的绘图
方法　376
15．7．2　Graphics类　376
15．8　位图操作　378
15．8．1　Image类和
BufferedImage类　378
15．8．2　输入/输出位图　380
15．9　技术解惑　382
15．9．1　使用绝对定位　382
15．9．2　对事件处理模型的简化
理解　382
15．9．3　使用AWT开发动画　383
15．9．4　图片缩放在现实中的
意义　383
15．9．5　AWT和Swing是窗体编程
的两个主角　383
15．9．6　AWT中的菜单组件不能
创建图标菜单　383
第16章　Swing详解　384
（视频总计66分钟，实例14个，拓展实例28个，技术解惑2个）
16．1　Swing基础　385
16．2　Swing的组件　386
16．2．1　Swing组件的层次
结构　386
16．2．2　Swing实现AWT组件　387
16．2．3　Jframe、JscrollPane和
边框　391
16．2．4　JToolBar　393
16．2．5　JColorChooser和
JFileChooser　395
16．2．6　JOptionPane　397
16．2．7　JSplitPane　402
16．2．8　JTabbedPane　405
16．3　拖放处理　407
16．3．1　拖放处理基础　407
16．3．2　Swing中的拖放处理　407
16．4　实现进度条效果——
JProgressBar、ProgressMonitor
和BoundedRangeModel　409
16．4．1　创建一个进度条　409
16．4．2　使用ProgressMonitor创建
进度条对话框　411
16．5　JSlider和BoundedRangeModel　412
16．6　JList和JComboBox　415
16．6．1　使用JList和JComboBox
的构造器创建列表框　415
16．6．2　使用ListCellRenderer　418
16．7　JTree和TreeModel　419
16．7．1　创建树　420
16．7．2　拖动、编辑节点　421
16．8　技术解惑　425
16．8．1　贯穿Java开发的MVC
模式　425
16．8．2　Swing胜过AWT的
优势　425
第17章　数据库编程　426
（视频总计26分钟，实例2个，拓展实例4个，技术解惑5个）
17．1　SQL基础　427
17．1．1　数据定义　427
17．1．2　数据操纵　428
17．1．3　视图　430
17．1．4　SQL高级操作　430
17．2　初识JDBC　431
17．2．1　JDBC API　432
17．2．2　JDBC驱动类型　432
17．2．3　JDBC的常用接口和类　433
17．2．4　JDBC编程步骤　434
17．3　常用的几种数据库　437
17．3．1　Access数据库　437
17．3．2　SQL Server数据库　437
17．3．3　MySQL数据库　440
17．4　执行SQL语句的方式　443
17．4．1　使用executeUpdate　443
17．4．2　使用execute方法　444
17．5　事务处理　446
17．5．1　JDBC中的事务控制　446
17．5．2　JDBC事务控制的流程　447
17．6　存储过程　450
17．6．1　存储过程基础　450
17．6．2　创建存储过程　450
17．6．3　调用创建存储过程　452
17．7　技术解惑　453
17．7．1　池子的功效　453
17．7．2　服务器自带连接池的
问题　454
17．7．3　连接池模型　455
17．7．4　数据模型、概念模型和关系
数据模型　455
17．7．5　数据库系统的结构　456
第18章　网络与通信编程　457
（视频总计45分钟，实例8个，拓展实例16个，技术解惑6个）
18．1　Java中的网络包　458
18．1．1　InetAddress类详解　458
18．1．2　URLDecoder类和
URLEncoder类详解　458
18．1．3　URL和URLConnection　459
18．1．4　实践演练　460
18．2　TCP编程　463
18．2．1　使用ServletSocket　463
18．2．2　使用Socket　464
18．2．3　TCP中的多线程　465
18．2．4　实现非阻塞Socket通信　468
18．3　UDP编程　472
18．3．1　使用DatagramSocket　472
18．3．2　使用MulticastSocket　475
18．4　代理服务器　478
18．4．1　什么是代理服务器　478
18．4．2　使用Proxy创建连接　479
18．4．3　使用ProxySelector选择
代理服务器　480
18．4．4　服务器代理实例　482
18．5　技术解惑　485
18．5．1　使用异常处理完善程序　485
18．5．2　使用ServerSocketChannel
的麻烦之处　485
18．5．3　体会烦琐的
DatagramPacket　486
18．5．4　MulticastSocket类的重要
意义　486
18．5．5　继承ProxySelector时需要
做的工作　486
18．5．6　代理服务无止境　486
第19章　多线程　487
（视频总计33分钟，实例3个，拓展实例6个，技术解惑10个）
19．1　线程基础　488
19．1．1　线程概述　488
19．1．2　线程带来的意义　488
19．1．3　Java的线程模型　489
19．2　创建线程　490
19．2．1　使用Thread类创建
线程　490
19．2．2　使用Runnable接口创建
线程　492
19．3　线程的生命周期　493
19．3．1　创建并运行线程　494
19．3．2　挂起和唤醒线程　494
19．3．3　终止线程的3种方法　495
19．3．4　线程阻塞　497
19．3．5　线程死亡　498
19．4　控制线程　499
19．4．1　使用join方法　499
19．4．2　慎重使用volatile
关键字　500
19．4．3　后台、让步和睡眠　501
19．5　线程传递数据　502
19．5．1　向线程传递数据的3种
方法　502
19．5．2　从线程返回数据的两种
方法　504
19．6　数据同步　505
19．6．1　使用Synchronized关键字
同步类方法　509
19．6．2　使用Synchronized块同步
变量　511
19．6．3　同步锁　512
19．7　总结多线程编程的常见缺陷及其
产生的原因　514
19．7．1　死锁问题　515
19．7．2　多线程编程的常见陷阱　517
19．8　技术解惑　521
19．8．1　线程和函数的关系　521
19．8．2　在run方法中使用线程名
时带来的问题　521
19．8．3　继承Thread类或实现
Runnable接口方式的
比较　521
19．8．4　start和run的区别　521
19．8．5　使用sleep()方法的注意
事项　521
19．8．6　线程的优先级　522
19．8．7　如何确定发生死锁　522
19．8．8　关键字synchronized和
volatile的区别　522
19．8．9　sleep()方法和yield()方法
的区别　523
19．8．10　分析Swing的多线程死锁
问题　523
第20章　整合开发企业快信系统　524
（视频总计41分钟）
20．1　一个项目　525
20．1．1　背景分析　525
20．1．2　需求分析　525
20．1．3　核心技术分析　525
20．2　系统设计　525
20．2．1　系统目标　525
20．2．2　系统功能结构　525
20．3　搭建开发环境　526
20．3．1　建立短信猫开发环境　526
20．3．2　设计数据库　527

20．3．3　设计表　528
20．4　规划系统文件　530
20．5　具体编码　531
20．5．1　编写公用模块代码　531
20．5．2　设计主页　534
20．5．3　名片夹管理模块　535
20．5．4　收发短信模块　540
20．5．5　邮件群发模块　543
20．6　分析Java Mail组件　544
20．6．1　Java Mail简介　544
20．6．2　邮件协议简介　545
20．6．3　邮件发送　545
20．6．4　收取邮件　547
20．7　项目调试　547

《Java编程实践：从基础到高级应用》 前言 在信息技术日新月异的今天，Java语言凭借其跨平台性、面向对象特性以及强大的生态系统，已成为构建各种规模应用程序的基石。从企业级应用开发到移动端Android开发，再到大数据处理和云计算，Java的身影无处不在。对于渴望掌握这项通用技能的开发者而言，一本既能打下坚实基础，又能引领走向高级应用的书籍至关重要。《Java编程实践：从基础到高级应用》正是一本旨在满足这一需求的力作。 本书并非对Java语言知识点的简单堆砌，而是聚焦于“实践”二字，强调理论与实操相结合。我们相信，只有在真实的项目场景中运用所学知识，才能真正理解其精髓，并具备解决实际问题的能力。因此，本书将带领读者循序渐进地探索Java的世界，从最基本的语法概念出发，逐步深入到面向对象设计、并发编程、网络通信、数据库交互、框架应用等更复杂的领域。 本书的写作初衷，源于我们对Java开发领域深刻的理解和丰富的实践经验。我们深知初学者在学习过程中可能遇到的困惑，也洞悉了资深开发者在面对复杂项目时所需的进阶技巧。因此，本书在内容编排上力求逻辑清晰，层层递进，既能让新手快速上手，也能为有经验的开发者提供新的视角和思路。 我们将以清晰易懂的语言，结合大量生动形象的代码示例，逐步揭示Java的奥秘。读者将不仅学习到“是什么”，更重要的是学习到“为什么”以及“如何做”。通过对典型问题的剖析和解决方案的设计，本书将帮助读者培养严谨的编程思维和优秀的工程习惯，为日后的职业发展奠定坚实的基础。 第一部分：Java核心基础 本部分将为读者构建起坚实的Java编程基石。我们将从最基本的元素开始，逐步深入，确保每一位读者都能全面掌握Java语言的精髓。 第一章：Java环境搭建与第一个程序 JDK、JRE和JVM的奥秘： 深入理解Java虚拟机（JVM）、Java运行时环境（JRE）和Java开发工具包（JDK）之间的关系，以及它们在Java程序执行过程中的核心作用。我们将详细解析JVM的加载、链接和执行机制，帮助读者理解Java“一次编写，到处运行”的强大能力。 开发环境的配置： 手把手指导读者完成JDK的安装与配置，并介绍如何在Eclipse、IntelliJ IDEA等主流集成开发环境（IDE）中创建和运行Java项目。我们将讲解IDE的常用功能，如代码补全、语法高亮、断点调试等，以提高开发效率。 编写你的第一个Java程序：“Hello, World!”： 从最简单的“Hello, World!”程序开始，讲解Java程序的结构，包括类（class）、主方法（main method）、输出语句（`System.out.println()`）等。我们将引导读者理解代码的执行流程，并为后续学习打下基础。 理解Java的关键字、标识符和注释： 详细介绍Java语言中的保留字（关键字），以及如何定义合法的标识符。我们将强调注释在代码可读性方面的重要性，并展示不同类型注释的使用方法。 第二章：Java基本语法与数据类型 变量与常量： 讲解变量的声明、初始化和使用，以及常量的定义。我们将区分不同作用域的变量，并强调变量命名规范的重要性。 基本数据类型： 深入理解Java的八种基本数据类型（byte, short, int, long, float, double, char, boolean），包括它们的取值范围、内存占用以及在计算机内部的表示方式。我们将重点讲解整型和浮点型数据的精度问题。 数据类型转换： 详述Java中的自动类型提升（隐式转换）和强制类型转换（显式转换），以及在转换过程中可能遇到的数据精度丢失问题。我们将提供实际案例来演示不同场景下的类型转换。 运算符与表达式： 全面介绍算术运算符、关系运算符、逻辑运算符、位运算符、赋值运算符以及三元运算符。我们将讲解运算符的优先级和结合性，并通过复杂的表达式计算来加深理解。 第三章：流程控制语句 条件判断语句： 详细讲解`if`、`else if`、`else`以及`switch`语句的用法，并示范如何使用它们来根据不同条件执行相应的代码块。我们将探讨嵌套if语句和switch语句的适用场景。 循环语句： 深入理解`for`循环、`while`循环和`do-while`循环的语法结构和执行机制。我们将讲解如何使用循环来重复执行代码，以及如何通过计数器、条件判断来控制循环的次数。 跳转语句： 掌握`break`、`continue`和`return`语句在流程控制中的作用。我们将演示如何在循环和switch语句中使用`break`和`continue`来改变程序的执行流程，并讲解`return`语句在方法中的退出机制。 第四章：数组与字符串 一维数组： 讲解数组的声明、创建、初始化和访问。我们将演示如何存储同类型数据的集合，并介绍数组长度（`length`属性）的应用。 多维数组： 深入理解二维数组的定义和使用，以及如何处理矩阵等二维数据结构。我们将展示如何遍历多维数组，并讨论其在实际问题中的应用。 String类的使用： 详细介绍Java中字符串（String）的特性，包括其不可变性（immutable）。我们将学习String对象的创建、拼接、查找、替换、截取等常用操作。 StringBuilder与StringBuffer： 讲解StringBuilder和StringBuffer的区别与联系，以及它们在处理大量字符串拼接操作时的效率优势。我们将对比它们在多线程环境下的安全性。 第二部分：面向对象编程（OOP） 本部分将带领读者进入Java面向对象的核心世界，理解其设计理念和强大功能。 第五章：类与对象 类的定义与实例化： 讲解如何定义一个类，包括类名、属性（成员变量）和方法（成员函数）。我们将演示如何通过`new`关键字创建类的对象（实例），以及对象与类之间的关系。 构造方法： 深入理解构造方法的概念、作用和定义。我们将讲解无参构造方法、有参构造方法以及构造方法的重载，并强调它们在对象初始化过程中的重要性。 封装： 剖析封装的含义、实现方式（`private`、`public`、`protected`）以及其在保护数据、提高代码复用性和可维护性方面的作用。我们将讲解getter和setter方法的使用。 this关键字： 详细解释`this`关键字的用法，包括区分成员变量和局部变量，以及在构造方法中调用其他构造方法。 第六章：继承与多态 继承： 讲解继承的语法（`extends`关键字），以及子类如何继承父类的属性和方法。我们将讨论单继承和多层继承，并强调代码复用的重要性。 方法重写（Override）： 学习如何在子类中重写父类的方法，以实现多态性的基础。我们将讲解方法重写的规则和注意事项。 super关键字： 详述`super`关键字的用法，包括调用父类的构造方法和方法。 多态（Polymorphism）： 深入理解多态的概念，包括编译时多态（方法重载）和运行时多态（方法重写）。我们将展示多态在实际开发中的强大威力，如向上转型和向下转型。 抽象类与抽象方法： 学习如何定义抽象类（`abstract class`）和抽象方法（`abstract method`），以及它们在构建类层次结构中的作用。我们将探讨抽象类不能被实例化的原因。 第七章：接口与内部类 接口（Interface）： 深入理解接口的概念、语法和作用。我们将讲解接口的定义、实现（`implements`关键字），以及接口的多实现特性。 接口与抽象类的对比： 详细比较接口和抽象类的异同，以及它们各自适用的场景。 默认方法与静态方法（Java 8+）： 介绍接口中引入的默认方法和静态方法，以及它们如何增强接口的功能。 内部类（Inner Classes）： 讲解成员内部类、局部内部类、匿名内部类和静态内部类。我们将分析内部类的应用场景，如事件监听、回调等。 第八章：异常处理 异常的分类： 区分Java中的运行时异常（Runtime Exception）、编译时异常（Checked Exception）和错误（Error）。 try-catch-finally语句块： 详细讲解`try`、`catch`和`finally`语句块的用法，以及如何捕获和处理异常。 throw与throws关键字： 学习如何使用`throw`关键字主动抛出异常，以及如何使用`throws`关键字声明方法可能抛出的异常。 自定义异常： 指导读者如何根据实际需求定义自己的异常类，以提高程序的可读性和健壮性。 第三部分：Java高级特性与实践 本部分将带领读者深入探索Java的高级特性，并将其应用于实际的项目开发中。 第九章：集合框架（Collections Framework） Collection接口与Map接口： 介绍`Collection`接口及其常用实现类（`List`、`Set`），以及`Map`接口及其常用实现类（`HashMap`、`TreeMap`）。 List的深入： 详细讲解`ArrayList`和`LinkedList`的区别、性能特点和使用场景。 Set的深入： 介绍`HashSet`、`TreeSet`和`LinkedHashSet`的特性，以及它们如何实现元素的唯一性。 Map的深入： 重点讲解`HashMap`的工作原理，包括哈希表（HashTable）的概念，以及`TreeMap`的排序特性。 迭代器（Iterator）： 学习使用迭代器来遍历集合中的元素，并理解其与增强`for`循环的区别。 泛型（Generics）： 深入理解泛型的概念，以及它如何提高代码的安全性和可读性，避免类型转换错误。 第十章：Java I/O流 流的分类： 区分字节流（Byte Stream）和字符流（Character Stream），以及输入流（Input Stream）和输出流（Output Stream）。 文件操作： 学习使用`File`类来操作文件和目录，包括创建、删除、重命名等。 常用I/O类： 详细介绍`FileInputStream`、`FileOutputStream`、`FileReader`、`FileWriter`以及缓冲流（`BufferedInputStream`、`BufferedOutputStream`、`BufferedReader`、`BufferedWriter`）的用法。 对象序列化（Serialization）： 讲解如何将Java对象转换为字节流进行存储或传输，以及如何反序列化。 第十一章：多线程编程 线程的创建与管理： 介绍两种创建线程的方式：继承`Thread`类和实现`Runnable`接口。 线程的生命周期： 理解线程从创建到终止的各个状态。 线程同步与锁机制： 讲解`synchronized`关键字的作用，以及如何解决多线程访问共享资源时的数据安全问题。 线程通信： 介绍`wait()`、`notify()`和`notifyAll()`方法在线程间通信中的作用。 并发工具类： 介绍`java.util.concurrent`包下的常用并发工具类，如`ExecutorService`、`Callable`、`Future`等。 第十二章：网络编程 TCP/IP协议基础： 简要介绍TCP和UDP协议的工作原理。 Socket编程： 学习使用`Socket`类创建客户端和服务器端，实现基于TCP的通信。 URL与URI： 理解URL和URI的概念，以及如何使用Java进行网络资源的访问。 HTTP协议： 讲解HTTP协议的基本请求和响应机制。 第十三章：反射（Reflection） 反射的概念与应用： 介绍反射机制，以及如何动态地获取类的信息、创建对象、调用方法。 `Class`类： 学习如何通过`Class`类来获取类的元数据。 反射的应用场景： 探讨反射在框架设计、单元测试、动态代理等领域的应用。 第十四章：Lambda表达式与Stream API（Java 8+） Lambda表达式： 深入理解Lambda表达式的语法、函数式接口以及它如何简化匿名内部类的编写。 Stream API： 学习如何使用Stream API对集合进行声明式、函数式的数据处理，包括`filter`、`map`、`reduce`等操作。 Stream的优势： 探讨Stream API在提高代码简洁性、可读性和并行处理性能方面的优势。 第四部分：Java企业级开发入门 本部分将为读者打开Java企业级开发的大门，介绍常用的技术和框架。 第十五章：数据库编程（JDBC） JDBC API： 介绍Java数据库连接（JDBC）API，以及如何使用它与各种关系型数据库进行交互。 数据库连接与操作： 学习如何加载数据库驱动、建立数据库连接、执行SQL语句（查询、插入、更新、删除）。 PreparedStatement： 讲解`PreparedStatement`的优势，包括防止SQL注入和提高性能。 结果集（ResultSet）： 学习如何处理SQL查询返回的结果集。 第十六章：Web开发基础（Servlet与JSP） Servlet： 介绍Servlet的概念、生命周期以及如何处理HTTP请求。 JSP（JavaServer Pages）： 讲解JSP的工作原理，以及如何使用JSP动态生成HTML页面。 请求与响应： 理解HTTP请求（Request）和响应（Response）对象的作用。 EL表达式与JSTL标签库： 学习使用EL表达式和JSTL简化JSP页面的开发。 第十七章：Maven与Gradle构建工具 项目构建的重要性： 讲解为什么需要构建工具来自动化项目的编译、测试、打包和部署。 Maven： 学习Maven的核心概念，如POM（Project Object Model）、依赖管理、生命周期和插件。 Gradle： 介绍Gradle作为更现代化、更灵活的构建工具。 第十八章：Spring框架入门 Spring核心概念： 介绍Spring IOC（Inversion of Control，控制反转）和DI（Dependency Injection，依赖注入）的概念。 Spring Beans： 学习如何配置和管理Spring Bean。 Spring MVC： 简要介绍Spring MVC框架在Web开发中的应用。 Spring Boot： 介绍Spring Boot如何简化Spring应用的开发和部署。 附录： Java开发最佳实践 常用的Java开发工具与资源 常见问题解答（FAQ） 结语 《Java编程实践：从基础到高级应用》旨在成为读者Java学习旅程中的一位忠实伙伴。我们希望通过本书的阅读，读者能够： 扎实掌握Java语言的各项核心知识，理解其底层原理。 熟练运用面向对象的设计思想，编写出高质量的代码。 掌握Java的高级特性，并将其应用于实际项目中。 初步了解Java企业级开发的生态系统，为进一步深入学习打下基础。 学习编程是一场持续的探索，而Java正是探索广阔技术世界的一把有力钥匙。愿本书能够点燃您对Java编程的热情，助您在开发的道路上不断前行，最终成就卓越。

评分☆☆☆☆☆

这本书的编写质量绝对是顶级的。作为一个有几年开发经验的程序员，我深知一本好书的重要性。很多技术书籍往往过于理论化，或者例子陈旧，无法跟上技术发展的步伐。而这本书，则让我眼前一亮。它不仅覆盖了 Java 开发的方方面面，从最基础的语法到高级特性，都做了深入浅出的讲解，而且书中大量的案例都非常贴近当下实际的开发需求，甚至包含了一些我之前在工作中遇到过但没能完全解决的问题。作者在讲解每个技术点的时候，都会考虑到读者可能遇到的陷阱和误区，并提前给出提醒和解决方案，这对于节省读者宝贵的学习和调试时间非常有帮助。我最看重的是，这本书没有止步于“会用”，而是着重于“理解”和“掌握”。它会引导我们去思考“为什么这么设计”，从而帮助我们建立起更深层次的编程思维。读完这本书，我感觉自己的 Java 内功得到了极大的提升，对很多框架和库的理解也更加透彻了。

评分☆☆☆☆☆

这本书简直是我的救星！我之前一直对 Java 望而却步，感觉它太复杂了，到处都是看不懂的术语和晦涩的概念。身边的朋友都推荐我学 Java，说它在编程界地位很高，应用也非常广泛，但每次打开那些教材，我就头晕眼花。直到我遇到了这本书，它就像一盏明灯，照亮了我前进的道路。作者的讲解方式非常独特，不是那种枯燥乏味的理论堆砌，而是从实际应用场景出发，一步步引导读者去理解。每当我遇到一个概念，它都能给我一个生动的比喻或者一个非常贴切的例子，让我瞬间茅塞顿开。最让我惊喜的是，这本书的例子非常贴合实际开发，不是那些脱离实际的“玩具”代码。通过跟着书中的例子一步步敲打，我不仅理解了代码的运行逻辑，还对如何解决实际问题有了更深的认识。而且，书中的练习题也设计得非常有针对性，做完练习后，我感觉自己对知识点的掌握程度立刻提升了一个档次。这本书让我对 Java 的学习不再感到恐惧，反而充满了期待，我觉得我真的有机会精通 Java 了！

评分☆☆☆☆☆

说实话，这本书的价值远超其价格。我之前为了学习 Java，买过很多书，也报过线上课程，但效果都不尽如人意。很多教程要么进度太快，要么讲解过于浅显，要么就是充斥着大量的错误和过时的信息。直到我偶然发现了这本书，我才明白什么是真正的“干货”。作者在书中倾注了大量的心血，将复杂的 Java 知识点抽丝剥茧，以一种非常易于理解的方式呈现出来。我特别欣赏书中对一些经典算法和设计模式的讲解，它不是简单地罗列代码，而是深入分析了它们的原理和应用场景，让我能够真正领会到其中的精髓。而且，书中的错误率非常低，我几乎没有遇到过无法运行或者逻辑错误的例子。读这本书，感觉就像在和一位经验丰富的资深工程师交流，他不仅能够告诉你“是什么”，更能够告诉你“为什么”和“如何做得更好”。

评分☆☆☆☆☆

刚拿到这本书的时候，我并没有抱太大的期望，毕竟市面上关于 Java 的书籍太多了，质量参差不齐。但当我翻开第一页，就被作者的写作风格吸引住了。他用了非常平实、易懂的语言，将 Java 的核心概念娓娓道来，没有丝毫的故弄玄虚。我尤其喜欢书中的“为什么”和“怎么做”的讲解模式。对于每一个知识点，作者都会先解释它出现的“为什么”，让我们明白它的重要性和价值，然后再详细讲解“怎么做”，并配以清晰的代码示例。这种方式让我能够真正理解 Java 编程的思想，而不是死记硬背一些语法规则。书中的逻辑结构也非常清晰，从基础的变量、数据类型，到复杂的面向对象、集合框架，再到网络编程、多线程等等，层层递进，环环相扣，让我能够循序渐进地建立起完整的 Java 知识体系。我之前学习 Java 时遇到的很多困惑，在这本书里都得到了解答，感觉就像是找到了一位耐心细致的老师，随时随地都能解答我的疑问。

评分☆☆☆☆☆

对于初学者来说，这本书简直是福音。我一直对编程充满兴趣，但苦于找不到合适的入门书籍。很多 Java 入门书都显得非常枯燥，充斥着大量的专业术语，让人望而却步。这本书彻底颠覆了我的认知。它用非常生动形象的比喻，将抽象的编程概念变得通俗易懂。例如，作者在讲解类和对象的时候，竟然用到了“买车”这个例子，让我瞬间就明白了面向对象编程的核心思想。而且，书中的代码示例非常实用，不是那些为了演示而写的“孤立”代码，而是能够集成到实际项目中的小模块。我跟着书中的例子一步步实践，感觉自己真的在一步步构建一个真实的 Java 应用。这本书让我对 Java 编程产生了浓厚的兴趣，并且让我相信，只要坚持下去，我一定能够掌握这门强大的编程语言。

评分☆☆☆☆☆

很好

评分☆☆☆☆☆

学霸老公买来看的，应该还不错。

评分☆☆☆☆☆

知识就是力量 这本书非常好 适合新手学习使用 多学习就有未来

评分☆☆☆☆☆

正在使用，挺好的。

评分☆☆☆☆☆

现在还没看。

评分☆☆☆☆☆

还没有学习，印装很好，这个系列的书看过一些了，还不错。

评分☆☆☆☆☆

书不错。还没来得及看。

评分☆☆☆☆☆

满意

评分☆☆☆☆☆

没看完