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.
User review
Compact and yet extremely informative, very useful
Java JDK1.5, codenamed `Tiger` was truly an exceptional change in the usual strategy of keeping Java language untouched. The Evolution was implemented by changes to Java's standard packages and the public API only. This time Java team went after the language itself and provided a bewildering set of changes, most notably through the generics, which look like C++ generics, mean though something diametrical different. JDK1.5 was not an Evolution, it was a Revolution, an overthrow. The Java as we knew it, has died,,.
I must admit, even as a veteran and active software architect I was lost in the wilderness of the new stuff, I did not knew what to make up of it all. Best was to avoid it all, and keep mind focused on our own, or rather our customers business.
This 180 pages booklet emulating the `notebook` with a 1/4 inch grid paper changed my position. Usually I am skeptic of writers like David Flanagan, seemingly a walking thesaurus with opinion to every system, language etc, but I felt proven wrong after the lecture of this book. It provides a nice conceived crash course in:
1) Generics,
2) Enumerations,
3) Boxing,
4) varargs,
5) Annotations,
6) The so lovely for/in statement,
7) Static imports, (Hurray, I love these!)
8) Formatting, a new C-like facility, titanic change for Java users,
9) New Threading features.
Each feature is of course merely briefly introduced, but in a well conceived compact form, including a nice code example and in many cases discussion of compilation error messages. Every example has the same sections `How do I do that?` and `What just happened.` I got it quickly, just as I like it, and after this lecture I was on my way to use the JDK1.5 features instantly, or I was ready to get some more specialized literature. Here I mean specifically the monstrous Java generics,,. One needs an entire book devoted to these only.
For me personally the biggest gain from this reading was the discovery of the Formatter/alias printf facility. Finally, we fought for years with conservative forces on Java team to make this happen. Several emulator packages were written over the years, some were even offered for money. This novelty invalidates the ah to useless monster set of dramatically verbose Java text IO classes, about which entire now obsolete books were written. McLaughlin/Flanagan code examples were enough to instantly understand the enormous gravity of this change.
I can warmly recommend this book to everybody who knew Java since its beginning and needs a quick jolt toward the seemingly so different looking code with its erratic and all such unknown constructs. An alternative would be literally to abandon the entire older Java book collection and to seek for one of the 1500 pages new books. I will rather stick with my trusty literature and add this 180 pages to it. Done. Do it too, you will like it.
Please note also that Amazon lists this book under 3 different article numbers. Its each time the same book.
User review
Better than Herbert Schildt's Tiger Book
This book does a good job of getting a reader well versed in Java 1.4 up to speed with Java 1.5's (Tiger's) new features. As noted, I believe this book does a better job of doing this over Herbert Schildt's book (Java 2 v5.0 (Tiger) New Features).
Both books hit the main areas most people are concerned about: generics, enums, annotations, enhanced for loop, autoboxing and var args. However, I felt the O'Reilly book did a more in-depth job of describing the features with more concise explanations and examples. For example, the section on Enums in the O'Reilly book also covers EnumMap and EnumSet whereas the Schildt book does not. Both books also cover some of the lesser known enhancements such as static imports, updated Unicode support and the new Formatter class.
Each book covers some minor enhancements the other does not. Schildt: Scanner class, Integer enhancements. O'Reilly: Queue classes. The O'Reilly book does cover one big area that Schildt's does not - threading / concurrency enhancements. Though this area is not covered as completely as the other features, it is a good overview nonetheless. Any good discussion of these issues would warrant a book of its own and perhaps that's why Schildt left it out of his book. However, it was nice to see some coverage in the O'Reilly book.
I guess my only complaint with the O'Reilly book is the `notebook` style itself with the gridlines and `hand written` notes in the margins. It does require some getting used to.
User review
Good Intro to the latest features of Java 1.5 Tiger.
This book delivers most of what it promises to, which is a good introduction to the latest and greatest features of Java 1.5 Tiger. Considering the extent of changes Sun introduced in the new version, I think the authors did a decent job explaining them. If you are new to 1.5 version though, you would probably need to read another book that explains the concepts in greater detail.
My only complaint is with the `Threading` chapter which was full of of API methods instead of letting the users know the concepts behind the changes. Looked like the authors were in a hurry to get the book finished and the `Threading` chapter got affected.
Overall, it is a good read.
User review
Good book to start with.
There's nothing in this book that you couldn't find on Sun's website, but it's a good quick reference book.
User review
This is the best way to progress from Java 4 to Java 5 that I know of
This is a great book. If you know Java 4 and you want to upgrade your knowledge, this book is short-and-sweet -- only 170 pages. It tells you quickly what is new in Java 5 so that you can make the transition from Java 4 prograamming to Java 5 programming.
