Java Programming Language

Name: Java Programming Language
Availability: InStock
ISBN: 9780321349804

ISBN-10: 0321349806

ISBN-13: 9780321349804

Edition: 4th 2006 (Revised)

Authors: James Gosling, David Holmes, Ken Arnold

List price: $69.99

30 day, 100% satisfaction guarantee!

Semester Rental: $19.09 Due date: 8/13/2024

Rental notice: supplementary materials (access codes, CDs, etc.) are not guaranteed with rental orders.

Buy used: $7.23

Marketplace

3 new & used from $5.24

what's this?

Rush Rewards U
Members Receive:

You have reached 400 XP and carrot coins. That is the daily max!

Description:

This definitive introduction and reference teaches programmers the basic and advanced features of Java. As the creators of the Java programming language, the authors help programmers understand why Java is such a powerful language. As a result, the programmers learn how Java is suitable for building a variety of applications. The authors also provide unique "behind-the-scenes" insights into how the language was designed and intended to be used. Thoroughly revised from start to finish, this fourth edition covers all of the features of J2SE 5.0 release. Updates to the fourth edition of this best-seller include concise coverage on generics, metadata, autoboxing, enumerations, enhanced…

Book details

List price: $69.99
Edition: 4th
Copyright year: 2006
Publisher: Addison Wesley Professional
Publication date: 8/17/2005
Binding: Paperback
Pages: 928
Size: 7.50" wide x 9.00" long x 1.50" tall
Weight: 3.278
Language: English

Ken Arnold is the founder and former president of Paragon Engineering Services, Houston, Texas. He has more that 40 years of experience in the operations and project management. He is actively involved in production facility design. He has served on numerous SPE, API, and government advisory committees as an expert on oil handling, produced-water treating, and safety aspects producing operations.



Preface



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



String Conversion and Formatting



Extending a Class



Invoking Methods of the Superclass



The Object Class



Type Casting



Interfaces



Generic Types



Exceptions



Annotations



Package



The Java Platform



Other Topics Briefly Noted



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



Methods with Variable Numbers of Arguments



Method Execution and Return



Parameter Values



Using Methods to Control Access



this



Overloading Methods



Importing Static Member Names



The main Method



Native Methods



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



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



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



Inner Classes in Static Contexts



Anonymous Inner Classes



Inheriting Nested Types



Nesting in Interfaces



Modifiable Variables in Interfaces



Implementation of Nested Types



Enumeration Types



A Simple Enum Example



Enum Declarations



Enum Modifiers



Enum Constant Declarations



Construction



Constant Specific Behavior



java.lang.Enum



To Enum or Not



Tokens, Values, and Variables



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



Primitives as Types



Common Fields and Methods



Construction



Constants



Common Methods



Void



Boolean



Number



The Integer Wrappers



The Floating-Point Wrapper Classes



Character



Working with UTF-16



Boxing Conversions



Operators and Expressions



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



Type Conversions



Implicit Type Conversions



Explicit Type Casts



String Conversions



Operator Precedence and Associativity



Member Access



Finding the Right Method



Control Flow



Statements and Blocks



if-else



switch



while and do-while



for



Basic for Statement



Enhanced for Statement



Labels



break



continue



return



What, No goto?



Generic Types



Generic Type Declarations



Bounded Type Parameters



Nested Generic Types



Working with Generic Types



Subtyping and Wildcards



Generic Methods and Constructors



Generic Invocations and Type Inference



Wildcard Capture



Under the Hood: Erasure and Raw Types



Erasure at Runtime



Overloading and Overriding



Finding the Right Method-Revisited



Class Extension and Generic Types



Exceptions and Assertions



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



Exception Chaining



Stack Traces



When to Use Exceptions



Assertions



The assert Statement



When to Use Assertions



State Assertions



Control Flow Assertions



Turning Assertions On and Off



Why Turn Assertions On and Off?



Controlling Assertions on the Command Line



Complete Removal



Making Assertions Required



Strings and Regular Expressions



Character Sequences



The String Class



Basic String Operations



String Comparisons



String Literals, Equivalence and Interning



Making Related Strings



String Conversions



Strings and char Arrays



Strings and byte Arrays



Character Set Encoding



Regular Expression Matching



Regular Expressions



Compiling and Matching with Regular Expressions



Replacing



Regions



Efficiency



The StringBuilder Class



Modifying the Buffer



