 |
Java 5.0 Tiger: A Developer's Notebook
Customer Reviews: 1 Average Customer Rating:   Write a Review and tell the world about this title! People who purchase this book frequently purchase: - Head First Design Patterns; Eric Freeman, et al, $28.50, 37% Off!
- Hibernate: A Developer's Notebook; James Elliott, $15.95, 36% Off!
- JBoss: A Developer's Notebook; Norman Richards, et al, $18.50, 38% Off!
- Java in a Nutshell, 5th Edition; David Flanagan, $28.50, 37% Off!
Books on similar topics, in best-seller order:Books from the same publisher, in best-seller order:
Java 1.5, code-named "Tiger", promises to be the most significant new version
of Java since the introduction of the language. With over a hundred substantial
changes to the core language, as well as numerous library and API additions,
developers have a variety of new features, facilities, and techniques available.
But with so many changes, where do you start? You could read through the lengthy,
often boring language specification; you could wait for the latest 500 page
tome on concepts and theory; you could even play around with the new JDK, hoping
you figure things out--or you can get straight to work with Java 1.5 Tiger:
A Developer's Notebook.
This no-nonsense, down-and-dirty guide by bestselling Java authors Brett McLaughlin
and David Flanagan skips all the boring prose and lecture, and jumps right into
Tiger. You'll have a handle on the important new features of the language by
the end of the first chapter, and be neck-deep in code before you hit the halfway
point. Using the task-oriented format of this new series, you'll get complete
practical coverage of generics, learn how boxing and unboxing affects your type
conversions, understand the power of varargs, learn how to write enumerated
types and annotations, master Java's new formatting methods and the for/in loop,
and even get a grip on concurrency in the JVM.
Light on theory and long on practical application, Java 1.5 Tiger: A Developer's
Notebook allows you to cut to the chase, getting straight to work with Tiger's
new features. The new Developer's Notebooks series from O'Reilly covers important
new tools for software developers. Emphasizing example over explanation and
practice over theory, they focus on learning by doing--you'll get the goods
straight from the masters, in an informal and code-intensive style that suits
developers. If you've been curious about Tiger, but haven't known where to start,
this no-fluff, lab-style guide is the solution.
Table of Contents
The Developer's Notebook Series
Preface
Chapter 1. What's New?
Working with Arrays
Using Queues
Ordering Queues Using Comparators
Overriding Return Types
Taking Advantage of Better Unicode
Adding StringBuilder to the Mix
Chapter 2. Generics
Using Type-Safe Lists
Using Type-Safe Maps
Iterating Over Parameterized Types
Accepting Parameterized Types as Arguments
Returning Parameterized Types
Using Parameterized Types as Type Parameters
Checking for Lint
Generics and Type Conversions
Using Type Wildcards
Writing Generic Types
Restricting Type Parameters
Chapter 3. Enumerated Types
Creating an Enum
Declaring Enums Inline
Iterating Over Enums
Switching on Enums
Maps of Enums
Sets of Enums
Adding Methods to an Enum
Implementing Interfaces with Enums
Value-Specific Class Bodies
Manually Defining an Enum
Extending an Enum
Chapter 4. Autoboxing and Unboxing
Converting Primitives to Wrapper Types
Converting Wrapper Types to Primitives
Incrementing and Decrementing Wrapper Types
Boolean Versus boolean
Conditionals and Unboxing
Control Statements and Unboxing
Method Overload Resolution
Chapter 5. varargs
Creating a Variable-Length Argument List
Iterating Over Variable-Length Argument Lists
Allowing Zero-Length Argument Lists
Specify Object Arguments Over Primitives
Avoiding Automatic Array Conversion
Chapter 6. Annotations
Using Standard Annotation Types
Annotating an Overriding Method
Annotating a Deprecated Method
Suppressing Warnings
Creating Custom Annotation Types
Annotating Annotations
Defining an Annotation Type's Target
Setting the Retention of an Annotation Type
Documenting Annotation Types
Setting Up Inheritance in Annotations
Reflecting on Annotations
Chapter 7. The for/in Statement
Ditching Iterators
Iterating over Arrays
Iterating over Collections
Avoiding Unnecessary Typecasts
Making Your Classes Work with for/in
Determining List Position and Variable Value
Removing List Items in a for/in Loop
Chapter 8. Static Imports
Importing Static Members
Using Wildcards in Static Imports
Importing Enumerated Type Values
Importing Multiple Members with the Same Name
Shadowing Static Imports
Chapter 9. Formatting
Creating a Formatter
Writing Formatted Output
Using the format( ) Convenience Method
Using the printf( ) Convenience Method
Chapter 10. Threading
Handling Uncaught Exceptions in Threads
Using Thread-Safe Collections
Using Blocking Queues
Specifying Timeouts for Blocking
Separating Thread Logic from Execution Logic
Using Executor as a Service
Using Callable Objects
Executing Tasks Without an ExecutorService
Scheduling Tasks
Advanced Synchronizing
Using Atomic Types
Locking Versus Synchronization
Index
Customer Reviews
Customer Reviews: 1 Average Customer Rating: Jun 5, 2006 Chris from Boston, USA
Nice and short
The latest Java in a Nutshell could break your foot if you dropped it. Or maybe that is what you are suppose to be using it for - cracking open nuts. I only mention that book because this one is nice and short. I like those Nutshell books also. This book is less than 200 pages and does a good job of only talking about the new features of Java. It is easy to read and the code samples are good. The pages are made to look like they were printed on graph paper, a little goofy and slightly distracting.
|
|
