Always Learning

Java Programming Language, The, 3/E
Ken Arnold
James Gosling
David Holmes

ISBN-10: 0201704331
ISBN-13:  9780201704334

Publisher:  Prentice Hall
Copyright:  2000
Format:  Paper; 704 pp
Published:  06/05/2000
Status: Out of Stock


    New edition available


Print this content

In this section:


Description

This is the definitive Java book written by the inventors of the language. Thoroughly revised from start to finish, this new edition describes the newest version of the Java programming language, version 1.3 of the Java 2 platform Standard Edition. More than just API updates, this third edition has been restructured to give more in-depth treatment of the newer language features, as well as informative examples on using the new core classes like the collections and internationalization packages.

Direct from the creators of the Java™ programming language, this Third Edition provides unique insights into why and how the language was designed and intended to be used. More advanced students will find this new edition to be a valuable reference, and will gain new insights into the subtleties of the language. Beginning and intermediate students will benefit from the valuable examples and clear explanations of language and library features.


Table of Contents



1. A Quick Tour.

Getting Started.

Variables.

Comments in Code.

Named Constants.

Unicode Characters.

Flow of Control.

Classes and Objects.

Creating Objects.

Static or Class Fields.

The Garbage Collector.

Methods and Parameters.

Invoking a Method.

The this Reference.

Static or Class Methods.

Arrays.

String Objects.

Extending a Class.

Invoking Methods from the Superclass.

The Object Class.

Type Casting.

Interfaces.

Exceptions.

Packages.

The Java Platform.

Other Topics Briefly Noted.



2. Classes and Objects.

A Simple Class.

Class Members.

Class Modifiers.

Fields.

Field Initialization.

Static Fields.

final Fields.

Access Control.

Creating Objects.

Construction and Initialization.

Constructors.

Initialization Blocks.

Static Initialization.

Methods.

Static Methods.

Method Invocations.

Method Execution and Return.

Parameter Values.

Using Methods to Control Access.

This.

Overloading Methods.

The main Method.

Native Methods.



3. Extending Classes.

An Extended Class.

Constructors in Extended Classes.

Constructor Order Dependencies.

Inheriting and Redefining Members.

Overriding.

Hiding Fields.

Accessing Inherited Members.

Accessibility and Overriding.

Hiding Static Members.

The super Keyword.

Type Compatibility and Conversion.

Compatibility.

Explicit Type Casting.

Testing for Type.

What protected Really Means.

Marking Methods and Classes final.

Abstract Classes and Methods.

The Object Class.

Cloning Objects.

Strategies for Cloning.

Correct Cloning.

Shallow versus Deep Cloning.

Extending Classes: How and When.

Designing a Class to Be Extended.

Designing an Extensible Framework.

Single Inheritance versus Multiple Inheritance.



4. Interfaces.

A Simple Interface Example.

Interface Declarations.

Interface Constants.

Interface Methods.

Interface Modifiers.

Extending Interfaces.

Inheriting and Hiding Constants.

Inheriting, Overriding, and Overloading Methods.

Working with Interfaces.

Implementing Interfaces.

Using an Implementation.

Marker Interfaces.

When to Use Interfaces.



5. Nested Classes and Interfaces.

Static Nested Types.

Static Nested Classes.

Nested Interfaces.

Inner Classes.

Accessing Enclosing Objects.

Extending Inner Classes.

Inheritance, Scoping, and Hiding.

Local Inner Classes.

Anonymous Inner Classes.

Inheriting Nested Types.

Nesting in Interfaces.

Modifiable Variables in Interfaces.

Implementation of Nested Types.



6. Tokens, Operators, and Expressions.

Lexical Elements.

Character Set.

Comments.

Tokens.

Identifiers.

Keywords.

Types and Literals.

Reference Literals.

Boolean Literals.

Character Literals.

Integer Literals.

Floating*Point Literals.

String Literals.

Class Literals.

Variables.

Field and Local Variable Declarations.

Parameter Variables.

final Variables.

Array Variables.

Array Modifiers.

Arrays of Arrays.

Array Initialization.

Arrays and Types.

The Meanings of Names.

Arithmetic Operations.

Integer Arithmetic.

Floating*Point Arithmetic.

Strict and non*Strict Floating*Point Arithmetic.

General Operators.

Increment and Decrement Operators.

Relational and Equality Operators.

Logical Operators.

instanceof.

Bit Manipulation Operators.

The Conditional Operator ?:.

Assignment Operators.

String Concatenation Operator.

new.

Expressions.

Order of Evaluation.

Expression Type.

