Customer Reviews

Pure Java 2

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

 

 

This book has a logical structure, and it is didactically superb and very well written. It is highly recommende for people who want to make the second step, as it picks you up where the typical tutorial stops.

The book is unique in concept, as it doesn't just show you how things can be done, but also how they should be done in order to produce reusable, and object-oriented code. Eg, when Litwak explains multithreading, he shows you that there are in principle two ways to do it: inheriting from the Java class Thread, or implementing the Runnable interface. Ok, that's in "Thinking of Java", too, but Litwak also explains you why he thinks that inheriting from Thread compromises object-orientation. But he is never religious about these things, he just explains you what it possible, and what criteria you might want to consider to make your own decision of how to do it in a real-life project. And this is, what makes this book so valuable: it connects the abstract concepts of object-orientation with the code and advice for real-life programming practice. The book helps you not only to find some solution, but it helps you to find your own way to the most general or the most suitable solution. At last I understand what re-usable code really is, and how I can write it myself!

So, why not five stars? Because there are incredibly many typos as well in the text as in the code examples, especially in the first part or the book. With only little knowledge of oo concepts or Java it is easy to identify them, but they can certainly confuse a reader with no knowledge of the language or objects and such. It's not that bad in part two. It looks as if part II has been written first, and part one was created only shortly before the deadline. Pity! What about a revised edition, SAMS?

I can only assume Ken Litwak is ducking his head as he walks quickly past the computer book section in his local store. He'll still be easy to spot however, because his wife will likely be following closely behind smacking him for putting her in the dedication. He mentions and thanks her twice for her proofreading efforts but we don't even make it past page 30 before we find this:

chap 3, p30:

public static final int STUDENT_CARD=1;

public static final int FACULTY_CARD=2;

public static fianl int ALUMNI_CARD=3;

Even if this was written in Ken Litwak's word processor and the code never tested to determine if it compiles (a sad idea, in my mind), "fianl" isn't a word in any language my word processor checks against. C'mon Ken. Borland has a freely downloadable version of their Java IDE. Give it a stab.

At least four more obvious typos appear in and out of sample code in the next 20 pages. Where was Litwak's editor? (Actually, _three_ technical editors are named in the flyleaf. Where were you, Alexandre, David and Ethan?) And how has SAMS, who have been publishing C books for roughly a decade, released a book where every other code sample has bad tabbing and alignment? In a class sample with 2 member variables and 1 function it is not a major challenge to tab them all up evenly. This creeping misalignment pervades the book with class declarations slowly shifting farther and farther right with each member variable and function.

Lest you think this is an isolated incident, I spot-checked other code samples throughout the book. p703. p395. p247. I didn't even have to search hard - nearly every third sample is a nightmare of hard-to-read layout. Its annoying in samples where simple declarations shift every few lines. It's hard to follow in later code samples with three nested if-else blocks.

I might have been inclined to think this was some odd "style" I'd never encountered if not for examples without matching open and close brackets. In one 20 line example there's three curlyque bracket pairs which don't remotely line up vertically, one without a closing bracket and one with a "|" where the closing bracket should go.

There's no excuse for a company with SAMS' reputation not having a technical editor insure that sample code at the very least spells reserved words correctly and is readably formatted. A cursory web search turns up half a dozen free tools which will do syntax highlighting, spell checking and enforce consistent code formatting.

I bought this book because it seemed to cover a good variety of material with a voice targeted at a knowledgable audience. I still think the conversational tone and organization are good. However I now I find myself wondering if I can trust the information in it without consulting Sun's canonical documentation; if they didn't proofread for spelling or even examine the code samples how can I trust the quality of the content? I am unsure if this book was rushed to market or simply the result of inept editing and an unskilled layout team. The only thing I am sure of is that the days when I would pick up a book solely on the basis of the word "SAMS" on the binding are gone.

There are some features of Java2 that this book does not cover. The book consists of three parts, an introduction to java, a deeper explanation of some of the core techniques of Java 2, and an API reference. The introduction has unfortunantely lot of typing errors, so if you are unfamiliar to java, this may be more difficult than it should be. The technique reference is one of the most usefull parts of the book, where there are an deep, weel-documented explanation of some of the core features of java2. The best thing about this book is in fact the small notes, tips and tricks, wich points out a lot of pit-falls which should be avoided. If you are familiar with java, and need to go further and learn more, this is a book for you.

