Java编程实践指南

需积分: 3 168 浏览量更新于2024-07-24 收藏 3.9MB PDF 举报

"JAVA CookBook" 《JAVA CookBook》是一本由Ian Darwin编著，O'Reilly出版社出版的Java开发指南，第一版发行于2001年6月，ISBN为0-59600-170-3，共计882页。这本书面向Java开发者，提供了一系列简洁、实用的代码片段，便于读者将这些代码整合到自己的项目中。作者旨在关注那些在编程过程中既有用又具有挑战性的内容。书中涵盖了主要的API，为希望涉足自己专业领域之外的Java开发者提供了一个良好的起点。本书的内容分为多个部分，包括但不限于以下几个方面： 1. **前言**：简要介绍书籍的目标读者群体、书中的主要内容、平台注意事项、其他相关书籍推荐以及本书采用的编写规范。 2. **开始：编译、运行与调试**：这部分内容教导读者如何使用JDK进行Java程序的编译和运行，如何利用带有语法高亮功能的编辑器提高编码效率，以及如何在集成开发环境（IDE）如Eclipse或IntelliJ IDEA中完成编译、运行和测试工作。此外，还介绍了如何使用本书中的类，以及如何利用自动化工具如`jr`、`make`和Apache Ant进行编译自动化。对于Web应用程序，书中还讲解了如何运行Applet以及如何处理依赖问题。 3. **类库和API的使用**：这部分可能涉及Java标准库的各种API，如集合框架、I/O流、网络编程、多线程、反射、异常处理等，通过实例代码展示如何有效利用这些API。 4. **对象和类的设计**：涵盖类的定义、继承、封装、抽象类和接口，以及设计模式的应用。 5. **数据存储和持久化**：包括文件操作、数据库连接、SQL查询、JDBC操作，以及可能涉及的NoSQL数据库使用。 6. **用户界面和图形编程**：讲解如何使用Swing、JavaFX等库创建GUI，以及事件处理和图形绘制。 7. **高级话题**：可能包含并发编程、垃圾回收、性能优化、单元测试、JVM调优等进阶主题。 8. **错误处理和调试**：介绍如何有效地识别和解决编程中的错误，以及使用调试工具进行程序调试。 9. **附录和索引**：提供完整的索引，方便读者查找特定话题，以及关于作者、读者评论、勘误表等信息。通过学习《JAVA CookBook》，Java开发者不仅可以深化对语言本身的理解，还能掌握各种实际应用场景下的编程技巧，提升工作效率。无论你是初学者还是经验丰富的开发者，这本书都是一份宝贵的参考资料。

Peter Coad's Java Design (PTR-PH/Yourdon Press) discusses the issues of object-oriented

analysis and design specifically for Java. Coad is somewhat critical of Java's implementation of

the observable-observer paradigm and offers his own replacement for it.

One of the most famous books on object-oriented design in recent years is Design Patterns, by

Gamma, Helm, Johnson, and Vlissides (Addison Wesley). These authors are often collectively

called "the gang of four," resulting in their book sometimes being referred to as "the GOF book."

One of my colleagues called it "the best book on object-oriented design ever," and I think he's

probably not far off the mark.

Another group of important books on object-oriented design is the UML series by "the Three

Amigos" (Booch, Jacobson, and Rumbaugh). Their major works are the UML User Guide, UML

Process, and others. A smaller and more approachable book in the same series is Martin

Fowler's UML Distilled.

Conventions Used in This Book

This book uses the following conventions.

Programming Conventions

I use the following terminology in this book. A program means either an applet, a servlet, or an

application. An applet is for use in a browser. A servlet is similar to an applet but for use in a

server. An application is any other type of program. A desktop application (a.k.a. client) interacts

with the user. A server program deals with a client indirectly, usually via a network connection.

The examples shown are in two varieties. Those that begin with zero or more import statements,

a Javadoc comment, and a public class statement are complete examples. Those that begin with

a declaration or executable statement, of course, are excerpts. However, the full versions of

these excerpts have been compiled and run, and the online source includes the full versions.

Recipes are numbered by chapter and number, so, for example, Recipe 7.5 refers to the fifth

recipe in Chapter 7.

Typesetting Conventions

The following typographic conventions are used in this book:

Italic

is used for commands, filenames, and sample URLs. It is also used to define new terms

when they first appear in the text.

Constant width

is used in code examples to show partial or complete Java source code program listings.

It is also used for class names, method names, variable names, and other fragments of

Java code.

Many programs are accompanied by an example showing them in action, run from the command

line. These will usually show a prompt ending in either $ for Unix or > for Microsoft, depending on

which computer I was using that day. Text before this prompt character can be ignored; it will be

a pathname or a hostname, again depending on the system.

Comments and Questions

As mentioned earlier, I've tested all the code on at least one of the reference platforms, and most

