Java 1.5 Tiger: A Developer's Notebook

David Flanagan, Brett McLaughlin

  • 出版商: O'Reilly
  • 出版日期: 2004-08-03
  • 售價: $1,360
  • 貴賓價: 9.5$1,292
  • 語言: 英文
  • 頁數: 202
  • 裝訂: Paperback
  • ISBN: 0596007388
  • ISBN-13: 9780596007386
  • 相關分類: Java 程式語言
  • 已過版
    無現貨庫存(No stock available)




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:


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