Rating: 
Summary: Appalling at times
Review: ... at times this book is absolutely appalling...The code peices offered are sometimes dreadful and violate one of the fundamental axioms of programming nowadays: give members meaningful names. Now our book here usually does that but there are times (eg static inner classes) where the authors gives as about a dozen motheds and fields centered around names like nonTSaticMethod_1(), staticMethod_1_1(), staticField_1_1_0 and so forth. ANd then they offer some explanation of this. Now imagine fifty-sixty lines of code in a class with names such as these and then try wending your way through the explanation that is supposed to acocmpany it (often not on the same page)...so flipping back and forth is necessary to try and find all these confusingly similarly named methods and fields. It's dreadful trying to learn tough-ish concepts presented so badly (this behavior seems to occur in 'difficult' topics: narrowing conversions for reference types, inner classes). Really makes you want to throw the book (as a previously reviewer suggested). Really, it's not good.Generally the language used in this book is at times stilted, prissy and very obnoxious (written by people for whom english is not a first language apparently...started to make me cringe reading it: could only take about an hour of it at a time- it's just so...off? Like not normal). Other times this book is really good. But there is some hurdles to get over to get the best out of this book. The CD accompanying the book could be fantastic: has several exams, exam and quiz generators and such so you can do full exams or even quizzes that target your weaknessess, which are very cool: however you have to pay extra for most of those additional features. There are three practise exams (though one has a problem with a timer- 61 quetions in 15 minutes!). But I'd suggest buying the book by Bert Bates and Kathy Sierra instead of this: it's cheaper, much more fun, more easy to read with clearer explanations; the chapter summaries are great and the end-of-chapter questions like those on the exam. But that's the choice you make. Maybe you'd can hang around and catch my copy of thos book as it comes flying by. I'm disappointed with this book.
Rating: 
Summary: A Must Have
Review: A Programmer's Guide to JAVA Certification, Second Edition
---------------------------------------------------------- This is one of the best books for exam preparation that I have read. In fact you can use it as an excellent Java reference book, a textbook and/or professional hands on source. It is geared towards passing the Java Sun Certified Programmer exam CX-310-035, but it actually prepares and elevates your knowledge to a higher level than the exam requires. Aside from preparing you to pass a Sun certification exam, the book can help you stay sharp, up-to-date with current technology terms. I have been using Java since 1994, right after it came out to the market. Even after so many years applying the language in the business world, I still find topics that I can brush on, or were totally forgotten... What are Anonymous Arrays? What are Upcasting and Downcasting? What is Dynamic Method Binding?... You should be able to find answers to these questions and others, in this excellent book. The CD accompanying the book contains great resources such as Whizlabs exam simulators, source code, solutions to programming exercises etc. It is highly recommended! Michael Bell.
...
Rating: 
Summary: Good book to prepare for SCPJ2 1.4 exam
Review: All in all, this is a good book to help prepare you for the SCPJ2 1.4 exam. For the most part explanations are concise and adequately explain the topic. I also like the tie-in with Whizlabs testing software. Since I gave this 4 stars, I won't go into everything I liked (since I obviously like this book), rather, I will give some detail as to why it didn't garner 5 stars: - The book is aimed at experienced programmers with or without Java knowledge. Well, for the most part that is true, but I believe that many novice Java programmers will need an additional source to learn Java. The explanations were sometimes lacking from the point of view of a new Java learner. So if you're totally new to Java, you may need an additional source to supplement this book. - Flow. This book frequently refers you to other sections of the book. Get used to being in the middle of an explanation (that spans only 2 pages) and it may provide 3 different references to other chapters/sections in the book. For instance, in section 4.2 "Defining Classes", in the 1 page of text devoted to explaining this topic, there are 9 references to other sections in the book to help the reader better understand the topic. Now, some of these are necessary as sometimes covering one topic requires you to mention something you haven't discussed, so references are nice if the reader wants to jump ahead to understand some minor point before returning to the topic at hand. However, I would like to see a more detailed discussion for each topic rather than skipping around through the book. - Exam Objectives at beginning of each chapter are somewhat annoying. The intent is good, but the implementation is lacking. When I read an "intro" or a bulleted list at the beginning of a chapter, I expect that is what the chapter is about. Not so in this book. Some chapters will mention many topics in the "Exam Objectives" prefacing the chapter, yet some or many of those objectives are not discussed in that chapter, but rather, you are given references to where they are discussed. Why couldn't they just say "here is what is important in this chapter" and leave it at that? As I said at the beginning, this is a good book and worthy of four stars, so don't let my negative comments fool you. I liked the book, I just would have liked it better had the latter two items I mentioned been better addressed.
Rating:
Summary: Orange cover - it will stand out on your book shelf
Review: Color of the book aside - the content is layed out with taste and thought. I found the use of UML helpful. However I'm experienced with UML - if your not, this may be an area that's not covered well enough for you; but UML is not the intent of the book. I've seen lots of computer software books and typically one sees the same tired graphics, useful but cliche. So I was impressed with the graphic to explain overflow in floating point numbers, Figure 3.2. I got a great laugh with the "(Not drawn to scale)" note, as it's hard to get a graph of negative infinity to positive infinity drawn to scale. I think this little pun will allow me to recall this graphic far into the future... Since I'm experienced with Java, have passed the exam some time ago, I didn't find the prolific use of "(see Section 4.1, p. 104)" annoying. However for a beginner this will cause more flipping back and forth than a good book is designed for. If the book is converted to a web site - this will be acceptable. I believe the authors cover the subject, passing the exam, not learning Java (the art of programming in OO with a toolkit so large as to require a tool-chest as large as the building). If you want to pass the exam (and you must - for you wouldn't read this prattle otherwise) this book is an excellent resource! If you have a bit of experience with Java, and one should before taking the exam, the book will be all you require to pass - well, except lots of study time, but time is a renewable resource! David PS - in the interest of full disclosure, the publisher gave me the book to review
Rating:
Summary: Helped me score 80 per cent on the exam first time
Review: Excruciatingly detailed explanations of all important Java language concepts and constructs. Intriguing examples in code of key Java programming principles and rules. Thorough coverage of every objective and sub-objective of the certification exam. And the best sample mock exam, in my opinion, of any of the certification texts (although I guess Whizlabs, not the authors, should get the credit for that). In short, an enormously helpful book for anyone doing serious study for Sun Certified Programmer for the Java 2 Platform. I took a course in Java, then read this book through all the way, and then re-read select portions after doing practice exams (I used some mock exams from the web to supplement the one in the book), and then re-read some more. The result was the score I have reported above: I'm Sun Certified!
Rating:
Summary: Must have for test preparation and learning
Review: First, I'd like to be upfront that I was sent this for review by Addison Wesley and that I am a big fan of their professional series but my opinion is not influenced by anything other than this book's merit. I've already earned my certification and I've been programming Java for over 5 years. As I read, I continuously applied three standards: "Would this have prepared me to pass the exam?", "Would this have prepared me be able to handle the responsibilities of a job where my certification was the basic qualification?" and "Would solid understanding of this books contents be sufficient for me to hire an intermediate level Java Developer?" So, what do I think about it? I think that if you are serious about getting your Java Cert, you need this book! I think that if you are serious about being a professional Java developer, you need this book! I think that, I will be making this book mandatory reading for junior developers!
Things I liked about it: * One stop shop for certification preparation. This book covers all the exam objectives thoroughly and explains the topics clearly. I especially like the sections on Threading and Exception Handling. * Excellent style for the intermediate level programmer. This book hits the target audience mark with perfect precision. The reader who already has a basic understanding of the language and has written a couple of applications will find the book easy to follow and highly informative. * Great examples, UML diagrams and tables. The book is laden with solid example code and UML diagrams that illustrate the topics. Many of these, if understood, lead to direct answers to difficult test questions. There are also very well laid out tables that give ready summaries of topics such as Primitive Types and their default values as well as operator precedence-indispensable for the exam. Things that I think could be improved: * Computational Theologist--the title of Gil Bracha, the guy who wrote the forward.This might be odd, but it really bugs me. Why? It sounds so pompous and corny that, without any personal or professional experience with Gil and not having the slightest clue what he really does at Sun, I immediately assume that he's a sham. What does that imply about the book itself? I want to make it clear that the book is fantastic. It's just that, if I picked this book up off the shelf and saw that job title associated with it on the front cover, I would immediately replace it on the shelf with a guffaw. I'm glad that this didn't happen because I would have missed out on a superb text. * Explanation of why to override the 'equals', 'hashcode' and 'compareTo' methods is misleading. Basically, the text could lead someone to believe that, unless these methods are overridden, a class cannot be used as members of Collections, HashSets or SortedCollections/SortedMaps: This is not true. In many cases, if you don't override them, then try to use them as the book says you cannot, you could end up with non-deterministic behavior. However, that doesn't mean that there aren't cases where it would work perfectly fine and, there is certainly no language specified restriction to this effect. * Not enough explanation of the gc() method. This is particularly picky, but the book is so well done that I have to scrape to find something to put here in order to maintain my review's structure. Here's the thing, gc() is a 'recommendation' to the JVM that it should garbage collect. The authors do use that word, but I don't think they do a good enough job pointing out that there isn't a straightforward way to guarantee that garbage collection should happen. If you're preparing for the Java Programmer Certification Exam, or you just want an excellent Java language text, this is a sure thing. It's certainly earned a spot on my top shelf.
Rating:
Summary: Good to Keep Around After the Test
Review: I found this book to be very complete with extensive examples and good questions. This book goes into more detail than most certification guides and actually stands as an all around good reference work. Some may find the detail and longer examples a bit daunting, but in the arena of certification guides, this stands out as accurate, detailed, complete and one you will go back to again and again. I think the layout could be a bit clearer, and more highlighted points and summations would help getting through the text. However, the detail and accuracy make it valuable beyond exam day, so I gave it the 5 star treatment! A solid book.
Rating:
Summary: Great details, Good questions
Review: I read many chapters of this book and found the subjet matter to be covered in great details. Good list of questions with
detailed answers. I recommend it.
Rating:
Summary: Best for java 1.4
Review: I started to use java since its beginning, three years ago, I used this book's first edition <> to pass my SCJP1.2...I really learnt a lot from this book and I rated it as the best one at that time. Now I passed SCJD, SCWCD and SCEA and became java architect in my company... I think the book gave me solid java foundation. I am glad to see its second edition out, it is more focus on the current SCJP certification, and contains a CD of SCPJ2 1.4 Exam Simulator developed by Whizlabs Software, which includes several mock exams and simulates the exam-taking experience. It explains common pitfalls in detail. I admit that after lots of year's java experience, I still learn a lot from the second edition of this book, which is even deeper than its previous edition. Wish other readers enjoy this book as well. Daniel
Rating:
Summary: Excellent Certification/Basic Java Reference Book
Review: I used "A Programmer's Guide to Java Certification" as a study guide for achieving my Java Certified Programmer (JCP) status two years ago, so when I had the chance to review the second edition, I jumped at it (full disclosure: the publisher sent me the second edition to review). As I expected, I was again aghast and delighted at the level of detail, the exercises and the arrangement of this fine book. Mughal and Rasmussen do a good job of covering all the nitty gritty details that the JCP requires one to know. Whether the length in bits of an int, the difference between overloading and overriding, or the order in which initializer expressions get executed, this book gives one enough detail to overwhelm the novice Java programmer, as well as cause those more experienced to scratch their heads and perhaps write a small program to verify what was read was valid. While this book lacks the discussion of I/O and the GUI of the previous edition (due to changes in the JCP test), it has a fine set of chapters on some of the fundamental libraries and classes. My two favorite explications are the chapter on Threads (Chapter 9), where that complicated subject is treated well enough to motivate more learning while not overwhelming the reader with detail, and the String and StringBuffer section of Chapter 10. So much of the Java programming I've done has been dealing with Strings, so this section, which covers the String class method by method and deals with issues of memory and performance as well as normal use, is very welcome. The exercises were crucial to my passing the JCP, and they remain useful in this book. Grouped at the end of logical sections of chapters, they break up the text and re-iterate the lessons learned in the previous sections. The answers to these exercises are in the back of the book. Also, a full mock exam is included at the back, as well as an annotated version of the JCP exam requirements which serves as a study guide (both for the full JCP 1.4 and for the upgrade exam). Reading over the mock exam definitely let me know what areas I'd need to study if I was taking the JCP again. In short, the didactic nature of this book has not been lost. The arrangement of this book is also useful. A fine index and the logical progression through the features of the Java language eases the onslaught of detailed information mentioned above. The extensive use of UML diagrams (especially class and sequence diagrams) was helpful as well. If one reads the book sequentially, one learns about how object references are declared (Chapter 4), then the various control structures available in Java (Chapter 5), then the basics of Object Orientation (Chapter 6), then the object life cycle (Chapter 8), in a very linear fashion. Additionally, there is extensive cross-referencing. This may not be useful to the novice programmer, but to anyone using this book as a reference, it's invaluable, because it allows Mughal and Rasmussen to provide yet more logical linking of disparate topics. However, this book is not for everyone. I wouldn't buy it if I wanted to learn to program. While there are a few chapters that have general value (Chapter 1, Chapter 6), the emphasis on mastering idiomatic Java, not general programming concepts. Also, as they state in the preface, this is not a complete reference book for Java. It covers only what is needed for the JCP. Finally, if one wants to know how to use Java in the real world, don't buy this book. While most of the java programming I've done has benefited from the understanding I gained from this book, it has not resembled the coding I did for the exercises at all. This makes sense--this book is teaching the fundamentals, and does not pretend to cover any of the higher level APIs and concepts that are used in everyday programming.
| 