Implicit Type Conversions.

Explicit Type Casts.

String Conversions.

Member Access.

Finding the Right Method.

Operator Precedence and Associativity.



7. Control Flow.

Statements and Blocks.

if-else.

switch.

while and do-while.

for.

Labels.

break.

continue.

return.

What, No goto?



8. Exceptions.

Creating Exception Types.

throw.

Transfer of Control.

Asynchronous Exceptions.

The throws Clause.

throws Clauses and Method Overriding.

throws Clauses and Native Methods.

try, catch, and finally.

finally.

When to Use Exceptions.



9. Strings.

Basic String Operations.

String Comparisons.

String Literal Equivalence.

Utility Methods.

Making Related Strings.

String Conversions.

Strings and char Arrays.

Strings and byte Arrays.

Character Encodings.

The StringBuffer Class.

Modifying the Buffer.

Getting Data Out.

Capacity Management.



10. Threads.

Creating Threads.

Using Runnable.

Synchronization.

synchronized Methods.

Static Synchronized Methods.

synchronized Statements.

Synchronization Designs.

wait, notifyAll, and notify.

Details of Waiting and Notification.

Thread Scheduling.

Voluntary Rescheduling.

Deadlocks.

Ending Thread Execution.

Cancelling a Thread.

Waiting for a Thread to Complete.

Ending Application Execution.

volatile.

Thread Management, Security and ThreadGroup.

Threads and Exceptions.

Don't stop.

ThreadLocal Variables.

Debugging Threads.



11. Programming with Types.

Wrapper Classes.

Void.

Boolean.

Character.

Number.

The Integer Wrappers.

The Floating*Point Wrapper Classes.

Reflection.

The Class class.

Naming Classes.

Examining Class Members.

The Modifier Class.

The Field Class.

The Method Class.

Creating New Objects and the Constructor Class.

Access Checking and AccessibleObject.

Arrays.

Packages.

The Proxy Class.

Loading Classes.

The ClassLoader Class.

Preparing a Class for use.

Loading Related Resources.



12. Garbage Collection and Memory.

Garbage Collection.

A Simple Model.

Finalization.

Resurrecting Objects during finalize.

Interacting with the Garbage Collector.

Reachability States and Reference Objects.

The Reference Class.

Strengths of Reference and Reachability.

Reference Queues.



13. Packages.

Package Naming.

Type Imports.

Package Access.

Accessibility and Overriding Methods.

Package Contents.

Package Objects and Specifications.



14. Documentation Comments.

The Anatomy of a Doc Comment.

Tags.

@see.

{@link}.

@param.

@return.

@throws and @exception.

@deprecated.

@author.

@version.

@since.

{@docRoot}.

An Example.

External Conventions.

Overview and Package Documentation.

The doc*files Directory.

Notes on Usage.



15. The I/O Package.

Byte Streams.

InputStream.

OutputStream.

Character Streams.

Reader.

Writer.

Character Streams and the Standard Streams.

InputStreamReader and OutputStreamWriter.

A Quick Tour of The Stream Classes.

Synchronization and Concurrency.

Filter Streams.

Buffered Streams.

Piped Streams.

ByteArray Byte Streams.

CharArray Character Streams.

String Character Streams.

Print Streams.

LineNumberReader.

SequenceInputStream.

Pushback Streams.

StreamTokenizer.

The Data Byte Streams.

DataInput and DataOutput.

The Data Stream Classes.

Working with Files.

File Streams and FileDescriptor.

RandomAccessFile.

The File Class.

FilenameFilter and FileFilter.

Object Serialization.

The Object Byte Streams.

Making Your Classes Serializable.

Serialization and Deserialization Order.

Customized Serialization.

Object Versioning.

Serialized Fields.

The Externalizable Interface.

Documentation Comment Tags.

The IOException Classes.



16. Collections.

Collections.

Exception Conventions.

Iteration.

Ordering using Comparable and Comparator.

The Collection Interface.

Set and SortedSet.

HashSet.

TreeSet.

List.

ArrayList.

LinkedList.

Map and SortedMap.

HashMap.

TreeMap.

WeakHashMap.

Wrapped Collections and the Collections Class.

The Synchronization Wrappers.

The Unmodifiable Wrappers.

The Collections Utilities.

The Arrays Utility Class.

Writing Iterator Implementations.

Writing Collection Implementations.

The Legacy Collection Types.

Enumeration.

Vector.

Stack.

Dictionary.

Hashtable.

Properties.



17. Miscellaneous Utilities.

BitSet.

Observer/Observable.

Random.

