|Java 9 for Programmers|
Author: Paul J. Deitel & Harvey M. Deitel
The latest edition of the Deitel tome on Java has been updated to include new facilities in Java 9.
This is the fourth edition of the well known Java book by Paul and Harvey Deitel and you either like their approach or you don't. However, the approach suits some situations. If you are giving an academic course then the book does fit in. If you are looking for something for self study then not so much.
My biggest problem with this book, however is its initial impression. The cover has no mention that this is a 4th edition; for that you have to look inside. You might think that it was a plus point to have made it through three editions successful enough to warrant a fourth, but there is a problem. The previous edition was an updated version to cope with Java 8 and this latest edition simply has Java 9 grafted on. What this means is that this isn't a book written from scratch with Java 9 in mind. This doesn't matter so much for the general reader, but if the book really is aimed at the programmer then it really should be more focused on Java 9. In short this is a book that might well annoy you if you buy it because of its title - Java 9 for Programmers. If you buy it as a book that introduces you to Java from the very beginning and also covers Java 9 you might not be so upset.
What we have is a slightly academic, very detailed, account of Java and object-oriented programming in general. It has to be said that this particular 1120-page brick does its best to be helpful and friendly by including short notes on common mistakes in programming. This makes it slightly less intimidating. But to be honest the layout, and the very small print, probably make the effort futile. It just looks like a hard read. On the other hand if you are looking for a book that covers the ground then you can't really fault this volume.
The book covers Java 9 SE from the first concepts, through objects, the user interface, graphics, JDBC, generics and so on.
As already suggested, even though it is supposedly aimed at "programmers" the text starts off more or less from first principles. If you already program in any object-oriented language then there is a lot you will need to skip. It starts off from an overview of objects, how to compile a hello world program and then basic classes and methods.
Next come the two chapters on flow of control and for the beginner this is going to be too much because it covers everything. If you are just struggling with the concept of a loop you really don't want to deal with all of the possible variations. The approach is complete rather than graduated, even though the explanations are always very basic. If you want a book that does it all then this is a plus point. Another plus point is that it does cover some of the uses of loops that aren't so obvious to the beginner - enumeration loops and sentinel loops.
From flow of control the next topic is to look at methods in more depth. This makes sense because it provides an opportunity to look at modular programming without having the clutter of objects. However it still might be more than a beginner wants to know at first encounter.
The next chapter focuses on arrays and the ArrayList before moving on to classes and objects in general. Chapter 8 provides a deeper look at the whole idea; Chapter 9 is about inheritance; and Chapter 10 polymorphism and interfaces.
At this point we have had a fairly standard introduction to OOP - encapsulation, inheritance and polymorphism with a side order of interfaces. The final chapter on core language features looks at exception handling. Overall these first chapters constitute a fairly basic introduction to Java.
From this point on the book looks at associated technologies like JavaFX and the new features introduced in Java 9. Chapter 12 and 13 are an introduction to JavaFX. Previous editions covered Swing and I'm still not convinced that JavaFX is more worth learning about than Swing. Chapter 14 is about Strings and regular expressions, Chapter 15 deals with files and NIO with a side order of XML and Chapter 16 is about the sometimes difficult topic of generics.
Chapter 17 introduces lambdas, new in Java 8, and still in the wrong place in this edition. Lambdas are too useful to leave until so late a chapter. They are the obvious way to handle event handlers and any situation where you need to treat a function as a first class entity.
Oddly the next chapter is on recursion which doesn't really fit anywhere better. After a deeper look at Generics - variance and wildcards we move on to a second look at JavaFX - this time animation and video.
The final few chapters are similar to the previous edition but with some additions to cover Java 9 features. We have a chapter on threading, database with JDBC and one the new JShell REPL, which seems fairly useless being covered so late. If you wanted to use a REPL then it would have been a good way for the beginner to try out ideas while learning. Chapter 24 is about the new Java persistence API (JPA).
The next two chapters are the same case study that has been in earlier editions on an ATM using UML. The introduction of UML so late on probably isn't worth it.
The final chapter is an account of the new Java 9 module system and in this case the end or towards the end is a good location for it. You don't want to worry about modules until your programs grow in size and so it isn't a beginner's topic.
If you are a complete beginner then the total amount of material and ideas presented might well make things more difficult. This book goes from the very basics of programming to some advanced ideas. As mentioned at the start, the ideal reader is probably a student or teacher engaged in a course on the topic. The book certainly provides enough material and exercises to be used in almost any introductory, and even second-level, course on Java.
Although the cover shouts Java 9 and Java Platform Module System, I wouldn't recommend buying it just to find out about Java 9 specifically. It really isn't for the experienced Java programmer wanting to pick up the ideas in Java 9 or even in Java 8. This is a complete course; not an upgrade path.
The best thing that could happen to the next incarnation of this book is that it be split up into two, or even three, smaller volumes - an introduction to Java that makes use of features in Java 8 and beyond as they are appropriate; an applied book on Java FX and other technologies; and finally an upgrade book for the programmer wanting to find out about Java 9 and beyond.
|Last Updated ( Tuesday, 26 September 2017 )|