Java入门1.2.3 一个老鸟的Java学习心得PDF电子书下载

第1篇Java语言基本语法 2

第1章 让自己的第一个Java程序跑起来 2

1.1想要用Java改变这个世界吗？ 2

1.1.1 Java有什么优势？ 2

1.1.2 Java在哪儿？ 3

1.2准备好开始Java之旅 3

1.2.1下载JDK 4

1.2.2安装JDK 5

1.2.3配置环境变量 6

1.2.4测试环境是否安装成功 8

1.2.5如果失败了怎么办？ 9

1.3让自己的第一个程序运行起来 10

1.3.1编写自己的Hello World源程序 10

1.3.2编译自己的HelloWorld程序 11

1.3.3让代码运行起来 13

1.4初探Hello World 14

1.4.1类（Class）：Java世界中一类物体 14

1.4.2方法（Method）：物体的功能 15

1.4.3 main（）方法：所有Java程序执行的起点 15

1.5名词解释 16

1.5.1 JDK和Java平台 16

1.5.2 Java编译器（Java Compiler） 17

1.5.3 Java类库（Java Class Libraries） 17

1.5.4 Java虚拟机（Java Virtual Machine） 17

1.5.5 HelloWorld的整个流程 17

1.6小结：我们学会了编译和运行一个Java程序！ 18

1.7习题 19

第2章 搭建自己的集成开发环境 20

2.1安装集成开发环境 20

2.1.1集成开发环境有哪些 20

2.1.2安装Eclipse 21

2.2 Eclipse界面介绍 23

2.2.1启动Eclipse 23

2.2.2 Eclipse的Perspective 24

2.2.3 Eclipse的菜单 25

2.2.4 Eclipse的工具条 25

2.2.5 Eclipse辅助视图区 25

2.2.6 Eclipse中Package Explorer 26

2.2.7 Eclipse中的源代码编辑器 26

2.2.8 Eclipse的设置窗口 26

2.2.9 Eclipse中的其他视图 27

2.3如何使用Eclipse 28

2.3.1在Eclipse中创建自己的第一个项目 28

2.3.2在Eclipse中编写HelloWorld程序 29

2.3.3通过Eclipse运行Hello World 31

2.4小结：Eclipse——功能很强大 32

2.5习题 32

第3章Java中的基本数据类型和运算符 33

3.1 Java中的基本数据类型 33

3.1.1基本数据类型——编程语言中的数据原子 33

3.1.2 Java中的基本上数据类型介绍 34

3.1.3基本数据类型值域 34

3.2 Java运算符 36

3.2.1变量的概念 36

3.2.2插曲：Java中的语句 37

3.2.3创建一个变量和变量名的规范 37

3.2.4 Java中的基本运算符和表达式 39

3.2.5 Java中的布尔运算符 43

3.3基本数据类型运算的难点 47

3.3.1强制类型转换——小数哪里去了 48

3.3.2类型的转换在运算中悄悄进行 50

3.3.3强制类型转换最优先 52

3.3.4等号其实不简单 52

3.3.5小心使用浮点数进行比较 53

3.3.6 boolean和char 55

3.3.7不要使用还没有创建出来的变量 57

3.3.8 String——char串起的项链 58

3.3.9转义符——看不见写得出 61

3.4小结：基本数据类型——Java中一切数据和运算的基础 63

3.5习题 65

第4章Java中的程序执行流程 67

4.1顺序执行 67

4.2使用if-else让程序懂得判断 68

4.2.1 if语句 68

4.2.2 if语句的嵌套 71

4.2.3 if-else语句 73

4.2.4 if-else语句嵌套 75

4.3使用while进行循环 76

4.3.1使用while语句 76

4.3.2使用do-while语句 79

4.4使用for进行循环 80

4.4.1自增和自减操作 80

4.4.2 for语句 82

4.4.3 for语句省略形式 84

4.5语句中不能不说的事 84

4.5.1小心复杂语句中创建的变量 85

4.5.2别让循环次数给弄懵了 86

4.5.3循环的嵌套 87

4.6 continue关键字与break关键字 88

4.6.1 continue关键字 88

4.6.2 break关键字 89

4.7使用switch进行跳转 90

4.8大例子 94

4.8.1从控制台读取数据 94

4.8.2结账程序中的循环 96

4.9小结： Java不是一个直肠子 98

4.10习题 99

第5章 数组 100

5.1什么是数组 100

5.1.1假设：如果需要逐个定义变量 100

5.1.2数组初探 101

