Brett D. McLaughlin, David Flanagan

Java 5.0 Tiger

• Broschiertes Buch

Produktbeschreibung

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.

---

Hinweis: Dieser Artikel kann nur an eine deutsche Lieferadresse ausgeliefert werden.

Produktdetails

• A Developer's Notebook
• Verlag: O'Reilly Media
• Seitenzahl: 177
• Erscheinungstermin: 3. August 2004
• Englisch
• Abmessung: 247mm x 165mm x 13mm
• Gewicht: 350g
• ISBN-13: 9780596007386
• ISBN-10: 0596007388
• Artikelnr.: 12695087

Autorenporträt

Brett McLaughlin is a bestselling and award-winning non-fiction author. His books on computer programming, home theater, and analysis and design have sold in excess of 100,000 copies. He has been writing, editing, and producing technical books for nearly a decade, and is as comfortable in front of a word processor as he is behind a guitar, chasing his two sons and his daughter around the house, or laughing at reruns of Arrested Development with his wife. Brett spends most of his time these days on cognitive theory, codifying and expanding on the learning principles that shaped the Head First series into a bestselling phenomenon. He's curious about how humans best learn, why Star Wars was so formulaic and still so successful, and is adamant that a good video game is the most effective learning paradigm we have. 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.

Inhaltsangabe

Copyright
The Developer's Notebook Series
Notebooks Are...
Notebooks Aren't...
Organization
Preface
Organization
How This Book Was Written
About the Examples
Conventions Used in This Book
How to Contact Us
Acknowledgments from Brett
Acknowledgments from David
Chapter 1: What's New?
1.1 Working with Arrays
1.2 Using Queues
1.3 Ordering Queues Using Comparators
1.4 Overriding Return Types
1.5 Taking Advantage of Better Unicode
1.6 Adding StringBuilder to the Mix
Chapter 2: Generics
2.1 Using Type-Safe Lists
2.2 Using Type-Safe Maps
2.3 Iterating Over Parameterized Types
2.4 Accepting Parameterized Types as Arguments
2.5 Returning Parameterized Types
2.6 Using Parameterized Types as Type Parameters
2.7 Checking for Lint
2.8 Generics and Type Conversions
2.9 Using Type Wildcards
2.10 Writing Generic Types
2.11 Restricting Type Parameters
Chapter 3: Enumerated Types
3.1 Creating an Enum
3.2 Declaring Enums Inline
3.3 Iterating Over Enums
3.4 Switching on Enums
3.5 Maps of Enums
3.6 Sets of Enums
3.7 Adding Methods to an Enum
3.8 Implementing Interfaces with Enums
3.9 Value-Specific Class Bodies
3.10 Manually Defining an Enum
3.11 Extending an Enum
Chapter 4: Autoboxing and Unboxing
4.1 Converting Primitives to Wrapper Types
4.2 Converting Wrapper Types to Primitives
4.3 Incrementing and Decrementing Wrapper Types
4.4 Boolean Versus boolean
4.5 Conditionals and Unboxing
4.6 Control Statements and Unboxing
4.7 Method Overload Resolution
Chapter 5: varargs
5.1 Creating a Variable-Length Argument List
5.2 Iterating Over Variable-Length Argument Lists
5.3 Allowing Zero-Length Argument Lists
5.4 Specify Object Arguments Over Primitives
5.5 Avoiding Automatic Array Conversion
Chapter 6: Annotations
6.1 Using Standard Annotation Types
6.2 Annotating an Overriding Method
6.3 Annotating a Deprecated Method
6.4 Suppressing Warnings
6.5 Creating Custom Annotation Types
6.6 Annotating Annotations
6.7 Defining an Annotation Type's Target
6.8 Setting the Retention of an Annotation Type
6.9 Documenting Annotation Types
6.10 Setting Up Inheritance in Annotations
6.11 Reflecting on Annotations
Chapter 7: The for/in Statement
7.1 Ditching Iterators
7.2 Iterating over Arrays
7.3 Iterating over Collections
7.4 Avoiding Unnecessary Typecasts
7.5 Making Your Classes Work with for/in
7.6 Determining List Position and Variable Value
7.7 Removing List Items in a for/in Loop
Chapter 8: Static Imports
8.1 Importing Static Members
8.2 Using Wildcards in Static Imports
8.3 Importing Enumerated Type Values
8.4 Importing Multiple Members with the Same Name
8.5 Shadowing Static Imports
Chapter 9: Formatting
9.1 Creating a Formatter
9.2 Writing Formatted Output
9.3 Using the format( ) Convenience Method
9.4 Using the printf( ) Convenience Method
Chapter 10: Threading
10.1 Handling Uncaught Exceptions in Threads
10.2 Using Thread-Safe Collections
10.3 Using Blocking Queues
10.4 Specifying Timeouts for Blocking
10.5 Separating Thread Logic from Execution Logic
10.6 Using Executor as a Service
10.7 Using Callable Objects
10.8 Executing Tasks Without an ExecutorService
10.9 Scheduling Tasks
10.10 Advanced Synchronizing
10.11 Using Atomic Types
10.12 Locking Versus Synchronization
Colophon

