本书全面介绍了Java编程的核心概念，共13章。首先概述Java的发展、特性及开发环境搭建，包括JDK?安装与环境配置等，帮助读者打下坚实的基础。接着，深入探讨基本数据类型、变量使用方法、流程控制语句等，帮助读者构建复杂的逻辑能力。随后，详细阐述面向对象编程的内容，如类、对象、继承、多态和封装等，强化培养读者面向对象的设计思维。此外，还介绍了异常处理、数组与集合框架、输入输出流和多线程等高级特性。本书旨在帮助读者提升处理数据和并发编程的能力，适合编程新手、有其他语言经验的开发者，以及计算机专业学生阅读。

马占飞，包头师范学院副校长、二级教授。作为核心成员参与国家级、省部级和厅局级等教科研项目80余项。授权发明专利10项、实用新型专利2项。发表学术论文80余篇（其中SCI/EI收录18篇、中文核心20篇），著学术专著1部，主编和参编教材10余部。入选内蒙古自治区“草原英才”和“新世纪321人才工程”，包头市“鹿城英才”高端人才和“5512工程”领军人才等。

目 录
第 1 章 走进 Java ·······················································································.1
1.1 Java 概述 ·························································································.2
1.1.1 Java 的历史 ···············································································.2
1.1.2 Java 的特点 ···············································································.3
1.1.3 Java 的应用领域 ·········································································.4
1.2 Java 开发环境 ···················································································.4
1.2.1 JDK 的安装···············································································.4
1.2.2 配置 Java 开发环境 ·····································································.6
1.2.3 安装和配置开发工具 IDEA ···························································.8
1.2.4 JDK 概述··················································································11
1.2.5 JRE 概述···················································································11
1.2.6 JDK、JRE 与 JVM 的区别和联系 ···················································11
1.2.7 第一个 Java 程序 ········································································11
1.3 Java 标识符 ······················································································12
1.3.1 标识符概述 ···············································································12
1.3.2 为什么使用标识符 ······································································12
1.3.3 标识符的命名规范 ······································································12
1.3.4 关键字和保留词 ·········································································13
本章小结 ·································································································13
关键术语 ·································································································13
习题 ·······································································································13
第 2 章 数据类型和变量 ················································································14
2.1 数据类型 ··························································································16
2.1.1 基本数据类型 ············································································16
2.1.2 引用数据类型 ············································································16
2.2 常量和变量 ·······················································································17
2.2.1 常量概述 ··················································································17
2.2.2 常量的使用 ···············································································17
2.2.3 变量概述 ··················································································18
2.2.4 变量的使用 ···············································································18
2.3 数据类型转换 ····················································································19
Java 编程技术与项目实战 VI
2.3.1 自动转换 ··················································································19
2.3.2 强制转换 ··················································································20
2.3.3 类型推断 ··················································································21
本章小结 ·································································································22
关键术语 ·································································································23
习题 ·······································································································23
实际操作训练 ···························································································23
第 3 章 运算符 ·····························································································24
3.1 算术运算符 ·······················································································26
3.1.1 加减乘除运算符 ·········································································26
3.1.2 取模运算符 ···············································································27
3.1.3 自增和自减运算符 ······································································28
3.1.4 总结算术运算符 ·········································································29
3.2 赋值运算符 ·······················································································29
3.3 关系运算符 ·······················································································30
3.3.1 关系运算符概述 ·········································································30
3.3.2 关系运算符的注意事项 ································································31
3.3.3 关系运算符的使用 ······································································31
3.4 逻辑运算符 ·······················································································32
3.5 位运算符 ··························································································33
3.5.1 位运算符概述 ············································································33
3.5.2 位运算符的类型 ·········································································33
3.5.3 位运算符的注意事项 ···································································33
3.5.4 位运算符的使用 ·········································································33
3.6 三元运算符 ·······················································································34
3.6.1 三元运算符概述 ·········································································34
3.6.2 三元运算符的语法 ······································································34
3.6.3 三元运算符的特点 ······································································34
3.6.4 三元运算符的注意事项 ································································35
3.6.5 三元运算符的使用 ······································································35
3.7 运算符的优先级 ·················································································35
本章小结 ·································································································36
关键术语 ·································································································37
习题 ·······································································································37
实际操作训练 ···························································································37
第 4 章 流程控制语句 ···················································································38
4.1 顺序结构 ··························································································39
4.1.1 顺序结构的定义 ·········································································39
目 录 VII
4.1.2 顺序结构的特点 ·········································································39
4.1.3 顺序结构的使用 ·········································································40
4.2 分支结构 ··························································································40
4.2.1 分支结构的定义 ·········································································40
4.2.2 分支结构的分类 ·········································································40
4.2.3 分支结构的特点 ·········································································41
4.2.4 分支结构的使用 ·········································································42
4.3 循环结构 ··························································································42
4.3.1 循环结构的定义 ·········································································42
4.3.2 循环结构的分类 ·········································································42
4.3.3 循环结构的特点 ·········································································44
本章小结 ·································································································44
关键术语 ·································································································45
习题 ·······································································································45
实际操作训练 ···························································································45
第 5 章 数组 ································································································46
5.1 数组介绍 ··························································································47
5.1.1 数组概念 ··················································································47
5.1.2 数组的特点 ···············································································47
5.1.3 数组的应用领域 ·········································································48
5.2 一维数组 ··························································································48
5.2.1 一维数组的创建 ·········································································49
5.2.2 一维数组的初始化 ······································································50
5.2.3 一维数组的操作 ·········································································51
5.3 二维数组 ··························································································53
5.3.1 二维数组概述 ············································································53
5.3.2 二维数组的创建和初始化 ·····························································53
5.3.3 二维数组的注意事项 ···································································54
本章小结 ·································································································55
关键术语 ·································································································55
习题 ·······································································································55
实际操作训练 ···························································································55
第 6 章 方法 ································································································56
6.1 方法概述 ··························································································58
6.1.1 方法的概念 ···············································································58
6.1.2 方法的特点 ···············································································58
6.1.3 方法的作用 ···············································································58
6.2 方法的定义和调用 ··············································································59
Java 编程技术与项目实战 VIII
6.2.1 方法的定义 ···············································································59
6.2.2 方法的调用 ···············································································59
6.3 方法参数 ··························································································60
6.3.1 方法参数的个数 ·········································································60
6.3.2 方法参数的类型 ·········································································61
6.3.3 方法参数的种类 ·········································································62
6.3.4 方法参数的传递 ·········································································62
6.4 方法返回值 ·······················································································64
6.4.1 方法返回值的类型 ······································································64
6.4.2 方法返回值的应用 ······································································64
6.4.3 方法返回值的注意事项 ································································65
6.5 方法重载 ··························································································65
6.5.1 方法重载的规则 ·········································································65
6.5.2 方法重载的实现 ·········································································65
6.5.3 方法重载的优势 ·········································································67
6.6 方法的作用域和生命周期 ·····································································67
6.6.1 方法的作用域 ············································································67
6.6.2 方法的生命周期 ·········································································67
6.7 递归方法 ··························································································68
6.7.1 递归方法的定义 ·········································································68
6.7.2 递归方法的特点 ·········································································68
6.7.3 递归方法的使用 ·········································································68
本章小结 ·································································································69
关键术语 ·································································································69
习题 ·······································································································69
实际操作训练 ···························································································70
第 7 章 面向对象··························································································71
7.1 面向对象的思想 ·················································································73
7.1.1 面向过程的概念 ·········································································73
7.1.2 面向对象的概念 ·········································································73
7.1.3 面向对象与面向过程的关系 ··························································74
7.2 类与对象的关系 ·················································································74
7.2.1 类的定义 ··················································································74
7.2.2 对象的定义 ···············································································75
7.2.3 类与对象的关系 ·········································································76
7.3 成员的调用 ·······················································································76
7.3.1 成员变量和成员方法的定义 ··························································76
7.3.2 成员变量和成员方法的调用 ··························································76
7.4 成员变量与局部变量的区别 ··································································77
目 录 IX
7.5 关键字 this 和 static ············································································78
7.5.1 关键字 this ················································································78
7.5.2 关键字 static ··············································································79
7.6 构造方法 ··························································································82
7.6.1 构造方法的定义 ·········································································82
7.6.2 构造方法的语法结构 ···································································83
7.6.3 构造方法的访问 ·········································································83
7.7 封装 ································································································84
7.7.1 封装的定义 ···············································································84
7.7.2 包 ···························································································84
7.7.3 访问修饰符的权限 ······································································85
7.7.4 封装的实现 ···············································································86
7.7.5 封装的好处 ···············································································87
7.8 继承 ································································································88
7.8.1 继承的定义 ···············································································88
7.8.2 继承的作用 ···············································································88
7.8.3 继承的语法与实现 ······································································88
7.8.4 成员的访问 ···············································································89
7.8.5 构造方法的调用顺序 ···································································89
7.8.6 方法重写 ··················································································90
7.8.7 关键字 super··············································································92
7.8.8 关键字 final ···············································································95
7.9 多态 ································································································96
7.9.1 多态的定义 ···············································································96
7.9.2 多态的优点和作用 ······································································96
7.9.3 多态的实现方式 ·········································································97
7.10 抽象类和抽象方法 ············································································98
7.10.1 抽象类的定义···········································································98
7.10.2 抽象类的特点···········································································99
7.10.3 抽象类的实现方式·····································································99
7.10.4 抽象类的作用········································································.100
7.10.5 抽象方法的定义·····································································.100
7.10.6 抽象方法的实现方式·······························································.100
7.11 接口····························································································.101
7.11.1 接口的定义···········································································.101
7.11.2 接口的特点···········································································.101
7.11.3 接口的作用···········································································.102
7.11.4 接口的实现方式·····································································.102
7.11.5 抽象类与接口的区别·······························································.103
本章小结 ······························································································.103
Java 编程技术与项目实战 X
关键术语 ······························································································.104
习题 ····································································································.104
实际操作训练 ························································································.104
第 8 章 内部类··························································································.105
8.1 内部类 ··························································································.106
8.1.1 内部类的定义 ·········································································.106
8.1.2 成员内部类 ············································································.107
8.1.3 局部内部类 ············································································.108
8.2 静态内部类 ····················································································.109
8.2.1 静态内部类的定义 ···································································.109
8.2.2 静态内部类的使用 ···································································.110
8.3 匿名内部类 ····················································································.111
本章小结 ······························································································.111
关键术语 ······························································································.112
习题 ····································································································.112
第 9 章 异常处理·······················································································.113
9.1 异常概念 ·······················································································.114
9.1.1 异常概述 ···············································································.114
9.1.2 异常体系结构 ·········································································.115
9.1.3 常用异常类 ············································································.115
9.2 异常处理 ·······················································································.116
9.2.1 异常捕获 ···············································································.116
9.2.2 异常抛出 ···············································································.118
9.3 自定义异常类 ·················································································.118
9.3.1 自定义异常类概述 ···································································.118
9.3.2 自定义异常类的实现 ································································.118
9.3.3 异常链 ··················································································.119
本章小结 ······························································································.119
关键术语 ······························································································.119
习题 ····································································································.120
第 10 章 字符串和常用类库········································································.121
10.1 字符串定义和通用操作 ···································································.122
10.1.1 创建字符串···········································································.122
10.1.2 字符串通用操作·····································································.123
10.1.3 StringAPI··············································································.126
10.2 StringBuilder 和 StringBuffer ····························································.127
10.2.1 StringBuilder 和 StringBuffer 概述···············································.127
目 录 XI
10.2.2 常用方法··············································································.128
10.2.3 StringBuilder 和 StringBuffer 的区别············································.129
10.3 正则表达式···················································································.129
10.3.1 正则表达式概述·····································································.129
10.3.2 正则表达式的语法··································································.130
10.3.3 正则表达式的使用··································································.130
10.4 Java 常用类库 ··············································································.132
10.4.1 Object 类··············································································.132
10.4.2 Math 类················································································.135
10.4.3 Random 类············································································.136
10.4.4 Date 类 ················································································.137
10.4.5 包装类·················································································.140
本章小结 ······························································································.141
关键术语 ······························································································.141
习题 ····································································································.141
实际操作训练 ························································································.141
第 11 章 集合框架·····················································································.142
11.1 集合框架概述················································································.144
11.1.1 数组特点和弊端·····································································.144
11.1.2 Java 集合框架体系··································································.144
11.1.3 Java 集合的使用场景·······························································.144
11.2 单列集合······················································································.146
11.2.1 Collection 接口·······································································.146
11.2.2 Iterator 接口 ··········································································.151
11.2.3 List 接口 ··············································································.153
11.2.4 Set 接口 ···············································································.157
11.3 双列集合······················································································.165
11.3.1 Map 集合概述········································································.165
11.3.2 HashMap 实现类 ····································································.165
11.3.3 TreeMap 实现类 ·····································································.167
11.3.4 HashTable 实现类 ···································································.172
11.3.5 Properties 实现类····································································.172
11.4 Collections 工具类 ·········································································.173
本章小结 ······························································································.174
关键术语 ······························································································.174
习题 ····································································································.174
实际操作训练 ························································································.174
Java 编程技术与项目实战 XII
第 12 章 File 类与输入输出流 ·····································································.175
12.1 File 类·························································································.176
12.1.1 File 类概述 ···········································································.176
12.1.2 File 类的构造方法 ··································································.177
12.1.3 File 类的常用方法 ··································································.178
12.2 输入输出流分类 ············································································.180
12.2.1 输入输出流分类概述·······························································.180
12.2.1 输入输出流 API ·····································································.180
12.3 节点流·························································································.181
12.3.1 Reader 与 Writer·····································································.181
12.3.2 FileReader 与 FileWriter 实现类··················································.182
12.3.3 InputStream 与 OutputStream······················································.183
12.3.4 FileInputStream 与 FileOutputStream ············································.184
12.4 处理流·························································································.187
12.4.1 缓存流·················································································.187
12.4.2 转换流·················································································.190
12.5 其他流·························································································.192
12.5.1 标准输入输出流·····································································.192
12.5.2 打印流·················································································.193
12.5.3 Scanner 类 ············································································.194
本章小结 ······························································································.196
关键术语 ······························································································.196
习题 ····································································································.196
实际操作训练 ························································································.196
第 13 章 多线程························································································.197
13.1 多线程基本概念 ············································································.199
13.1.1 程序、进程与线程··································································.199
13.1.2 线程的调度···········································································.199
13.1.3 多线程的优点········································································.200
13.1.4 单核与多核概述·····································································.200
13.1.5 并行与并发概述·····································································.200
13.2 线程的创建与启动 ·········································································.200
13.2.1 继承 Thread 类·······································································.200
13.2.2 实现 Runnable 接口·································································.202
13.2.3 匿名内部类创建启动线程·························································.204
13.2.4 继承 Thread 类与实现 Runnable 接口的区别··································.205
13.3 线程的生命周期 ············································································.205
13.4 多线程同步···················································································.206
目 录 XIII
13.4.1 资源线程的安全问题·······························································.206
13.4.2 同步机制··············································································.210
13.5 线程间的通信 ···············································································.215
13.5.1 为什么要进行线程通信····························································.215
13.5.2 等待唤醒机制········································································.216
13.6 线程池·························································································.220
13.6.1 为什么使用线程池··································································.220
13.6.2 线程池的优点········································································.221
13.6.3 线程池相关 API ·····································································.221
本章小结 ······························································································.223
关键术语 ······························································································.223
习题 ····································································································.223
实际操作训练 ························································································.224
习题答案····································································································.225