Op werkdagen voor 23:00 besteld, morgen in huis Gratis verzending vanaf €20

Java 5.0 Tiger: A Developer's Notebook

Paperback Engels 2004 9780596007386
Verwachte levertijd ongeveer 8 werkdagen


Java 5.0, 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 5.0 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 5.0 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.


Aantal pagina's:177
Hoofdrubriek:IT-management / ICT


Wees de eerste die een lezersrecensie schrijft!

Geef uw waardering

Zeer goed Goed Voldoende Matig Slecht

Over David Flanagan

David Flanagan is a computer programmer who spends most of his time writing about JavaScript and Java. His books with O'Reilly include Java in a Nutshell, Java Examples in a Nutshell, Java Foundation Classes in a Nutshell, JavaScript: The Definitive Guide, and JavaScript Pocket Reference. David has a degree in computer science and engineering from the Massachusetts Institute of Technology. He lives with his wife and children in the U.S. Pacific Northwest bewteen the cities of Seattle, Washington and Vancouver, British Columbia. David has a blog at www.davidflanagan.com.

Andere boeken door David Flanagan


The Developer's Notebook Series

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


Managementboek Top 100


Populaire producten



        Java 5.0 Tiger: A Developer's Notebook