5.1.3数组——物以类聚 104

5.1.4数组元素的值内有乾坤 105

5.1.5创建数组的简洁语法 106

5.2数组的“名”与“实” 107

5.2.1“名”与“实”分离的数组 107

5.2.2一“实”多“名”的数组 109

5.2.3一“实”多“名”带来的困惑 111

5.3多维数组 114

5.3.1什么是多维数组 114

5.3.2多维数组的实质 115

5.4数组大练兵 123

5.4.1轻松查询全班成绩 123

5.4.2轻松查询全校成绩不在话下 124

5.4.3杨辉三角 125

5.5小结：方便快速的数组 129

5.6习题 129

第2篇Java语言高级语法 132

第6章Java的类（Class）和对象（Object） 132

6.1驾驶汽车向类（Class）的世界进发 132

6.1.1汽车带来的问题 132

6.1.1类的组成 134

6.1.3使用自定义的Car类 136

6.1.4类和对象 139

6.1.5源文件的存放 141

6.1.5理解引用 143

6.1.7 null关键字 145

6.2巧妙使用类中的属性 147

6.2.1在类中给每个变量一个初始值 147

6.2.2定义自己的引用 147

6.2.3使用点操作符的技巧 148

6.2.4类的数组 149

6.3小结：Java其实是个类和对象的世界 152

6.4习题 153

第7章Java中的方法——给汽车丰富多彩的功能 154

7.1方法：让汽车开动 154

7.1.1引出问题：开动汽车 154

7.1.2那么，方法到底是什么呢？ 155

7.1.3方法调用过程初探 156

7.2 Java普通方法的组成部分 157

7.2.1访问控制符：public 158

7.2.2返回值和关键字void 158

7.2.3方法名（Method Name） 159

7.2.4参数列表（Parameter List） 159

7.2.5方法体（Method Body） 160

7.2.6方法串串烧 160

7.3方法的参数：让汽车加速 161

7.3.1方法的参数：让汽车可以加速 161

7.3.2带参数的方法有何不同？ 162

7.3.3让方法有多个参数 163

7.4返回值：汽车超速了吗？ 164

7.4.1写一个有返回值的方法 164

7.4.2调用有返回值的方法 165

7.4.3发生了什么？如何使用方法的返回值？ 166

7.4.4使用return结束方法 166

7.5方法重载（overload）：给汽车加速添个限制 168

7.5.1什么是方法的签名 168

7.5.2什么是重载？为什么要重载？ 168

7.5.3给汽车加个重载的方法 169

7.5.4测试一下 169

7.5.5重载容易引发误解的两个地方——返回类型和形参名 170

7.5.6重载中的最难点——参数匹配原则 171

7.6使用类的实例作为方法参数 172

7.6.1超车方法：使用类实例做参数 172

7.6.2调用这个方法 173

7.6.3发生了什么 174

7.7加餐：局部变量和实例变量 175

7.7.1什么是局部变量（Local Variable） 175

7.7.2什么是实例变量（Instance Variable） 177

7.8 this关键字：指向对象自己的引用 177

7.8.1发现问题：当实例变量和局部变量重名 177

7.8.2经常深藏不露的 this关键字 178

7.8.3在方法中调用方法 179

7.9构造方法（Constructor） 181

7.9.1构造（Constructor）方法初探 181

7.9.2如何使用构造方法 182

7.9.3留个无参数的构造方法——给重要属性赋初始值 183

7.9.4在构造方法中调用构造方法 184

7.10方法大汇总 185

7.10.1本例中用到的类 186

7.10.2使用例程将本章的知识穿起来 189

7.11小结：多方位理解Java方法 191

7.12习题 192

第8章Java中的包（Package）命名习惯和注释 193

8.1 Java中的包（Package） 193

8.1.1 Java中的包 193

8.1.2在Eclipse中使用包 194

8.1.3天上掉下个package 197

8.1.4包带来了什么？ 197

8.2 import语句：化繁为简 200

8.2.1 import语句 200

8.2.2一网打尽包中所有类 201

8.2.3 import语句带来的小问题 202

8.2.4默认引入的包 204

8.3命名习惯大回顾 204

8.4 Java中的注释 205

8.4.1使用双斜杠的单行注释 205

8.4.2多行注释 206

8.4.3 Javadoc注释 206

8.5小结：包让 Java的类更清晰优雅 208

8.6习题 209

第9章 再看数组、字符串和main（）方法 210

9.1数组也是类 210

9.1.1得到数组的长度 210