Rezensionen

"Java 1.5 Tiger" is impressively concise. Not having time to digest a 1000-page book, I like that style very much. For my students the advantages are different: first, the lower price, second, a friendlier look & feel as compared to the typical books that are of encyclopaedic size. The seemingly handwritten notes and the typewriter-style font fit the practical hands-on style very well. No sophisticated theoretical explanations, but code examples and a description what happens there and what to look for.

Despite its briefness, the text covers pretty well what I'd like to see.

May I suggest, however, to add a brief comparision of the novel features of Java 1.5 to those of C++ and C#? The chapter on generics is not too easy to follow, especially in the discussion of type conversions involving generics. For most of my students, the chapter on threading would be too tough. But, yes, whereas this chapter may be for experts only, it is important: a good reason to leave it at the end of the book.

In total, I found the book very refreshing to read and will recommend it to students who have to update their Java knowledge."

Prof. Dr. Loviscach, Januar 2005, Hochschule Bremen, University of Applied Sciences, Fachbereich Elektrotechnik und Informatik Rezension Java 1.5 Tiger, O'Reilly, 2004 (Frank Grimm, [e-mail], 24.10.04)

"Java 1.5 Tiger - A Developer's Notebook" beschreibt die neueste Version von Sun's Java-Plattform (bei Technikern als Java 1.5, Codename Tiger, bekann, vom Sun Marketing als Java 5 verkaut). Zur Vorgängerversion von Java sind sehr viele grundlegende Änderungen in die neue Java-Version eingeflossen. So kennt Java zum Beispiel neue Programmierkonzepte wie Generics, Enumerations

(Auszählungsklassen), Ellipsen (variable Anzahl von Funktionsparametern, varargs), Schleifen und neue Threading-Funktionalität. Das Buch beschreibt diese neuen Eigenschaften von Java in 10 Kapiteln. Jedes Kapitel erläutert kurz, wozu das jeweils neue Programmierkonzept gut ist, um dann in sehr praktischen und anschaulichen Beispielen, zu erklären, wie man mit ihnen umgeht. Die Probleme, die zur Veranschaulichung verwendet werden, sind aus dem Programmieralltag entnommen und wohl jedem Java-Programmierer bekannt. In den Beispielen wird ein neues Konzept (fast immer) dem bisherigen Vorgehen gegenübergestellt und beschrieben, wie das bisherige Problem mit Java 1.5-Methoden besser zu lösen ist. Java-Programmierer können sofort erkennen, wie sie bisherige Stolpersteine mit dem neuen Java besser meistern können.

Das Buch beschreibt sehr anschaulich, wie Java 1.5 dem Programmierer hilft, alltägliche Probleme kompfortabler zu lösen als mit vergangenen Java-Versionen. Da alle wichtigen Neuerungen in Java besprochen werden, kann natürlich nicht jedes neue Konzept grundlegend erklärt werden, deshalb wird jeweils kurz beschrieben, wozu die neuen Konzepte dienen und welche bisherigen Probleme mit älteren Java-Versionen sie versuchen zu beseitigen. Oft werden Referenzen auf andere Java-Bücher gegeben, die ein Konzept im Detail erläutern.

Da Buch ist deshalb für Java-Programmierer zu empfehlen, die sich schnell und mit Hilfe von Beispielen aus dem wahren Leben, einen Überblick über die Neuerungen und Änderungen in Java 1.5 schaffen wollen. Es ist kein Einsteigerbuch und lohnt sich nur, wenn man bereits gundlegende Java-Kenntnisse hat. Die Sprache im Buch ist kurz, knapp und präzise, so dass sich allzeit gestresste Entwickler in kürzester Zeit einen sehr praxisnahenÜberblick beschaffen können.