面向对象技术与UMLPDF电子书下载

上篇 面向对象技术 3

第1章 Java入门 3

1.1认识Java 3

1.1.1认识编程语言 3

1.1.2 Java的来历 4

1.1.3 Java为什么流行 5

1.1.4 Java的三个版本 7

1.1.5编程前的准备工作 7

1.2安装JDK 7

1.2.1获取JDK 7

1.2.2安装JDK步骤 8

1.2.3安装目录介绍 9

1.2.4环境变量设置 9

1.3开发第一个Java程序 11

1.3.1如何编写源代码 11

1.3.2如何将源代码编译成.class文件 12

1.3.3如何执行.class文件 13

1.3.4新手常见错误 13

1.4用Eclipse开发Java程序 14

1.4.1 Eclipse的概念 14

1.4.2安装Eclipse 15

1.4.3如何建立项目 16

1.4.4如何开发Java程序 17

1.4.5如何维护项目 19

1.5小结 20

第2章 程序设计基础：变量及其运算 21

2.1认识变量 21

2.1.1变量的定义 21

2.1.2变量有哪些类型 22

2.2如何使用变量 23

2.2.1如何使用整型变量 23

2.2.2如何使用浮点型变量 24

2.2.3如何使用字符型变量 25

2.2.4如何使用布尔型变量 27

2.2.5基本数据类型之间的类型转换 28

2.2.6基本数据类型和字符串之间的转换 29

2.2.7变量的作用范围 30

2.3注释的书写 31

2.4 Java中的运算 32

2.4.1算术运算 32

2.4.2赋值运算 34

2.4.3关系运算 35

2.4.4逻辑运算 36

2.4.5运算符的优先级 36

2.5小结 37

第3章 程序设计基础：流程控制和数组 38

3.1判断结构 38

3.1.1为什么需要判断结构 38

3.1.2 if结构 38

3.1.3 switch结构 42

3.2认识循环结构 44

3.2.1为什么需要循环结构 44

3.2.2 while循环 44

3.2.3 do-while循环 45

3.2.4 for循环 46

3.2.5循环嵌套 47

3.2.6 break和continue 48

3.3数组 50

3.3.1为什么需要数组 50

3.3.2如何定义数组 51

3.3.3如何使用数组 52

3.3.4数组的引用性质 54

3.3.5数组的应用 55

3.3.6多维数组 56

3.4小结 57

第4章 实验指导1 58

4.1关于变量和数据类型的实践 58

4.2流程控制和数组的综合实践 60

第5章 类、对象和成员 69

5.1认识类和对象 69

5.1.1为什么需要类 69

5.1.2如何定义类 70

5.1.3如何使用类实例化对象 70

5.1.4如何访问对象中的成员变量 71

5.1.5对象的引用性质 72

5.2认识成员函数 74

5.2.1为什么需要函数 74

5.2.2如何定义和使用成员函数 75

5.2.3函数参数的传递 78

5.2.4认识函数重载 80

5.3认识构造函数 81

5.3.1为什么需要构造函数 81

5.3.2如何定义和使用构造函数 82

5.4静态变量和静态函数 84

5.4.1为什么需要静态变量 84

5.4.2静态变量的常见应用 86

5.4.3认识静态函数 87

5.4.4静态代码块 88

5.5小结 89

第6章 封装 90

6.1使用封装 90

6.1.1为什么需要封装 90

6.1.2如何实现封装 91

6.2使用包 92

6.2.1为什么需要包 92

6.2.2如何将类放在包中 92

6.2.3如何访问包中的类 95

6.3使用访问控制修饰符 97

6.3.1什么是访问控制修饰符 97

6.3.2类的访问控制修饰符 97

6.3.3成员的访问控制修饰符 98

6.4使用类中类 98

6.5小结 99

第7章 继承和多态 100

7.1使用继承 100

7.1.1为什么需要继承 100

7.1.2如何实现继承 101

7.1.3继承的底层本质 103

7.2成员的覆盖 105

7.2.1什么是成员覆盖 105

7.2.2成员覆盖有何作用 107