9.1.2加餐：不可改变的fiinal变量 211

9.1.3多维数组的长度 212

9.1.4一维数组的clone（）方法 212

9.1.5当数组类型不再是基本数据类型 214

9.1.6多维数组的clone（）方法 217

9.2老朋友String类 220

9.2.1遍历String中的字符 220

9.2.2获取字符串中的一部分 222

9.2.3判断两个字符串是否相等 223

9.2.4判断字符串的开头和结尾 225

9.2.5分割字符串 225

9.2.6在字符串中查找子字符串或字符 226

9.2.7替换字符串中的内容 226

9.2.8 String对象——磐石刻字 227

9.3 String类的最佳拍档——StringBuffer类 227

9.3.1 StringBuffer：专业操纵字符 228

9.3.2 String和StringBuffer一个都不能少 229

9.4最熟悉的陌生人：main（）方法 229

9.4.1 main（）方法的参数 229

9.4.2 static关键字 232

9.4.3当方法遇到 static关键字 233

9.5小结：学会使用类中的方法 235

9.6习题 236

第10章 继承和多态 237

10.1继承——最优的解决方案 237

10.1.1饭前水果：实例变量的访问控制符 237

10.1.2一切还是从汽车开始 238

10.1.3一类车，一个类 241

10.1.4分开也有麻烦 244

10.1.5使用继承——问题迎刃而解 245

10.1.6使用Bus类 248

10.1.7 Java中的单继承 248

10.1.8 Java中的类图 249

10.1.9万类之祖——Object类 250

10.2子类对象？父类对象？ 251

10.2.1父随子行 251

10.2.2当构造方法遇到继承 254

10.2.3记得给类一个无参数的构造方法 255

10.2.4调用父类中的构造方法 256

10.2.5对象也会“变脸” 258

10.2.6遵守语法，正确“变脸” 262

10.3覆盖——与继承如影随形 264

10.3.1当方法不再通用 264

10.3.2覆盖——让众口不再难调 265

10.3.3覆盖——到底调用了哪个方法 270

10.3.4覆盖的语法不简单 272

10.3.5更复杂的使用覆盖的情况 274

10.3.6覆盖——不得不打开的潘多拉魔盒 276

10.3.7使用super调用父类中的方法和属性 278

10.4多态（Polymorphism）以及其他 279

10.4.1多态——运行方知结果 280

10.4.2重载也不简单 280

10.4.3使用多态构建车队 283

10.5在多态的环境中拨开迷雾 284

10.5.1神秘的Class类 284

10.5.2覆盖不再神秘 285

10.5.3 instanceof运算符——让对象告诉你它的类是谁 286

10.6小结：继承和多态让世界丰富多彩 287

10.7习题 290

第11章 修饰符（Qualifiier） 291

11.1插曲：类的组成部分的名字 291

11.2类中的修饰符 292

11.2.1无修饰符类 292

11.2.2类的可见性 293

11.2.3 fiinal——让类不可被继承 295

11.2.4理解fiinal关键字 296

11.2.5总结：类的修饰符 297

11.3方法的修饰符 297

11.3.1方法的访问控制符 298

11.3.2 public：没有限制的修饰符 299

11.3.3 protected：仅对子类和同包的类可见 300

11.3.4默认控制符：仅在本包中可见 301

11.3.5 private：仅对本类可见 303

11.3.6理解4个访问控制符 304

11.3.7访问控制符可见性汇总 306

11.3.8访问控制符带来的覆盖问题 306

11.3.9 final：不允许方法被覆盖 310

11.3.10重温静态方法 311

11.3.11静态方法——类范围里的概念 312

11.3.12静态方法何以为“静态” 314

11.4变量的修饰符 316

11.4.1变量方法皆成员 317

11.4.2变量的访问控制符 317

11.4.3使用private修饰类的成员变量 318

11.4.4使用private，然后呢？ 320

11.4.5变量的覆盖 322

11.4.6使用fiinal修饰成员变量 325

11.4.7静态成员变量 326

11.4.8局部变量的修饰符 326

11.4.9当fiinal遇到引用类型成员变量 327

11.5小结：修饰符作用大 328

11.6习题 330

第12章 接口 331

12.1自行车带来的问题 331

12.1.1记录马路上的车辆 331

12.1.2引发问题的自行车 335

12.1.3仔细分析recordTransport（）方法 338

12.2初用接口 339

12.2.1准备好需要用到的类 339

12.2.2认识接口的代码组成 340

12.2.3什么是接口 341

