Used price: $5.75
Collectible price: $10.59
Buy one from zShops for: $13.09
List price: $24.99 (that's 30% off!)
Used price: $14.00
Buy one from zShops for: $17.37
If you dont plan on going to course, read it BEFORE starting your
studies from the bigger Study Guide for a good overview. (I recommend "RHCE Red Hat Certified Engineer Linux Study Guide, Third Edition" by Michael Jang) Published by McGraw-Hill.
Happy Studying!
Good luck with your exam.
List price: $45.00 (that's 30% off!)
Used price: $22.98
Buy one from zShops for: $31.27
Used price: $164.93
Used price: $4.95
Collectible price: $5.25
Buy one from zShops for: $4.99
Collectible price: $26.47
Used price: $5.49
Buy one from zShops for: $5.51
Used price: $25.95
Buy one from zShops for: $35.00
The chapters of the book are organized along the same lines as the Sun objectives, but in general the order of the chapters makes more sense than the order of the objectives. For example, the objectives' section 4 (Language Fundamentals) and section 5 (Operators and Assignments) are covered in early chapters of the book, as they should be. It makes no sense to discuss Flow Control and Exception Handling (objectives section 2) until the fundamentals of the language are covered.
Each chapter is laid out in reasonable sections. Most sections begin with a general theoretical discussion and include a number of examples to illustrate the principles. Most sections end with review questions that can be used as an initial check of how well you understand the material. For the vast majority of the sections I studied, there is just the right amount of material included in each section, and just the right number of review questions to cover it.
Both the book as a whole and most individual chapters go beyond the Sun objectives. The authors list "Supplementary Objectives" at the beginning of each chapter to clearly identify what additional material is covered. This practice makes sense to me. First, the objectives don't completely cover what you need to know to use Java. The Supplementary Objectives provide that additional information. Second, if the Sun objectives change, you are less likely to need an additional text. The book covers the Java language, not just what you need in order to pass the certification exam.
I found the chapters on Collections, AWT Components, and AWT Events to be especially good. The diagrams of the inheritance structure make the class and interface relationships clear. The accompanying text explanations are clear and concise, and give a detailed overview of the most important classes, interfaces, and methods in each area. I knew very little about any of these areas when I started, but had no problems with any questions about them after I had mastered the material in this book.
I also found especially helpful the diagrams in section 4.9, Member Accessibility Modifiers. When used with the text, they perfectly illustrate the different accessibilities provided by the public, protected, default (package), and private modifiers.
The book includes a practice exam, with clearly explained answers. The questions are on a par with the questions on the actual exam, at least in my experience. I took many practice exams while preparing for my test and found most of them to be lacking in some way. Most ask easier questions than the Sun exam. Most have at least a few poorly worded questions. This is not the case with this book's practice exam.
Now my complaints about the book.
I thought Chapter 7 on Inner Classes should be clearer and more systematic. Each kind of inner class is discussed fully, but the characteristics are not always covered in the same order. I found I needed to make my own chart of the characteristics of each kind of inner class in order to clarify my understanding. Once I understood the material, I felt I must be missing something because it seemed much simpler than I had thought based on reading the chapter. I checked out the topic in the language spec and found that very little space is spent on this topic. There are a few simple concepts to learn and a few additional rules to follow, but other than that, inner classes are no big deal.
I have a similar concern about the chapter on Java I/O classes. The diagrams and discussion of the inheritance structure of the various InputStream, OutputStream, Reader, and Writer classes are great. Unfortunately, the inheritance structure tells us next to nothing about how the classes are used. There are other charts that attempt to overcome this shortcoming by listing the various classes in different groups, but I feel it could have been done better. Here's the idea I used to clarify it to myself: what Stream objects can be created from "primitives" (ByteArray, String, File, etc.)? What Stream objects must be created from other Stream objects? Answering these questions tells us much more about how to use the various classes.
I found several minor problems with ambiguous wording, unanswered obvious questions, and missing rules. The author does warn the reader not to depend on the text alone, but to write sample Java code to test out all the concepts. However, I feel that more careful attention to these details would mean many fewer test programs. An example is the discussion of the keyword "transient". The book notes "... the transient modifier should not be specified for static variables ...". Does "should not" here refer to a compile error, a question of good style, or something else? The text also ignores the obvious question "What values do transient variables get when an object is created by deserialization?" If there's a rule about this in the Java language spec, then the book should cite it. If there's none, then the book should note that fact and discuss it.
Finally, I found something lacking in the coverage of exceptions, specifically this question: How do "return" statements in try, catch, and finally blocks interact with exceptions? What value is returned if there are return statements in both try and finally blocks? If there is a return statement in the try block and in the statements following the finally block? This can be a confusing topic, but is considerably clarified using the concept of "abrupt completion" discussed in the Java Language Spec. The book would benefit from using this concept in its description of exceptions.
Overall, I recommend this book to anyone studying for the Java Programmer's Certification exam. But you should not rely on this book alone. Write test programs; go to other sources to investigate questions not answered by the book; take various practice exams; create your own tables to make your understanding of the topic more systematic.
I'm 50 years old, with 20 years experience of COBOL programming and should point out that I have not read any other similar books and haven't actually taken the SJPC exam yet, so cannot comment on how well it prepared me for this. However, with no commercial Java programming experience, this book has made me confident about taking the exam - an exam which Sun Microsystems says cannot be taken without programming experience.
Prior to starting the book, I had completed course M874, a postgraduate course on Java, with the Open University in England. This Java 1.1 course only covered the language basics however. The book provides the rigourous, no-nonsense, complete story on each aspect of the Java language syntax. It repays close attention to the code examples.
Note however that not all of the book is relevant to the exam, so you can leave some chapters (Swing, Graphics, etc) until after the exam. There is an appendix to cross-reference the exam objectives to the relevant chapters, but please note that since the first edition, the Programmer Certification exam objectives have changed, so that chapter 18 Files and Streams is now relevant to the exam.
Thus the book not only covers all of the exam objectives, but also has chapters which cover other essential aspects of Java.
The exam is a 'closed book' exam, which means that you need to remember quite a lot of Java syntax and features in the core packages. As a C++ programmer with minimal experience in JDK 1.1 - I decided to learn this language/platform correctly - ordered this book and locked myself in a room for 14 days (It was exactly(!) 14 days between the day I received this book in the mail and the day I took the prometric exam.)
The result:
- 62 pages of notes on 'squared' A4 note-paper, averaging at about 5 pages per exam objective.
- A first-time pass with a result of 83% - passing every section.
If you compare this to Sun's recommendations of 1-3 courses followed by at least 3-6 months of post-course experience, you can only shake your head. Conclusion: Save your money and just do it.
Please excuse me if I'm bragging a little in this review - but it's a true story and I'm surprised that it could be done when looking in the rear view mirror - and by the way, don't worry if you don't pass the test-exam in the book - it's much harder than the real thing.