7.3使用多态性 108

7.3.1什么是多态 108

7.3.2如何使用多态性 109

7.3.3父子类对象的类型转换 111

7.4抽象类和接口 113

7.4.1为什么需要抽象类 113

7.4.2为什么需要接口 114

7.5其他内容 115

7.5.1 final关键字 115

7.5.2 Object类 116

7.6一些工具的使用 118

7.6.1将字节码打包发布 118

7.6.2文档的使用 121

7.7小结 124

第8章 实验指导2 125

8.1单例模式的设计 125

8.1.1需求简介 125

8.1.2不用单例模式的效果 126

8.1.3最原始的单例模式 127

8.1.4首次改进 127

8.1.5再次改进 128

8.1.6思考题 130

8.2利用继承和多态扩充程序功能 130

8.2.1需求简介 130

8.2.2实现方法 131

8.2.3出现的问题 132

8.2.4改进 132

8.2.5测试 133

第9章 异常处理 135

9.1认识异常 135

9.1.1生活中的异常 135

9.1.2软件中的异常 135

9.1.3为什么要处理异常 137

9.1.4异常机理 138

9.1.5常见异常 139

9.2异常的就地捕获 140

9.2.1为什么要就地捕获 140

9.2.2如何就地捕获异常 141

9.2.3如何捕获多种异常 142

9.2.4用finally保证安全性 145

9.3异常的向前抛出 147

9.3.1为什么要向前抛出 147

9.3.2如何向前抛出 147

9.4自定义异常 151

9.4.1为什么需要自定义异常 151

9.4.2如何自定义异常 152

9.5小结 155

第10章 Java常用API 156

10.1数值运算 156

10.1.1用Math类实现数值运算 156

10.1.2实现随机数 158

10.2用String类进行字符串处理 159

10.3用StringBuffer类进行字符串处理 162

10.4基本数据类型的包装类 165

10.4.1认识包装类 165

10.4.2通过包装类进行数据转换 165

10.5认识Java集合 165

10.5.1为什么需要集合 165

10.5.2 Java中的集合 166

10.6使用一维集合 167

10.6.1认识一维集合 167

10.6.2使用List集合 167

10.6.3使用Set集合 169

10.6.4使用Collections类对集合进行处理 172

10.6.5使用泛型简化集合操作 174

10.7 Java中的二维集合 175

10.7.1使用Map集合 175

10.7.2使用 Hashtable和Properties 177

10.8小结 178

第11章 Java IO操作 179

11.1认识IO操作 179

11.2用File类操作文件 180

11.2.1认识File类 180

11.2.2使用File类操作文件 181

11.2.3使用File类操作目录 182

11.3字节流的输入输出 183

11.3.1认识字节流 183

11.3.2如何读写文件 184

11.3.3如何读写对象 187

11.4字符流的输入输出 190

11.4.1认识字符流 190

11.4.2如何读写文件 191

11.4.3如何进行键盘输入 193

11.5和IO操作相关的其他类 195

11.5.1用RandomAccessFile类进行文件读写 195

11.5.2使用Properties类 196

11.6小结 199

第12章 多线程开发 200

12.1认识多线程 200

12.1.1为什么需要多线程 200

12.1.2继承Thread类开发多线程 202

12.1.3实现Runnable接口开发多线程 204

12.1.4两种方法有何区别 206

12.2控制线程运行 207

12.2.1为什么要控制线程运行 207

12.2.2传统方法的安全问题 207

12.2.3如何控制线程的运行 208

12.3线程同步安全 210

12.3.1什么是线程同步 210

12.3.2一个有问题的案例 211

12.3.3如何解决 213

12.3.4小心线程死锁 215

12.4认识定时器 217

12.4.1为什么需要定时器 217

12.4.2如何使用定时器 217

12.5小结 220

第13章 反射技术 221

13.1为什么要学习反射 221

13.1.1引入配置文件 221

13.1.2配置文件遇到的问题 222

13.2认识Class类 223

13.2.1什么是Class类 223

13.2.2如何获取一个类对应的Class对象 223