12.2.4使用接口仅需一步——实现接口 342

12.2.5接口——让类集多重类型于一身 344

12.2.6简化recordTransport（）方法 347

12.3再探接口 349

12.3.1重温上节中的程序 349

12.3.2面向接口编程 351

12.3.3话说“抽象” 353

12.3.4接口大瘦身 355

12.3.5实现多个接口 355

12.3.6接口中的变量 357

12.3.7接口的继承 358

12.3.8匹配抽象方法中的类型 359

12.3.9空接口 361

12.4小结：接口的难点在于何时使用 362

12.5习题 364

第13章 抽象类和内部类 365

13.1抽象类（Abstract Class） 365

13.1.1不知道怎么打招呼的Person类 365

13.1.2当类中有了抽象方法 367

13.1.3抽象类语法详解 368

13.1.4理解抽象类的作用 369

13.2内部类的分类（Inner Class） 370

13.2.1成员内部类 370

13.2.2局部内部类 372

13.3成员内部类 374

13.3.1使用成员内部类 374

13.3.2成员内部类的修饰符 375

13.3.3在类外部使用内部类 376

13.3.4非静态内部类的特性 378

13.3.5外部类访问成员内部类中的属性 382

13.3.6静态成员内部类 383

13.4局部内部类 384

13.4.1局部内部类之“局部” 385

13.4.2局部内部类之“内部类” 386

13.4.3使用局部内部类 388

13.5匿名内部类（Anonymous inner classes） 389

13.5.1准备工作 389

13.5.2匿名内部类的语法 389

13.5.3通过接口使用匿名类 390

13.5.4通过抽象类使用匿名类 391

13.6类，这样一路走来 391

13.7小结：丰富多彩的类 395

13.8 习题 397

第14章Java的异常处理机制 398

14.1认识异常 398

14.1.1异常什么时候发生 398

14.1.2异常是什么 401

14.1.3 Java异常机制的流程 401

14.2抛出异常 403

14.2.1异常类的父类——Throwable 403

14.2.2在代码中使用throw抛出一个异常 404

14.2.3在方法声明中使用throws 407

14.2.4构造自定义异常类 409

14.2.5使用自定义异常类 410

14.3异常的传递 411

14.3.1抛出最确切的异常类型 411

14.3.2 Java异常的传递 412

14.3.3图说Java异常的传递 414

14.4异常的处理 418

14.4.1把异常捉住 418

14.4.2图说异常处理流程 421

14.4.3多类异常，一并处理 424

14.4.4 try-catch-finally语句 426

14.4.5 try-finally语句 431

14.4.6好好利用catch语句 432

14.5异常的类型 433

14.5.1 3个类的继承关系 433

14.5.2必须处理的Exception类 434

14.5.3灵活掌握的RuntimeException类 434

14.5.4不用处理的Error类 435

14.6小结：终止错误的蔓延 435

14.7习题 437

第15章 多线程编程 438

15.1线程——执行代码的机器 438

15.1.1线程——执行代码的基本单位 438

15.1.2演奏会模型 440

15.2 Java中的线程编程 443

15.2.1线程类Thread 443

15.2.2覆盖Thread类的run（）方法 444

15.2.3使用Runnable接口 446

15.2.4两个线程 448

15.3深入学习Thread类 449

15.3.1线程的名字 449

15.3.2得到当前的线程 451

15.3.3让线程“沉睡” 453

15.4多个线程的故事 457

15.4.1一个有多个线程的程序 457

15.4.2复印社模型 459

15.4.3一个简单的复印社例程 461

15.5多个线程的同步 463

15.5.1线程同步之synchronized关键字 463

15.5.2深入学习synchronized关键字 468

15.5.3静态同步方法 469

15.5.4非静态的同步方法 472

15.5.5银行的麻烦——账户乱套了 474

15.5.6多角度理解同步方法 481

15.5.7闲话同步方法的使用 484

15.5.8同步代码块 485

15.5.9锁（Lock） 486

15.5.10线程同步之wait（）和notify（）方法 488

15.5.11 wait和notify的顺序 491

15.6小结：线程——代码执行器 494

15.7习题 495

第3篇Java语言编程进阶 498

第16章 如何学习本篇 498

16.1多想多写多练 498

16.2术业有专攻 498

16.3拆分问题，逐个击破 500

16.4阅读Javadoc 500

16.5小结：大练兵马上开始 506

16.6习题 507

第17章 编程常用知识 508

17.1再谈对象的比较 508

17.1.1 hashcode（）方法 508