StringTokenizer.

Timer and TimerTask.

Math and StrictMath.



18. System Programming.

The System Class.

Standard I/O Streams.

System Properties.

Utility Methods.

Creating Processes.

The Process Class.

Process Environments.

Portability.

Shutdown.

Shutdown Hooks.

The Shutdown Sequence.

Shutdown Strategies.

The Rest of the Runtime.

Loading Native Code.

Debugging.

Security.

The SecurityManager Class.

Permissions.

Security Policies.

Access Controllers and Privileged Execution.



19. Internationalization and Localization.

Locale.

Resource Bundles.

ListResourceBundle.

PropertyResourceBundle.

Subclassing ResourceBundle.

Time, Dates, and Calendars.

Calendars.

Time Zones.

GregorianCalendar and SimpleTimeZone.

Formatting and Parsing Dates and Times.

Internationalization and Localization for Text.

Collation.

Formatting and Parsing.

Text Boundaries.



20. Standard Packages.

java.awt---The Abstract Window Toolkit.

java.applet---Applets.

java.beans---Components.

java.math---Mathematics.

java.net---The Network.

java.rmi---Remote Method Invocation.

java.security --- Security Tools.

java.sql --- Relational Database Access.

Utility Subpackages.

Archive Files---java.util.jar.

ZIP Files---java.util.zip.

javax.*---Standard Extensions.

javax.accessibility --- Accessibility for GUIs.

javax.naming---Directory and Naming Services.

javax.sound---Sound Manipulation.

javax.swing --- Swing GUI Components.

org.omg.CORBA --- CORBA APIs.



Appendix A. Runtime Exceptions.

RuntimeException Classes.

Error Classes.



Appendix B Useful Tables.

Table 1: Keywords.

Table 2: Operator Precedence.

Table 3: Unicode Digits.

Table 4: Unicode Letters and Digits.

Table 5: Special Characters Using \.

Table 6: Documentation Comment Tags.

Table 7: Unicode Character Blocks.



Further Reading.


Index. 0201704331T04062001


Next Edition(s)

  • Java Programming Language, The, 4/E
    Arnold, Gosling & Holmes
    ©2006  |  Prentice Hall  |  Paper; 928 pp  |  Instock
    ISBN-10: 0321349806  |  ISBN-13: 9780321349804
    Brief Description  |  More Info



Back to top

Print this content

In this section:


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.




Backcover Copy

Direct from the creators of the Java™ programming language, this Third Edition of The Java™ Programming Language is a valuable resource for both novice and advanced programmers. More than 100,000 developers who programmed with C, C++, Smalltalk, or other high-level languages have used this book to get a concise, intelligent, and deep understanding of the Java programming language.

This book is what you need to understand the basic design goals of the language and the application of the language in real-world development. It provides unique insights into why and how the language was designed and intended to be used.

The authors describe the latest version of the language, as defined in the Java™ Language Specification, Second Edition and implemented in version 1.3 of the Java 2 SDK, Standard Edition. This third edition has been structured to give more in-depth treatment of the newer language features, as well as informative examples on using some of the new APIs.

New and/or revised in this edition:

  • more details on language features, including an expanded section on nested classes
  • more comprehensive treatment of garbage collection and related programming issues
  • coverage of new APIs, such as collections and internationalization

Thoroughly revised from start to finish, this edition fully covers the features of the current release of the Java programming language and class libraries. The book serves as a tutorial introduction to the language and essential libraries as well as a reference.

Experienced programmers will find this new edition to be a valuable reference, and will gain new insights into the subtleties of the language. Novice and intermediate programmers will benefit from the valuable examples and clear explanations of language and library features. Make sure you understand the contents of this book before you begin any serious development for the Java platform.



0201704331B04062001

Back to top

Log in to the Instructor Resource Center

Login name: 

  Password: 

Forgot login/password?  |  Need to redeem an access code?

        

Instructor Resource Center File Download

This work is protected by local and international copyright laws and is provided solely for the use of instructors in teaching their courses and assessing student learning. Dissemination or sale of any part of this work (including on the World Wide Web) will destroy the integrity of the work and is not permitted. The work and materials from this site should never be made available to students except by instructors using the accompanying text in their classes. All recipients of this work are expected to abide by these restrictions and to honor the intended pedagogical purposes and the needs of other instructors who rely on these materials.

Cancel     I accept, proceed with download

Print this content

Pearson Higher Education offers special pricing when you choose to package your text with other student resources. If you're interested in creating a cost-saving package for your students contact your Pearson Higher Education representative.

Back to top