Java™ Programming Language, The, 4th Edition
- By Ken Arnold, James Gosling, David Holmes
- Published Aug 17, 2005 by Addison-Wesley Professional. Part of the Java Series series.
- Copyright 2006
- Dimensions: 7-3/8x9-1/4
- Pages: 928
- Edition: 4th
- ISBN-10: 0-321-34980-6
- ISBN-13: 978-0-321-34980-4
Register your product to gain access to bonus material or receive a coupon.
Product Author Bios
Ken Arnold, formerly senior engineer at Sun Microsystems Laboratories, is a leading expert in object-oriented design and implementation. He was one of the original architects of the Jini™ technology, and the lead engineer of Sun's JavaSpaces™ technology.
James Gosling is a Fellow and Chief Technology Officer of Sun's Developer Products group, the creator of the Java programming language, and one of the computer industry's most noted programmers. He is the 1996 recipient of Software Development's "Programming Excellence Award." He previously developed NeWS, Sun's network-extensible window system, and was a principal in the Andrew project at Carnegie Mellon University, where he earned a Ph.D. in computer science.
David Holmes is director of DLTeCH Pty Ltd, located in Brisbane, Australia. He specializes in synchronization and concurrency and was a member of the JSR-166 expert group that developed the new concurrency utilities. He is also a contributor to the update of the Real-Time Specification for Java, and has spent the past few years working on an implementation of that specification.
Direct from the creators of the Java programming language, the completely revised fourth edition of The Java Programming Language is an indispensable resource for novice and advanced programmers alike.
Developers around the world have used previous editions to quickly gain a deep understanding of the Java programming language, its design goals, and how to use it most effectively in real-world development. Now, Ken Arnold, James Gosling, and David Holmes have updated this classic to reflect the major enhancements in Java 2 Standard Edition 5.0 (J2SE 5.0).
The authors systematically cover most classes in Javas main packages, java.lang.*, java.util, and java.io, presenting in-depth explanations of why these classes work as they do, with informative examples. Several new chapters and major sections have been added, and every chapter has been updated to reflect todays best practices for building robust, efficient, and maintainable Java software.
Key changes in this edition include
- New chapters on generics, enums, and annotations, the most powerful new language features introduced in J2SE 5.0
- Changes to classes and methods throughout to reflect the addition of generics
- Major new sections on assertions and regular expressions
- Coverage of all the new language features, from autoboxing and variable argument methods to the enhanced for-loop and covariant return types
- Coverage of key new classes, such as Formatter and Scanner
The Java Programming Language, Fourth Edition, is the definitive tutorial introduction to the Java language and essential libraries and an indispensable reference for all programmers, including those with extensive experience. It brings together insights you can only get from the creators of Java: insights that will help you write software of exceptional quality.
88 of 93 people found the following review helpful
Concise but complete Java Language Model,Read more
24 of 24 people found the following review helpful
exellent java book,
By A Customer
The book offers enough depth that it requires few different re-reads for most people.
I think the book is on par with the "C programming language" as a reference of the language, I also like the layout of the page, very easy on the eyes to help the reading. It comes with good examples. The book is printed on high quality paper...
A must have JAVA book, but not the first java book for... Read more
20 of 20 people found the following review helpful
The only book you need to learn the "Java Language",
Other books that you may like to take a look at are:
1) Thinking in Java. This is available on the for Free(But its too verbose for my... Read more
› See all 70 customer reviews...
Online Sample Chapter
Download the Index
file related to this title.
--Frank Lloyd Wright
The Java programming language has been warmly received by the world community of software developers and Internet content providers. Users of the Internet and World Wide Web benefit from access to secure, platform-independent applications that can come from anywhere on the Internet. Software developers who create applications in the Java programming language benefit by developing code only once, with no need to "port" their applications to every software and hardware platform.
For many, the language was known first as a tool to create applets for the World Wide Web. An applet is a mini-application that runs inside a Web page. An applet can perform tasks and interact with users on their browser pages without using resources from the Web server after being downloaded. Some applets may, of course, talk with the server to do their job, but that's their business.
The Java programming language is indeed valuable for distributed network environments like the Web. However, it goes well beyond this domain to provide a powerful general-purpose programming language suitable for building a variety of applications that either do not depend on network features, or want them for different reasons. The ability to execute downloaded code on remote hosts in a secure manner is a critical requirement for many organizations.
Other groups use it as a general-purpose programming language for projects in which machine independence is less important. Ease of programming and safety features help you quickly produce working code. Some common programming errors never occur because of features like garbage collection and type-safe references. Support for multithreading caters to modern network-based and graphical user interface-based applications that must attend to multiple tasks simultaneously, and the mechanisms of exception handling ease the task of dealing with error conditions. While the built-in tools are powerful, it is a simple language in which programmers can quickly become proficient.
The Java programming language is designed for maximum portability with as few implementation dependencies as possible. An int, for example, is a 32-bit signed two's-complement integer in all implementations, irrespective of the CPU architecture on which the program executes. Defining everything possible about the language and its runtime environment enables users to run compiled code anywhere and share code with anyone who has a Java runtime environment.
About This BookThis book teaches the Java programming language to people who are familiar with basic programming concepts. It explains the language without being arduously formal or complete. This book is not an introduction to object-oriented programming, although some issues are covered to establish a common terminology. Other books in this series, and much online documentation, focus on applets, graphical interfaces, databases, components, and other specific kinds of programming tasks. For other references, see "Further Reading" at the end of the book.
This fourth edition provides integrated coverage of the Java programming language as provided by the Java 2 Platform Standard Edition 5.0, and specified by The Java Language Specification, Third Edition. It also covers most of the classes in the main packages (java.lang.*, java.util, java.io) as implemented in the J2SE Development Kit 5.0 (more commonly known as JDK 5.0, or in the older nomenclature JDK 1.5.0). If you have already read the third edition, you will find that there have been some major changes, both in the language and this book, since the 1.3 release that the third edition covered. There are new chapters on generics, enums and annotations--the major new language features introduced in the 5.0 release--and major new sections on assertions and regular expressions. There has been some restructuring of existing material to accommodate other changes and improve the general flow of the text--such as introducing the new boxing and unboxing conversions. But every single chapter has been updated in some way--whether it is a new language feature like variable argument methods, or the new enhanced for loop construct; or a new class such as Formatter for formatting text output; or changes to classes and methods caused by the addition of generics (such as the collections utilities and the reflection classes)--change permeates this entire fourth edition.
The Java programming language shares many features common to most programming languages in use today. The language should look familiar to C and C++ programmers because it was designed with C and C++ constructs where the languages are similar. That said, this book is neither a comparative analysis nor a "bridge" tutorial--no knowledge of C or C++ is assumed. C++ programmers, especially, may be as hindered by what they must unlearn as they are helped by their knowledge.
Chapter 1--A Quick Tour--gives a quick overview of the language. Programmers who are unfamiliar with object-oriented programming notions should read the quick tour, while programmers who are already familiar with object-oriented programming paradigms will find the quick tour a useful introduction to the object-oriented features of the language. The quick tour introduces some of the basic language features that examples through the rest of the book are built on.
Chapters 2, 3, 4, 5, and 6 cover the object-oriented core features of the language, namely, class declarations that define components of a program, and objects manufactured according to class definitions. Chapter 2--Classes and Objects--describes the basis of the language: classes. Chapter 3--Extending Classes--describes how an existing class can be extended, or subclassed, to create a new class with additional data and behavior. Chapter 4--Interfaces--describes how to declare interface types which are abstract descriptions of behavior that provide maximum flexibility for class designers and implementors. Chapter 5--Nested Classes and Interfaces--describes how classes and interfaces can be declared inside other classes and interfaces, and the benefits that provides. Finally, Chapter 6--Enumeration Types--covers the definition and use of type-safe enumeration constants.
Chapters 7, 8, 9, and 10 cover standard constructs common to most languages. Chapter 7--Tokens, Values and Variables--describes the tokens of the language from which statements are constructed, the types defined by the language and their allowed values, and the variables that are used to store data either in objects, arrays or locally within methods. Chapter 8--Primitives as Types--explores the relationship between the primitive types and objects of their corresponding wrapper classes, and how boxing and unboxing can transparently convert between them. Chapter 9--Operators, and Expressions--describes the basic operators of the language, how operators are used to build expressions, and how expressions are evaluated. Chapter 10--Control Flow--describes how control statements direct the order of statement execution.
Chapter 11--Generic Types--describes how generic types are written and used, their power and their limitations.
Chapter 12--Exceptions and Assertions--describes the language's powerful error-handling capabilities, and the use of assertions to validate the expected behavior of code.
Chapter 13--Strings and Regular Expressions--describes the built-in language and runtime support for String objects, the underlying character set support, and the powerful utilities for regular expression matching.
Chapter 14--Threads--explains the language's view of multithreading. Many applications, such as graphical interface-based software, must attend to multiple tasks simultaneously. These tasks must cooperate to behave correctly, and threads meet the needs of cooperative multitasking.
Chapter 16--Annotations--describes the annotation types used to document some of the extra-linguistic properties of classes and method.
Chapter 15--Reflection--describes the type introspection mechanism and how objects of unknown type can be constructed and manipulated dynamically at runtime.
Chapter 17--Garbage Collection and Memory--talks about garbage collection, finalization, and lower-strength reference objects.
Chapter 18--Packages--describes how you can group collections of classes and interfaces into separate packages.
Chapter 19--Documentation Comments--shows how to write reference documentation in comments.
Chapters 20 through 24 cover the main packages. Chapter 20--The I/O Package--describes the input/output system, which is based on streams. Chapter 21--Collections--covers the collection or container classes such as sets and lists. Chapter 22--Miscellaneous Utilities--covers the rest of the utility classes such as bit sets, formatted output, text scanning, and random number generation. Chapter 23--System Programming--leads you through the system classes that provide access to features of the underlying platform. Chapter 24--Internationalization and Localization--covers some of the tools used to create programs that can run in many linguistic and cultural environments.
Chapter 25--Standard Packages--briefly explores the packages that are part of the standard platform, giving overviews of those packages not covered in more detail in this book.
Appendix A--Application Evolution--looks at some of the issues involved in dealing with the evolution of applications and the Java platform, and the impact this has on some of the new language features.
Appendix B--Useful Tables--has tables of information that you may find useful for quick reference.
Finally, Further Reading lists works that may be interesting for further reading on complete details, object orientation, programming with threads, software design, and other topics.
Examples and Documentation
All the code examples in the text have been compiled and run on the latest version of the language available at the time the book was written, which was the JDK 1.5.0_02 product version. Only supported features are covered--deprecated types, methods, and fields are ignored except where unavoidable, or where knowledge of the past is necessary to understand the present. We have also covered issues beyond writing programs that simply compile. Part of learning a language is to learn to use it well. For this reason, we have tried to show principles of good programming style and design.
In a few places we refer to online documentation. Development environments provide a way to automatically generate documentation (usually HTML documents) from a compiled class using the documentation comments. This documentation is normally viewed using a Web browser.
Results! Why, man, I have gotten a lot of results.I know several thousand things
that won't work.
Table of Contents
Chapter 1: A Quick Tour 1
1.1 Getting Started 1
1.2 Variables 3
1.3 Comments in Code 6
1.4 Named Constants 7
1.5 Unicode Characters 8
1.6 Flow of Control 9
1.7 Classes and Objects 12
1.8 Methods and Parameters 15
1.9 Arrays 18
1.10 String Objects 21
1.11 Extending a Class 24
1.12 Interfaces 27
1.13 Generic Types 29
1.14 Exceptions 32
1.15 Annotations 35
1.16 Packages 36
1.17 The Java Platform 38
1.18 Other Topics Briefly Noted 39
Chapter 2: Classes and Objects 41
2.1 A Simple Class 42
2.2 Fields 44
2.3 Access Control 47
2.4 Creating Objects 49
2.5 Construction and Initialization 50
2.6 Methods 56
2.8 Overloading Methods 69
2.9 Importing Static Member Names 71
main Method 73
2.11 Native Methods 74
Chapter 3: Extending Classes 75
3.1 An Extended Class 76
3.2 Constructors in Extended Classes 80
3.3 Inheriting and Redefining Members 84
3.4 Type Compatibility and Conversion 90
protected Really Means 93
3.6 Marking Methods and Classes
3.7 Abstract Classes and Methods 97
Object Class 99
3.9 Cloning Objects 101
3.10 Extending Classes: How and When 107
3.11 Designing a Class to Be Extended 108
3.12 Single Inheritance versus Multiple Inheritance 114
Chapter 4: Interfaces 117
4.1 A Simple Interface Example 118
4.2 Interface Declarations 120
4.3 Extending Interfaces 122
4.4 Working with Interfaces 126
4.5 Marker Interfaces 130
4.6 When to Use Interfaces 131
Chapter 5: Nested Classes and Interfaces 133
5.1 Static Nested Types 133
5.2 Inner Classes 136
5.3 Local Inner Classes 142
5.4 Anonymous Inner Classes 144
5.5 Inheriting Nested Types 146
5.6 Nesting in Interfaces 148
5.7 Implementation of Nested Types 149
Chapter 6: Enumeration Types 151
6.1 A Simple Enum Example 151
6.2 Enum Declarations 152
6.3 Enum Constant Declarations 154
6.5 To Enum or Not 160
Chapter 7: Tokens, Values, and Variables 161
7.1 Lexical Elements 161
7.2 Types and Literals 166
7.3 Variables 169
7.4 Array Variables 173
7.5 The Meanings of Names 178
Chapter 8: Primitives as Types 183
8.1 Common Fields and Methods 184
8.6 Boxing Conversions 198
Chapter 9: Operators and Expressions 201
9.1 Arithmetic Operations 201
9.2 General Operators 204
9.3 Expressions 214
9.4 Type Conversions 216
9.5 Operator Precedence and Associativity 221
9.6 Member Access 223
Chapter 10: Control Flow 229
10.1 Statements and Blocks 229
10.6 Labels 241
10.10 What, No
Chapter 11: Generic Types 247
11.1 Generic Type Declarations 250
11.2 Working with Generic Types 256
11.3 Generic Methods and Constructors 260
11.4 Wildcard Capture 264
11.5 Under the Hood: Erasure and Raw Types 267
11.6 Finding the Right Method--Revisited 272
11.7 Class Extension and Generic Types 276
Chapter 12: Exceptions and Assertions 279
12.1 Creating Exception Types 280
throws Clause 283
12.5 Exception Chaining 291
12.6 Stack Traces 294
12.7 When to Use Exceptions 294
12.8 Assertions 296
12.9 When to Use Assertions 297
12.10 Turning Assertions On and Off 300
Chapter 13: Strings and Regular Expressions 305
13.1 Character Sequences 305
String Class 306
13.3 Regular Expression Matching 321
StringBuilder Class 330
13.5 Working with UTF-16 336
Chapter 14: Threads 337
14.1 Creating Threads 339
14.3 Synchronization 345
14.5 Details of Waiting and Notification 357
14.6 Thread Scheduling 358
14.7 Deadlocks 362
14.8 Ending Thread Execution 365
14.9 Ending Application Execution 369
14.10 The Memory Model: Synchronization and
14.11 Thread Management, Security, and
14.12 Threads and Exceptions 379
ThreadLocal Variables 382
14.14 Debugging Threads 384
Chapter 15: Annotations 387
15.1 A Simple Annotation Example 388
15.2 Annotation Types 389
15.3 Annotating Elements 392
15.4 Restricting Annotation Applicability 393
15.5 Retention Policies 395
15.6 Working with Annotations 395
Chapter 16: Reflection 397
Class Class 399
16.2 Annotation Queries 414
Modifier Class 416
16.4 The Member classes 416
16.5 Access Checking and
Field Class 418
Method Class 420
16.8 Creating New Objects and the
Constructor Class 423
16.9 Generic Type Inspection 426
16.10 Arrays 429
16.11 Packages 432
Proxy Class 432
16.13 Loading Classes 435
16.14 Controlling Assertions at Runtime 444
Chapter 17: Garbage Collection and Memory 447
17.1 Garbage Collection 447
17.2 A Simple Model 448
17.3 Finalization 449
17.4 Interacting with the Garbage Collector 452
17.5 Reachability States and Reference Objects 454
Chapter 18: Packages 467
18.1 Package Naming 468
18.2 Type Imports 469
18.3 Package Access 471
18.4 Package Contents 475
18.5 Package Annotations 476
18.6 Package Objects and Specifications 477
Chapter 19: Documentation Comments 481
19.1 The Anatomy of a Doc Comment 482
19.2 Tags 483
19.3 Inheriting Method Documentation Comments 489
19.4 A Simple Example 491
19.5 External Conventions 496
19.6 Notes on Usage 497
Chapter 20: The I/O Package 499
20.1 Streams Overview 500
20.2 Byte Streams 501
20.3 Character Streams 507
20.5 A Quick Tour of the Stream Classes 514
20.6 The Data Byte Streams 537
20.7 Working with Files 540
20.8 Object Serialization 549
IOException Classes 563
20.10 A Taste of New I/O 565
Chapter 21: Collections 567
21.1 Collections 567
21.2 Iteration 571
21.3 Ordering with
Collection Interface 575
enum Collections 594
21.10 Wrapped Collections and the
Collections Class 597
21.11 Synchronized Wrappers and Concurrent Collections 602
Arrays Utility Class 607
21.13 Writing Iterator Implementations 609
21.14 Writing Collection Implementations 611
21.15 The Legacy Collection Types 616
Chapter 22: Miscellaneous Utilities 623
Chapter 23: System Programming 661
System Class 662
23.2 Creating Processes 666
23.3 Shutdown 672
23.4 The Rest of
23.5 Security 677
Chapter 24: Internationalization and Localization 685
24.1 Locale 686
24.2 Resource Bundles 688
24.3 Currency 694
24.4 Time, Dates, and Calendars 695
24.5 Formatting and Parsing Dates and Times 703
24.6 Internationalization and Localization for Text 708
Chapter 25: Standard Packages 715
java.awt--The Abstract Window Toolkit 717
java.net--The Network 724
java.rmi--Remote Method Invocation 727
java.security and Related Packages--Security Tools 732
java.sql--Relational Database Access 732
25.9 Utility Subpackages 733
javax.* --Standard Extensions 737
javax.accessibility--Accessibility for GUIs 737
javax.naming--Directory and Naming Services 738
javax.sound--Sound Manipulation 739
javax.swing--Swing GUI Components 740
org.omg.CORBA--CORBA APIs 740
Appendix A: Application Evolution 741
A.1 Language, Library, and Virtual Machine Versions 741
A.2 Dealing with Multiple Dialects 743
A.3 Generics: Reification, Erasure, and Raw Types 744
Appendix B: Useful Tables 749
Further Reading 755
Downloadable Sample Chapter
Download the Sample
Chapter related to this title.
This book includes free shipping!
Get access to thousands of books and training videos about technology, professional development and digital media from more than 40 leading publishers, including Addison-Wesley, Prentice Hall, Cisco Press, IBM Press, O'Reilly Media, Wrox, Apress, and many more. If you continue your subscription after your 30-day trial, you can receive 30% off a monthly subscription to the Safari Library for up to 12 months. That's a total savings of $199.