17.1.2 equals（）方法 509

17.1.3对象的比较equals（）方法 509

17.2 Java中的集合类框架 510

17.2.1集合类框架中的接口 510

17.2.2 List接口 511

17.2.3使用ArrayList 512

17.2.4 Set接口 516

17.2.5使用HashSet类 517

17.2.6 List与Set 518

17.3泛型简介 518

17.3.1没有泛型时的程序 519

17.3.2使用泛型——避免强制类型转 520

17.4 Map接口 522

17.4.1认识Map 522

17.4.2使用HashMap 523

17.5字符集和编码 524

17.5.1字符集 524

17.5.2编码 525

17.5.3关于字符集的小程序 526

17.6小结：编程需要打好基础 529

17.7习题 530

第18章Java文件编程和Java文件I/O 531

18.1 Java中的文件编程 531

18.1.1 File类 531

18.1.2创建和删除文件 532

18.1.3列出文件和文件夹 533

18.1.4重命名文件 535

18.2 Java的I/O编程 536

18.2.1理解Java中的Stream 536

18.2.2向文件中写入数据 538

18.2.3从文件中读取数据 539

18.2.4从控制台读取数据 541

18.2.5使用输出流写入数据 543

18.2.6使用输入流读取数据 545

18.3小结：Java中的文件类和输入输出机制 546

18.4习题 547

第19章Java Socket编程 548

19.1 IP地址和端口号 548

19.1.1 IP地址——计算机的标识 548

19.1.2端口号——通信的窗口 549

19.1.3网络IP地址和端口号 551

19.2 Java TCP编程 551

19.2.1数据传输协议 552

19.2.2 TCP的数据传输模式 552

19.2.3第一个TCP小程序 553

19.3 Java UDP编程 557

19.3.1 UDP的数据传输模式 557

19.3.2使用UDP协议收发数据 558

19.3.3 TCP和UDP的区别 560

19.4小结：让程序伸向整个网络 561

19.5习题 561

第20章Java Swing编程 562

20.1 Java Swing编程简介 562

20.1.1图形用户界面编程简介 562

20.1.2组件 563

20.1.3布局管理器（Layout Manager） 563

20.1.4事件处理（Event Handling） 564

20.2 Swing基本组件 565

20.2.1窗口（JFrame） 565

20.2.2 Swing的线程 567

20.2.3 Swing组件的鼻祖——JComponent 567

20.2.4 Swing面板类 568

20.2.5 Swing中的标签 568

20.2.6 Swing中的文本框 570

20.2.7 Swing中的文本域 571

20.2.8 Swing中的组合框 572

20.2.9 Swing中的按钮 573

20.3 Swing的布局管理器 574

20.3.1最简单的FlowLayout 574

20.3.2东南西北中之BorderLayout 574

20.3.3平均分割之——GridLayout 576

20.3.4最强大的布局管理器——GridBagLayout 577

20.3.5使用多个布局管理器 579

20.4 Swing的事件处理 581

20.4.1事件的传递和封装 581

20.4.2事件监听器——事件的处理者 582

20.4.3 Swing事件处理的机制 584

20.4.4事件监听器的编写 586

20.4.5如何学习更多的事件 588

20.5小结：从此不再依赖控制台 588

20.6习题 588

第21章 编程，需要的是想象力和恒心 589

21.1编程的前奏 589

21.1.1细数手中的积木 589

21.1.2发挥想象力 590

21.1.3确定程序的功能 591

21.2聊天窗口程序 591

21.2.1聊天程序设计 591

21.2.2设计程序运行效果 593

21.2.3 UDP消息收发模块 595

21.2.4图形用户界面模块 598

21.2.5消息处理模块 600

21.2.6一个更通用的聊天程序 601

21.3小结：编程是必不可少的锻炼 602

21.4习题 602

第22章JDBC入门 603

22.1 JDBC的基本API 603

22.1.1 JDBC是什么 603

22.1.2 DriverManager——驱动管理器 605

22.1.3 Connection接口 606

22.1.4 Statement接口 606

22.1.5 PreparedStatement接口 606

22.1.6 ResultSet接口 607

22.1.7 JDBC-ODBC桥 607

22.2一个操作数据库的简单程序 608

22.2.1程序的执行结果 608

22.2.2程序设计与模块划分 609

22.2.3准备好数据源 610

22.2.4数据库操作模块的实现 610

22.2.5图形用户界面模块的实现 611

22.3小结：强大的JDBC标准 613

22.4习题 613