Java Programming Language

ISBN-10: 0321349806
ISBN-13: 9780321349804
Edition: 4th 2006 (Revised)
List price: $69.99
30 day, 100% satisfaction guarantee

If an item you ordered from TextbookRush does not meet your expectations due to an error on our part, simply fill out a return request and then return it by mail within 30 days of ordering it for a full refund of item cost.

Learn more about our returns policy

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,  More...

what's this?
Rush Rewards U
Members Receive:
coins
coins
You have reached 400 XP and carrot coins. That is the daily max!
You could win $10,000

Get an entry for every item you buy, rent, or sell.

Study Briefs

Limited time offer: Get the first one free! (?)

All the information you need in one place! Each Study Brief is a summary of one specific subject; facts, figures, and explanations to help you learn faster.

Add to cart
Study Briefs
Careers in Legal Assisting Online content $4.95 $1.99
Add to cart
Study Briefs
Italian Grammar Online content $4.95 $1.99
Add to cart
Study Briefs
Portuguese Grammar Online content $4.95 $1.99
Add to cart
Study Briefs
Spanish Grammar Online content $4.95 $1.99

Customers also bought

Loading
Loading
Loading
Loading
Loading
Loading
Loading
Loading
Loading
Loading

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: 2.992
Language: English

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 loops, and more.

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

×
Free shipping on orders over $35*

*A minimum purchase of $35 is required. Shipping is provided via FedEx SmartPost® and FedEx Express Saver®. Average delivery time is 1 – 5 business days, but is not guaranteed in that timeframe. Also allow 1 - 2 days for processing. Free shipping is eligible only in the continental United States and excludes Hawaii, Alaska and Puerto Rico. FedEx service marks used by permission."Marketplace" orders are not eligible for free or discounted shipping.

Learn more about the TextbookRush Marketplace.

×