I've been programming in java for 2 years now. This is the fifth java book that I've read. It's the best one so far. The book reviews how to use necessary classes in the jdk that would benefit most java developers. It also sheds light on subjects that other books don't really cover. It teaches you how to code with the jdk, but it also explains what is happening in the java virtual machine so you understand exactly what is happening with your code. Reading this book has really helped me understand programming in java. It's not really geared towards teaching java or object oriented design, but if you have some java experience and you want to take it a step further I would highly recomend this book. There were only 2 minor drawbacks that I saw. First, it doesn't go in depth for some subjects. For example, if your trying to target in on using java swing this book will just give you the general overview but not enough to create a really nice gui. Second, there are minor typos in the code. ..................

This book is great! The numerous examples alone make this book worth its weight in gold. In fact, it's one of the least expensive of the JAVA books in my library collection. Furthermore, the material is updated to reflect the J2SE.

Kenneth Litwak does a great job of presenting the material. There are a lot "TIP" and "CAUTION" sections that are helpful and interesting. This is one of the few books where the example codes are well documented. The one thing I really like about Kenneth's approach is he does a very good job of documenting his code. Rather than presenting the code with numbers on the side, and then explaining line-by-line with statements like, "Line 1) does this and Line 2) does that...", he embeds the explanation within the code examples. This method is a much better approach to presenting sample code, then having to refer back and forth between the code example and the explanation. Finally, all the example codes are self-contained. They have a "main" module that actually executes the topic being presented. This makes it very easy to cut-and-paste his examples to try other tweaks. This way I don't spend my time writing little driver programs.

As a very good Technical Leader once told me, "Any good programmer should able to read code." And if they can't read documented code, then they shouldn't be programming!

This book has a logical structure, and it is didactically superb and very well written. It is highly recommended for people who want to make the second step, as it picks you up where the typical tutorial stops.

The book is unique in concept, as it doesn't just show you how things can be done, but also how they should be done in order to produce reusable, and object-oriented code. Eg, when Litwak explains multithreading, he shows you that there are in principle two ways to do it: inheriting from the Java class Thread, or implementing the Runnable interface. Ok, that's in "Thinking of Java", too, but Litwak also explains you why he thinks that inheriting from Thread compromises object-orientation. But he is never religious about these things, he just explains you what it possible, and what criteria you might want to consider to make your own decision of how to do it in a real-life project. And this is, what makes this book so valuable: it connects the abstract concepts of object-orientation with the code and advice for real-life programming practice. The book helps you not only to find some solution, but it helps you to find your own way to the most general or the most suitable solution. At last I understand what re-usable code really is, and how I can write it myself!

So, why not five stars? Because there are incredibly many typos as well in the text as in the code examples, especially in the first part or the book. With only little knowledge of oo concepts or Java it is easy to identify them, but they can certainly confuse a reader with no knowledge of the language or objects and such. It's not that bad in part two. It looks as if part II has been written first, and part one was created only shortly before the deadline. Pity! What about a revised edition, SAMS?

This is a good book for beginners looking for a reference and HowTo on Java. But does not go into detail about any of the advanced features of Java like Java Beans, etc.

This is my first book on Java, and thanks God it succeeded! I was fed up with Java "Programming Language" style books that give you the syntax with silly "Hello World" examples which does not serve any purpose. But this book covers Java as a "Whole Platform" rather than a Programming Language. You can draw a picture of Java "2" in your mind after reading this book with its syntax, virtual machine, tools (compiler, debugger, documenter), special topics like calling C functions from Java or Vice-Versa, what has changed from Java 1.0 to 1.2 (or 2), 1.2 API reference along with Hints, Tips, and Cautions from a really good programmer. Especially those hints, cautions sections were always able to answer questions that came into my mind. The general style of the book is; it tells you the topic, give a short but very useful example, and tell you almost every pitfalls of that code from the programmer's perspective (what mistakes you shall avoid), from the compiler's perspective (what the compiler assumes), and even from the Java Developer's perspective (why Java implemented that thing in that certain way). In short, this book deserves more attention than its price (only about 20$ !). I am looking forward to Litwak's other books...