I recently had the pleasure to read and examine Murach's Java Programming 4th Ed. Joel Murach does a good job of producing training and reference manuals for a variety of Java technologies. This is no exception.
The book focuses on
Java 7 Standard Edition, but does include a number of other features which were added in Java 5 and Java 6 for completeness.
One of the things I really like is that it uses
NetBeans as the IDE to teach Java to the next generation of programmers. A lot of books on Java focus on the language itself. This would have the appearance that an IDE plays no role in learning Java. Any professional programmer will tell you that an IDE is absolutely essential in making you more productive. Joel's choice of
NetBeans as a tool to teach Java with demonstrates its ease of use with beginners. Chapter 1 is dedicated to getting the new programmer up to speed with
NetBeans.
The book offers educators and trainers optional support materials for teaching. This thoughtful approach to education is vital for anyone teaching Java.
The layout and examples are designed to get the programmer up to speed on the topic being covered. A typical example of the layout is to have textual material on the left-side page with examples on the right. This allows you to read the material, and refer to the actual code examples. The book layout makes it easy to teach and learn. You are not left reading a volume of material without any code examples to make the essential points. This is a real benefit to the reader.
In addition, the book is developed with exercises to get the beginner involved. The exercises are based on the material learned in the chapter. The example exercises follow a common theme throughout the book allowing you to build on top of the information learned in the previous chapters. This common thread keeps you engaged through the book to see how the different topics tie the applications together.
Overall I would highly recommend the book to anyone looking to learn Java 7, or update their skills.
I would give it (4/5) stars.
Chapters
Chapter 3 has a great section on using BigDecimal and arbitrary precision arithmetic. I really liked the explanation and examples. Although
BigDecimal was added in 1.4.2 it is not used as much as it should, and this gives it a little press.
Chapter 5 mentions a best practice which is often overlooked. The practice is to add any custom exceptions to the package in which classes are likely to throw them. Often I find that the exceptions are in a
package.exception package. This may be a good design if there is a general hierarchy for using the exceptions in multiple sub-packages, but generally is not the case.
Chapter 7 describes a relationship between a class and its instance. The description is eloquent and worth repeating.
"Once an instance of a class is created, it has an identity (a unique address) and a state (the values that it holds). Although an object's state may change throughout a program, its identity never does."
This is a beautiful explanation of OO programming relationships between a class and instance.
Chapter 8 has a discussion on the use of
final. The point to be made is that if you declare a class
final, all of its methods automatically become
final implicitly.
Chapter 10 on nested classes really does a good job of explaining the requirements and limitations of nested classes. There are a couple of exam type gems like an inner class can not contain any static methods, or variables, and a static class can only reside inside another class.
In chapter 11, there was a remark about using
Arrays.sort(Object[]) to sort an array. It mentioned that the objects must implement the
Comparable interface. I thought that it would "naturally order" without it. I was wrong. I validated that specific case. Even an old dog can learn new tricks.
Chapter 19 is the best tutorial on StAX I have seen. It is simple and easy to follow. After reading the chapter, I will go back and look at StAX when I need this kind of low level XML handling.
Chapter 20 covers
Apache Derby (
JavaDB). It does a good job of explaining the basics, and gives some implementation recommendations. My only gripe is that the author fell into the Oracle trap of claiming that it is not an enterprise capable database. This is simply not true as borne out from my own experience.
If there is a weakness in the book, it has to do with Chapter 22 on Threads. The chapter does not cover this important topic in enough details. It also does not mention the
Java Concurrency Library which has been standard since JDK 6, and handles a lot of the issues with direct thread programming. This chapter should be updated.
Errata
Figure 2-5 Statements that mix int and double variables. The first example requires a cast to int.
int result9 = (int) invoiceTotal / invoiceCount;
Figure 9-1 Example 1 should reflect the current Java design principles. All methods of a public interface are
public and
abstract.
public interface Printable {
void print();
}
Figure 9-1 Description bullet #3 should read
A classs that implements an interface must provide an implementation for each method defined by the interface, or the class must be declared abstract.
Figure 10-8 Bullet #2 is incorrect. A nested class does not need to be enclosed in a public class of the same file name as the public class. For example X.java could contain the following code:
class P {
Q q;
P() {
q = new Q();
}
public Q getQ() {
return q;
}
class Q {
void print() {
System.out.println("I am inside P");
}
}
}
This will work without being in a public class.
Figure 12-2 Common Collection Classes.
The statement that a
HashSet requires that classes to implement a
hashcode is incorrect.
Chapter 12 (Page 384) 2nd Para. incorrectly states the two queue methods as
push and
pull. The
pull method does not exist, and was likely supposed to be
pop. There are actually three from the
Queue<E> interface of note: offer(E e), peek(), and poll.
