Customer Reviews

Java 2 v5.0 (Tiger) New Features

5 star:		(4)
4 star:		(3)
3 star:		(5)
2 star:		(0)
1 star:		(0)

 

 

"If you already know Java and want to utilize the impressive array of innovations contained in Java 2, v5.0, this book is for you." That's actually from the back cover of the book and I have to say I fully agree. Schildt has brought us many useful titles and "Java 2, v5.0 (Tiger) New Features" is no exception.

The delightfully small book (a hair below 200 pages) packs just enough information to upgrade your know-how to the level of the latest Java version. Each topic (generics, autoboxing, enums, for-each, static imports, varargs, annotations, formatter, scanner) is explained clearly and concisely with expressive code samples. Schildt even lets you in on how the compiler handles some of these syntax enhancements, which I especially enjoyed reading about. The major features of each new addition is discussed in more detail and the less common methods are given a one-sentence description, which suits me, personally, quite well as long as I agree with what's common and what's not.

Talking about agreeing on what's common, the only real gripes I have with "Java 2, v5.0 (Tiger) New Features" is that the author completely by-passes the addition of java.lang.instrument and java.lang.management packages, only mentioning that those have been added. I would've certainly expected to read at least a page worth of overview on the actual services those packages provide.

In summary, I'd say you can't go wrong with this book. It's not a "complete reference" nor is it intended to be. It's a quick path to knowing just enough to feel comfortable diving into Java code written "Tiger style".

I was looking for a clear & comprehensive explanation of Generics (mostly). Elsewhere (in web tutorials) I have found detailed explanations but confusingly written. This book is VERY clear and readable. But it is not at all comprehensive (the reviewer who described it as Comprehensive obviously does not realize just how much is not covered!). EG it descibes Upper Bounds in some depth, but gives NO explanation of how/why to use Lower Bounds. Also under Enums, it makes NO mention of instance-level polymorphic methods.
This book would be an excellent introduction to the new features - but you will need to go elsewhere for the rest of the details. However I must say that the coverage is MUCH better than all the other Java books claiming to be 'fully updated' for Java 5 - most of which seem to have max half a page on Generics!!!
Despite its omissions I am glad I bought this book.

The book starts that it is ment for experienced Java programmers who want to get up to speed quickly. However it only touches each subject so lightly that an eperienced programmer would have had enough from the API documentation and other sources.

For example the chapter about autoboxing fails to mention what happens when you unbox a null object, while that would be the interesting case.

I also fail to understand how an entire chapter can be devoted to the enhanced for loop. The part about generics would require more chapters, one introduction and one more advanced part. When diving into generics things get complicated, but it is not described in this book.

The part about annotiation fails to mention that the @SuppressWarnings annotation is not implemented in 1.5

This book does a great job introducing the new features of Tiger to developers familiar with previous versions of Java. There examples are not lengthy and are not meant to be mock-ups of real-life applications, as other reviewers have noted, but that's not really the scope of this book. The small code examples serve a simple purpose; to demonstrate the specific functionality that the author has described.

And the author does a fantastic job of defining the new features. Some of the features represent a significant departure from what I am used to in previous versions of Java (Generics and Annotations are the two biggest for me), and the author's exposition of these features really helped me understand them. I won't claim to be an expert, but again, that's not what this book is about. It is an introduction to the new features, which I feel well-acquainted with after having read this book.

This book is a good introduction to the new features of v5.0. If you are experienced Java developer and you want to have a fast and quick way to pick up what's new in v5.0, then this book is suitable for you.

In general, this book is easy to read and the examples are clean. It covers the fundamental level of using the new language extensions. It spends lots of pages about the new Java v5.0 syntax and usage such as Generics. However, it only covers very very fundamental part of the new API. It contains only 2 pages about the new pachages such as java.lang.management and java.util.concurrent. If you are looking for the new API functionality, then this book is not for you.

If you are experienced Java professional and want to have a fast and quick way to pick up what's new in v5.0, then this book is for you. Each topic (generics, autoboxing, enums, for-each, static imports, varargs, annotations, formatter, scanner) is explained clearly and concisely with expressive code samples. Schildt even lets you in on how the compiler handles some of these syntax enhancements.

By covering only what's new in Tiger, this fast paced guide gets you up to speed quickly, without rehashing what you already know. The world of Java is changing and no programmer can afford to be left behind. Herb Schildt show you how to move your programming skills to Java 2, v5.0

Compared to other books and articles in Sun Java sites, this book is simpler to read and understand the basics. It covers all the major topics in easy-to-understand format with examples of the existing way (java 2) and the new java 5 way.
This book does not go beyond its stated purpose and show all the program nuance and exceptional cases to look out for. So this book is good if you are new to java 5 and are afraid where to start.
After the quick reading you can confidently use the new java 5 features but to create java 5 library codes (e.g. generics, iterator classes etc) to be used by others, you need to study further from other resources.
In short, good for passing Java 5 exam, but cant be used as a reference.
Warning for exam-takers: There are no questions for any chapter in the book.

This book does a decent job of getting a reader well versed in Java 1.4 up to speed with Java 1.5's (Tiger's) new features. However, the O'Reilly equivalent book (Java 1.5 Tiger: A Developer's Notebook (Java 5,Version 1.5)) is superior.

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.

The author did a good job in bringing all the new features of Java 1.5 in front of the reader.

This is one of the first books published for Java 5, and I am very satisfied with it.

Schildt gives us a concise walkthrough of Java 1.5, to a reader already acquainted with 1.4. The autoboxing produces more readable code. While varargs brings back a feature beloved by many erstwhile C programmers, who have lobbied years for its inclusion into Java.

Possibly the most far reaching changed described is Generics. It has some resemblences to templates in C++. It lets you define parameterised classes that have stronger runtime type safety. A precious thing, as run time errors can be hard and expensive to find and debug. Anyplace you can reduce the chance of this is a worthy saving.

Enumerations now have finally surfaced in Java. But unlike C or C++, where these are sets of integer constants, Java defines them as being class types, and they can have instances, constructors and methods. Java gives them far more power. Very pretty.