on several. Still, there may be platform dependencies, or even bugs, in my code or in some

important Java implementation. Please report any errors you find, as well as your suggestions for

future editions, by writing to:

O'Reilly & Associates, Inc.

101 Morris Street

Sebastopol, CA 95472

(800) 998-9938 (in the United States or Canada)

(707) 829-0515 (international or local)

(707) 829-0104 (fax)

To ask technical questions or comment on the book, send email to:

bookquestions@oreilly.com

There is an O'Reilly web site for the book, listing errata, examples, or any additional information.

You can access this page at:

http://www.oreilly.com/catalog/javacook/

I also have a personal web site for the book:

http://javacook.darwinsys.com

Both sites will list errata and plans for future editions. You'll also find the source code for all the

Java code examples to download; please don't waste your time typing them in again! For specific

instructions, see the next section.

Getting the Source Code

From my web site http://javacook.darwinsys.com, just follow the Download link and you will

be presented with three choices:

1. Download the entire source archive as a single large zip file

2. Download individual source files, indexed alphabetically as well as by chapter

3. Download the binary JAR file for the com.darwinsys.util package needed to compile

many of the other programs

Most people will choose either #1 or #2, but anyone who wants to compile my code will need #3.

See Section 1.5 for information on using these files.

Downloading the entire source archive (#1) gives a large zip file that contains all the files from the

book (and more). This archive can be unpacked with jar (see Section 23.4), the free zip

program from Info-ZIP, the commercial WinZip or PKZIP, or any compatible tool. The files are

organized into subdirectories by topic; there is one for strings (Chapter 3), regular expressions

(Chapter 4), numbers (Chapter 5) and so on. The archive also contains the index by name and

index by chapter files from the download site, so you can easily find the files you need.

Downloading individual files is easy too: simply follow the links either by the file/subdirectory

name or by chapter. Once you see the file you want in your browser, use File->Save or the

equivalent, or just copy and paste it from the browser into an editor or IDE.

The files will be updated periodically, so if there are differences between what's printed in the

book and what you get, be glad, for you'll have received the benefit of hindsight.

Acknowledgments

My life has been touched many times by the flow of the fates bringing me into contact with the

right person to show me the right thing at the right time. Steve Munroe, with whom I've long since

lost touch, introduced me to computers -- in particular an IBM 360/30 at the Toronto Board of

Education that was bigger than a living room, had 32 or 64K of memory, and had perhaps the

power of a PC/XT -- in 1970. (Are you out there somewhere, Steve?) Herb Kugel took me under

his wing at the University of Toronto while I was learning about the larger IBM mainframes that

came later. Terry Wood and Dennis Smith at the University of Toronto introduced me to mini- and

micro-computers before there was an IBM PC. On evenings and weekends, the Toronto Business

Club of Toastmasters International (http://www.toastmasters.org) and Al Lambert's Canada

SCUBA School allowed me to develop my public speaking and instructional abilities. Several

people at the University of Toronto, but especially Geoffrey Collyer, taught me the features and

benefits of the Unix operating system at a time when I was ready to learn it.

Greg Davidson of UCSD taught the first Learning Tree course I attended, and welcomed me as a

Learning Tree instructor. Years later, when the Oak language was about to be released on Sun's

web site, Greg encouraged me to write to James Gosling and find out about it. James's reply of

March 29th, 1995, that the lawyers had made them rename the language to Java and that it was

"just now" available for download, is the prized first entry in my saved Java mailbox. Mike Rozek

took me on as a Learning Tree course author for a Unix course and two Java courses. After

Mike's departure from the company, Francesco Zamboni, Julane Marx, and Jennifer Urick in turn

provided product management of these courses. Jennifer also arranged permission for me to

"reuse some code" in this book that had previously been used in my Java course notes. Finally,

thanks to the many Learning Tree instructors and students who showed me ways of improving

my presentations. I still teach for "The Tree" and recommend their courses for the busy developer

who wants to zero in on one topic in detail over four days. Their web site is

http://www.learningtree.com.

Closer to this project, Tim O'Reilly believed in "the little Lint book" when it was just a sample

chapter, enabling my early entry into the circle of O'Reilly authors. Years later, Mike Loukides

encouraged me to keep trying to find a Java book idea that both he and I could work with. And he

stuck by me when I kept falling behind the deadlines. Mike also read the entire manuscript and

made many sensible comments, some of which brought flights of fancy down to earth. Jessamyn

Read turned many faxed and emailed scratchings of dubious legibility into the quality illustrations

you see in this book. And many, many other talented people at O'Reilly & Associates helped put

this book into the form in which you now see it.

I also must thank my reviewers, first and foremost my dear wife Betty Cerar, who may still think

Java is some kind of caffeinated beverage that I drink while programming, but whose passion for

clear expression and correct grammar has benefited much of my writing. Jonathan Knudsen,

Andy Oram, and David Flanagan commented on the outline when it was little more than a list of

chapters and recipes, and yet were able to see the kind of book it could become, and to suggest

ways to make it better. Learning Tree instructor Jim Burgess read most of the book with a very

critical eye on locution, formulation, and code. Bil Lewis and Mike Slinn (mslinn@mslinn.com)

made helpful comments on multiple drafts of the book. Ron Hitchens (ron@ronsoft.com) and

Marc Loy carefully read the entire final draft. Editor Sue Miller helped shepherd the manuscript

through the somewhat energetic final phases of production. Sarah Slocombe read the XML

chapter in its entirety and made many lucid suggestions, though unfortunately time did not permit

me to include all of them. Each of these people made this book better in many ways, particularly

by suggesting additional recipes or revising existing ones. Any faults that remain are surely my

own.

I've used a variety of tools and operating systems in preparing, compiling, and testing the book.

The developers of OpenBSD (http://www.openbsd.org), "the proactively secure Unix-like

system," deserve thanks for making a stable and secure Unix clone that is also closer to

traditional Unix than other freeware systems. I used the vi editor (vi on OpenBSD and vim on MS-

Windows) while inputting the original manuscript in XML, and Adobe FrameMaker to format the

documents. Each of these is an excellent tool in its own way. If you're wondering how I got from

XML to Frame, the answer will be given in Chapter 21.

No book on Java would be complete without a quadrium

[4]

of thanks to James Gosling for

inventing the first Unix Emacs, the sc spreadsheet, the NeWS window system, and Java. Thanks

also to his employer Sun Microsystems (NASDAQ SUNW) for creating not only the Java

language but an incredible array of Java tools and API libraries freely available over the Internet.

[4]

It's a good thing he only invented four major technologies, not five, or I'd have to rephrase that to avoid

infringing on an Intel trademark.

Thanks to Tom and Nathan, for the Perl Cookbook. Without them I might never have come up

with the format for this book.

Willi Powell of Apple Canada provided MacOS X access.

Thanks to the Tim Horton's Donuts in Bolton, Ontario for great coffee and for not enforcing the

20-minute table limit on the weird guy with the computer.

To each and every one of you, my sincere thanks.

1 Getting Started: Compiling, Running, and

Debugging

1.1 Introduction

This chapter covers some entry-level tasks that you simply need to know how to do before you

can go on -- it is said you must crawl before you can walk, and walk before you can ride a bicycle.

Before you can try out anything else in the book, you need to be able to compile and run your

Java, so I start there, showing several ways: the JDK way, the Mac way, and the Integrated

Development Environment (IDE) way. Then I'll discuss a few details about applets, in case you

are working on them. Deprecation warnings come next, as you're likely to meet them in

maintaining "old" Java code.

[1]

There is humor in the phrase "old Java code," which should be apparent when you realize that Java has

been in circulation for under five years at the time of this book's first printing.

If you're already happy with your IDE, you may wish to skip some or all of this material. It's here

to ensure that everybody can compile and debug their programs before we move on.

1.2 Compiling and Running Java: JDK

1.2.1 Problem

You need to compile and run your Java program.

1.2.2 Solution

This is one of the few areas where your computer's operating system impinges into Java's

portability, so let's get it out of the way first.

1.2.2.1 JDK

Using the command-line Java Development Kit (JDK) may be the best way to keep up with the

very latest improvements from Sun/JavaSoft. This is not the fastest compiler available by any

means; the compiler is written in Java and interpreted at compile time, making it a sensible

bootstrapping solution, but not necessarily optimal for speed of development. Nonetheless, using

Sun's JDK (or Java SDK), the commands are javac to compile and java to run your program. For

example:

C:\javasrc>javac HelloWorld.java

C:\javasrc>java HelloWorld

Hello, World

C:\javasrc>

As you can see from the compiler's (lack of) output, this compiler works on the Unix "no news is

good news" philosophy: if a program was able to do what you asked it to, it shouldn't bother

nattering at you to say that it did so. Many people use this compiler or one of its clones. The javac

and java commands are available with the JDK on both Windows and Unix, and under MacOS X

if you have installed the bundled Developer Tools package.

剩余710页未读，继续阅读

zhouyoutest

粉丝: 0
资源: 2

Java编程实践指南

Java Cookbook(3rd) 无水印pdf

javacookbook

JavaCookBook

JavaCookbook.pdf

java:Java Cookbook的开发存储库

The Common Java Cookbook 2009

JavaCookBook(2nd)

java-cookbook-examples:通过 Java Cookbook 2nd 中的示例学习 Java 秘诀。 埃德。 伊恩·F·达尔文

Java Cookbook - Problems and Solutions for Java Developers

JavaCookBook(part2)

最新资源

java-cookbook-examples:通过 Java Cookbook 2nd 中的示例学习 Java 秘诀。埃德。伊恩·F·达尔文