Getting Data Out



Capacity Management



The StringBuffer Class



Working with UTF-16



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



The Memory Model: Synchronization and volatile



Synchronization Actions



Final Fields and Security



The Happens-Before Relationship



Thread Management, Security, and ThreadGroup



Threads and Exceptions



Don't stop



Stack Traces



ThreadLocal Variables



Debugging Threads



Annotations



A Simple Annotation Example



Annotation Types



Annotating Elements



Restricting Annotation Applicability



Retention Policies



Working with Annotations



Reflection



The Class Class



Type Tokens



Class Inspection



Examining Class Members



Naming Classes



Obtaining Class Objects by Name



Runtime Type Queries



Annotation Queries



The Modifier Class



The Member classes



Access Checking and AccessibleObject



The Field Class



Final Fields



The Method Class



Creating New Objects and the Constructor Class



Inner Class Constructors



Generic Type Inspection



Type Variables



Parameterized Types



Wildcards



Generic Arrays



String Representations of Type Objects



Arrays



Genericity and Dynamic Arrays



Packages



The Proxy Class



Loading Classes



The ClassLoader Class



Preparing a Class for Use



Loading Related Resources



Controlling Assertions at Runtime



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



Finalization and Reachability



Packages



Package Naming



Type Imports



Package Access



Accessibility and Overriding Methods



Package Contents



Package Annotations



Package Objects and Specifications



Documentation Comments



The Anatomy of a Doc Comment



Tags



@see



{@link} and {@linkplain}



@param



@return



@throws and @exception



@deprecated



@author



@version



@since



{@literal} and {@code}



{@value}



{@docRoot}



{@inheritDoc}



Inheriting Method Documentation Comments



Inheriting @throws Comments



A Simple Example



External Conventions



Package and Overview Documentation



The doc-files Directory



Notes on Usage



The I/O Package



Streams Overview



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



A Taste of New I/O



Collections



Collections



Exception Conventions



Iteration



Ordering with Comparable and Comparator



The Collection Interface



Set and SortedSet



HashSet



LinkedHashSet



TreeSet



List



ArrayList



LinkedList



RandomAccess Lists



Queue



PriorityQueue



Map and SortedMap



HashMap



LinkedHashMap



IdentityHashMap



WeakHashMap



TreeMap



enum Collections



EnumSet



EnumMap



Wrapped Collections and the Collections Class



The Collections Utilities



The Unmodifiable Wrappers



The Checked Wrappers



Synchronized Wrappers and Concurrent Collections



The Synchronized Wrappers



The Concurrent Collections



The Arrays Utility Class



Writing Iterator Implementations



Writing Collection Implementations



The Legacy Collection Types



Enumeration



Vector



Stack



Dictionary



Hashtable



Properties



Miscellaneous Utilities



Formatter



Format Specifiers



Integer Conversions



Floating-Point Conversions



Character Conversions



General Conversions



Custom Formatting



Format Exceptions



The Formatter Class



BitSet



Observer/Observable



Random



Scanner



Stream of Values



Scanning Lines



Using Scanner



Localization



StringTokenizer



Timer and TimerTask



UUID



Math and StrictMath



System Programming



The System Class



Standard I/O Streams



System Properties



Utility Methods



Creating Processes



Process



Process Environments



ProcessBuilder



Portability



Shutdown



Shutdown Hooks



The Shutdown Sequence



Shutdown Strategies



The Rest of Runtime



Loading Native Code



Debugging



Security



The SecurityManager Class



Permissions



Security Policies



Access Controllers and Privileged Execution



Internationalization and Localization



Locale



Resource Bundles



ListResourceBundle



PropertyResourceBundle



Subclassing ResourceBundle



Currency



Time, Dates, and Calendars



Calendars



Time Zones



GregorianCalendar and SimpleTimeZone



Formatting and Parsing Dates and Times



Using Formatter with Dates and Times



Internationalization and Localization for Text



Collation



Formatting and Parsing



Text Boundaries



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 and Related Packages-Security Tools



java.sql-Relational Database Access



Utility Subpackages



Concurrency Utilities-java.util.concurrent



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



Application Evolution



Language, Library, and Virtual Machine Versions



Dealing with Multiple Dialects



Generics: Reification, Erasure, and Raw Types



Raw Types, "Unchecked" Warnings, and Bridge Methods



API Issues



Useful Tables


Further Reading


Index