13.2.3如何获取类中的成员信息 225

13.3通过反射机制访问对象 230

13.3.1如何实例化对象 230

13.3.2如何给成员变量赋值 232

13.3.3如何调用成员函数 233

13.4何时使用反射 234

13.5动态异常处理框架 235

13.5.1框架功能简介 235

13.5.2重要技术 237

13.5.3框架代码编写 238

13.5.4使用该框架 239

13.6小结 242

第14章 实验指导3 243

14.1字符频率统计软件 243

14.1.1软件功能简介 243

14.1.2重要技术 244

14.1.3项目结构 244

14.1.4代码编写 245

14.1.5思考题 247

14.2文本翻译软件 247

14.2.1软件功能简介 247

14.2.2重要技术 248

14.2.3项目结构 248

14.2.4代码编写 249

14.2.5思考题 251

14.3用享元模式优化程序性能 251

14.3.1为什么需要享元模式 251

14.3.2重要技术 252

14.3.3代码编写 252

14.3.4思考题 254

下篇 UML 257

第15章UML入门 257

15.1认识UML 257

15.1.1为什么需要UML 257

15.1.2 UML的来历 258

15.2用Rational Rose进行UML建模 259

15.2.1什么是Rational Rose 259

15.2.2安装Rational Rose 259

15.2.3如何使用Rational Rose 261

15.2.4 UML图的种类 262

15.3小结 263

第16章 用例图 264

16.1认识用例图 264

16.1.1为什么需要用例图 264

16.1.2什么是用例图 265

16.2详解用例图 265

16.2.1系统边界 265

16.2.2参与者 266

16.2.3用例 266

16.2.4箭头 267

16.2.5注释 268

16.2.6用Rational Rose画用例图 268

16.2.7用例规约 269

16.3一个案例 269

16.3.1案例描述 269

16.3.2画出用例图 269

16.3.3写出用例描述 269

16.4小结 271

第17章 类图和对象图 272

17.1认识类图 272

17.1.1为什么需要类图 272

17.1.2什么是类图 272

17.2详解类图 273

17.2.1类 273

17.2.2箭头 274

17.2.3注释 277

17.2.4用Rational Rose画类图 277

17.3对象图 278

17.4小结 278

第18章 实验指导4 279

18.1用例图练习 279

18.1.1软件功能简介 279

18.1.2识别系统中的参与者和用例 279

18.1.3画出用例图 280

18.1.4用例描述 280

18.2类图练习 286

18.2.1练习1：根据代码画出类图 286

18.2.2练习2：根据需求构建类图 286

18.3思考题 289

第19章 顺序图、协作图、状态图和活动图 290

19.1顺序图 290

19.1.1什么是顺序图 290

19.1.2详解顺序图 291

19.1.3用Rational Rose画顺序图 292

19.2协作图 292

19.2.1什么是协作图 292

19.2.2详解协作图 293

19.2.3用Rational Rose画协作图 293

19.3状态图 294

19.3.1什么是状态图 294

19.3.2详解状态图 294

19.3.3用Rational Rose画状态图 295

19.4活动图 295

19.4.1什么是活动图 295

19.4.2详解活动图 296

19.4.3用Rational Rose画活动图 297

19.5小结 297

第20章 包图、构件图和部署图 298

20.1包图 298

20.1.1什么是包图 298

20.1.2详解包图 298

20.1.3用Rational Rose画包图 299

20.2构件图 300

20.2.1什么是构件图 300

20.2.2详解构件图 300

20.2.3用Rational Rose画构件图 301

20.3部署图 301

20.3.1什么是部署图 301

20.3.2详解部署图 301

20.3.3用Rational Rose画部署图 302

20.4小结 302

第21章 实验指导5 303

21.1顺序图、协作图练习 303

21.1.1功能简介 303

21.1.2创建顺序图 303

21.1.3创建协作图 303

21.2状态图、活动图练习 304

21.2.1功能简介 304

21.2.2创建状态图 304

21.2.3创建活动图 305

21.3包图、构件图和部署图练习 306