Customer Reviews

Head First Java: Your Brain on Java - A Learner's Guide

5 star:		(55)
4 star:		(12)
3 star:		(2)
2 star:		(3)
1 star:		(3)

 

 

When I first saw "Head First Java", it reminds me of the colorful "conversational English" books I had when I started to learn English years ago. The casual, humorous books have turned out effective for English language learning. Is that style good for the Java language learners as well? Is this type of books for beginners only?

With those questions in mind, I started to read "Head First Java". Since I consider myself a Java expert (I wrote a Java book myself, after all), I decided that I would NOT read the book from cover to cover. Instead, I would randomly flip through the book for the humorous stories and photos. I figured that if I cannot learn much new about Java from a "beginner" book, I can at least have some fun.

Geez, I was wrong. I was ADDICTED to the book's short stories, annotated code snippets, mock interviews, puzzle games and brain exercises. They are not only entertaining but also informative. It may be a beginner's book but the stuff they cover are definitely deep enough for expert readers as well (e.g. multiple inheritance, polymorphism, inner classes, threads, RMI, ... just to name a few). The best of all is that I can actually remember the things I learned from the book because I associate them with the stories and pictures. I guess it has something to do with the fact that both sides of my brain are active when reading this book: The right side is for the stories and the left side is for the technical and logic stuff.

There are other great Java books (e.g. "Thinking in Java" by Bruce Eckel) in the market. But they are all very serious and require the readers to spend hours to read entire chapters. The great thing about "Head First Java" is that the bite-size code snippets and stories allow me to learn something about Java in my 5-10 minutes spare time, one piece a time.

The overall writing style is casual and enlightened. The presentation style (fonts and placements of graphical elements) fits the content very well. The book covers a wide variety of Java topics including: basic code structure and language syntax, OOP concepts, math and numbers, exception handling, the Swing GUI library, serialization, network, and distributed computing.

Of course, the casual style is not for everyone. I know people who love the re-assuring feeling from "serious" books. But I can re-assure you that Kathy and Bert are authoritative figures in the Java training community. The content is absolutely first class. I highly recommend "Head First Java" for both Java beginners and expert readers.

Who do Kathy Sierra and Bert Bates think they are? Don't they know that learning a programming language is supposed to be hard? Don't they know that it is supposed to involve suffering? Apparently not, as they have written a complete introduction to Java that is fun to read and easy to understand. If we don't stamp this out now, students will start expecting their teachers to be entertaining!

The book is an excellent introduction to Java. It covers all the typical topics of a basic introductory text and some extra including serialization, networking, and distributed computing. Each topic is covered in a fun way with important information highlighted. The authors use stories, fake interviews, pictures, and assorted other clever techniques to catch your imagination and make the topics memorable. There are plenty of exercises (with answers) to help you check to be sure you understood each chapter. And there are plenty of fun programs to code including a cool music machine instead of the typical "reverse a String" exercises.

If you are looking for a traditional text then this book is definitely not for you. Instructors should think carefully whether this book fits in with their style of teaching. This book is not for everyone but if you want to learn Java and object oriented programming in fun and unique way then this is the book you want. Now I just have to figure out how to keep it away from my students.

In all my years of reading technical books trying to learn new skills, the closest I have ever come to a book like this was when I first read a Dummies book. I liked it because it presented information in a humorous fashion that made things easy to comprehend. This style takes that type of learning to a whole new level. Using a combination of writing style, graphics, illustrations, and sample code, they draw you into each subject in such a way that you can't help but learn and understand.

This book starts with the basics of Java and progresses clear through to RMI and JINI. Granted, those last subjects are just touched on, but at least you're exposed to them. Even after all the Java tutorial manuals I've read, I still got a lot out of this book. For instance, I always was sort of fuzzy on the event listener logic. The Head First explanation was one of the most understandable (and entertaining) treatments of it that I've ever read. Likewise, inner classes were always confusing to me. The coverage of that subject here makes it sound so simple.

And why do you need this if you're a Notes/Domino developer? If you've never worked with Java, you're probably intimidated by the subject and afraid to get started. Don't be... This is the most fun you'll ever have learning a new skill. While it doesn't talk specifically about how to code a Java agent in a Notes application, you'll learn the concepts and the syntax you'll need to be able to do that. Once you have those skills in place, you can move on to a book specific to using Java in a Notes environment (such as Domino Development With Java by Tony Patton). The book doesn't assume you're a programming guru to get started. You will learn a lot from this material, and it's something you need to do in order to continue to stay relevant in the IBM/Lotus world.

Conclusion
If you're a C/C++ guru approaching Java, this book may not be for you. You'll already know much of the material from your exposure to those languages. But if you're a mere mortal like the rest of us, you need to buy this book if you're looking to learn Java. I am SO hoping that the Head First approach to tech writing becomes a series. If it does, I'm ruined for life in what I will expect from a book. This is really great stuff!

I had the pleasure of reading Head First Java as Kathy & Bert turned out the chapters. Though the book has not hit the stores yet, I'd like to share my experience reading the work copy of the book.

I'm a 47 year old programmer that has basically seen it all in my 25+ years in IT. Though I've been busy with Java for more than 2 years, I until recently still saw myself as an absolute beginner. Why you might ask? Well for starters all my Java was simply "hobby" work, I did not use it at work. Secondly, and the most important reason, is that I simply did not understand and grasp some of the key concepts of OO that one needs to know to be able to fully use the capabilities Java has to offer.

As fate would have it, the work copy Kathy & Bert's book became available to me as I started to work in a new department where I have to program in Java. I was drowning. I had to keep on asking the youngsters on the team for assistance. You can't believe what that does for your self-confidence. But as I read more and more of Head First Java I found myself sitting in tech meetings not only understanding what was being said but I was actually coming up with some fresh ideas that helped us re-design our systems to become fully OO.

Why is that so. Simply because of the unique way Kathy and Bert teach and share their knowledge. The best way for me to describe this book is by using the teacher at school that we all have encountered in our school careers. You know the one that enthusiastically drew the most elaborate drawing on the black board to explain his point, the one that simply generates interest in his subject purely because of his sheer love of the subject he teaches. Now imagine that teacher in book form. The Head First way, your favourite teacher in a book.

I can carry on for quite awhile about the unique style of the Head First way, but I suggest you download the sample chapters at O'Reilly or go download the "demo" at Kathy & Bert's own site...

What has this book done for me. For one it finally made me grasp Polymorphism, and the use of interfaces. Though I've used it before, like a parrot without understanding, I never saw it's real strength. Now I use it all the time. I can't believe I programmed Java without them. Head First Java turned me into a Java OO programmer instead of a Java procedural programmer. Yep one can write pretty neat procedural programs in Java.

If you are a Java programmer that has problems understanding the finer points of the language and OO in general I suggest you go out and buy the book.

I want to end with a word of caution. This book, because of it's uniqueness, might not appeal to everybody. I suggest you browse (or download the demo) the book before buying. You will know immediately know if the book is for you.

If you want learning to be fun buy this book.

In short, it's a great book. It will make all your other Java books
indistinguishable from a printed copy of the API. This is how to
actually understand Java. I kept yelling "So THAT's how it works!" at
least once a chapter. It's really amazing how much I realized I didn't
know. Well, didn't understand. I knew stuff and could do the right
syntax and all that but now I think I really get Java a lot more. In
particular OO and polymorphism which, let's face it, are the kind of
thing that seem simple at first but are slippery to really get ahold of.

The exercises are excellent. I think I could learn more from just the
Head First exercises than from the other books on Java I've bought,
combined. When you buy this, do them all at least once.

I want to point out one particular thing they do with the weirder
concepts. They'll introduce and explain a topic, and then you go to the
next page and there's a picture of someone going "Huh???" And the text
will say yeah, this is a weird concept, and start again and explain it a
different way. And then clarify it again. By then you really do
understand it. I think this is great because it acknowledges that some
of these concepts are just hard to learn. No matter how brilliant you are or
whether you're the love child of Bill Joy and Carly Fiorina.

You absolutely must have this book if you want to learn Java, and you
absolutely must have this book if you've been programming for a couple
years but you have to admit deep down you're still a little fuzzy on a
how things really work.

Earlier this year I decided to learn Java. Grabbing a copy of 'Learning Java' from O'Reilly I started learning.

Of course, you can't learn Java without a good understanding of object-oriented languages. I made fairly heavy going with 'Learning Java' until I decided to dive in head first, 'Head First Java' that is - I bought this book that has a totally different attitude to teaching than I've seen before in computer books. The style is humorous, full of graphics, cartoons, puzzles, quizzes and crosswords. It reminds me of the textbooks that used to try and teach me geometry and algebra in high school or my daughters elementary books on Roman and Greek history I purchased for her at the British Museum. The style didn't work to teach me much algebra and geometry, but I wasn't anywhere near as motivated. This time, it worked. In a couple of weeks I worked through the book and finally have Java skills where I can branch off and start coding the projects I had in mind (though something more advanced will be required soon.)

In the introduction the authors examine learning and explain why they designed the book as they did. To quote from one section: "Some of the Head First learning principles. Make it visual. Put the words within or near the graphics. Use a conversational and personalized style. Get the learner to think more deeply. Get-and keep-the reader's attention. Touch their emotions." They argue that our brain is tuned to novelty, and that their style provides the novelty to keep your brain turned on. They also provide ten tips for good learning. That's one thing that seems to set this book apart from most other computer books, they say they think of their reader as a learner and indeed that's the way you are treated by the book.

The book also has a good emphasis on test-driven development, a good style to get new programmers started. I also appreciated the excellent chapter on how to package all your code up for release, something that you might expect to be trivial but not quite as easy as expected.

When compared to 'Learning Java' the coverage is not as good, 'Head First' really only covers the basics, up to and including creating a GUI with SWING and then touches a number of others; 'Learning Java' goes on to explore, with a fair depth, network programming, web programming, servlets, applets, Java Beans, XML and other topics that are only touched on briefly in 'Head First.' If the style of learning does not suit you then this will be an incredibly irritating and useless book, I'd give it a try first, though.

This edition also has a fair number of errors, including some in the examples. To this all I can say is "shame, shame, shame." I keep on harping on this in computer book reviews but if you can't figure out a way of including code that compiles and/or runs in your book then give up. The example code is available online - how hard is it to check that it all runs and then include that source directly into the text.

When you get down to it, though, the only way to really decide on the worth of a tutorial is to decide how well it teaches. 'Head First Java' excels at teaching. OK, I thought it was silly, I had a hard time making myself do the exercises, fill out the crosswords and solve the puzzles. Then I realized that I was thoroughly learning the topics as I went through the book. 'Learning Java' was doing the same job, but the dry traditional method wasn't doing as well. Both books are well written, designed and constructed-the style of 'Headfirst Java' just made learning, well, easier.

It would seem to me that the 'Head First' approach is going to work wonderfully for the more 'beginner' topics, books for introducing you to a new style of programming, a new language or a radically different operating system or application. So if you're looking for a book to introduce you to Java then I can recommend 'Head First Java'. Now if I could only find a book as good to introduce me to Common Lisp.

I was skeptical when I heard about this book, and even MORE skeptical when I saw it (at the JavaOne conference). At first glance, it looks like an explosion at the graphics factory. But it was fun to flip through, so I started looking at some of the pages, and I realized that I was learning things just looking at the pictures, that I hadn't known before. Whoever thinks this is a 'dummies book' hasn't read it, but I can see how it might appear that way if you don't really get into it.
This is a learning book, the authors go to great lengths to make that clear, and to explain the learning principles behind all the visuals. I have read three Java books, and even taken a two-day intro course, but there were still many key pieces that I didn't quite get until I worked through this book. I think its really important to do the exercises (I think the puzzles are optional).
I got through this book much faster than with the other books that cover the same topics (I won't give the book names, and they were very good books, but I can understand them better now that I really learned the topics from Head First Java), and now I understand some things much better than I had before. Things like OO concepts in particular, but also some of the distributed programming topics.
One nice thing about this book is that it makes even the advanced topics seem easy. I have the feeling sometimes that books make things even more complicated than they should be, and I am not sure why that is. Maybe it is because so many text books cover a topic in such detail (and with so many words) that you have a hard time getting just the key points out of it, so that you can understand and it and USE it.
There is a large optional exercise that covers several chapters, that uses JavaSound -- it is a multi-user, networked midi drum machine. If you are not into midi music, you might not want to take the time to go through it (but I think that is why they say it is optional), because it spend a fair amount of time teaching you about something (the sound API) that you will probably never use. But I thought it was a lot of fun, and I learned a lot more Java from it. And I am now building a 'learning music' application as a result of getting started with that.

If you see it in a store, take the time to read some pages, or look at the sample chapters before you say it's a dummies book. It is definitely not a dummies book! I really don't consider myself a dummy, I just prefer it when things are clear.
I guess there are some people who will not like this style, and it does seem geared toward a younger audience (I am 45, but I have teenagers in the house). But it was the right choice for me, and I think it will probably be the right choice for most people trying to learn Java for the first time (or in my case, the third or fourth time). I wish this had been the first Java book I had picked up. Yes, there is a certain amount of 'cute', but I will never forget some of this content simply BECAUSE those pictures are in my head. So in some ways, I guess it like having an annoying radio commercial or song that you can't stop humming. You might not necessarily like it, but you can't forget it.
They claim this is part of the learning principles behind it -- that if you store information as both a picture and text, it is in two different parts of your brain, and doubles your chance of recalling it.

It is a very differrent experience, and I guess that people who are more comfortable with traditional methods might not like it. I happen to like things that are off-beat, and this was the perfect way for me to learn. One problem is that now I am hooked on this style and it's going to be harder for me to go back to learning things with text books. I am waiting for them to apply this format to other things I need to learn. O'Reilly are you listening?

For those programmers that want to learn Java, this book is an excellent resource. It appears to be targeted towards experienced programmers coming from a different language. There is a great deal to like about this book. The content is at an appropriate depth and numerous topics are covered. Most important perhaps is the way that the material is covered. Graphics and text are mixed in such a way to keep the reader visually stimulated. The explanations are very atypical for a book on a technical subject.

The book is organized as a tutorial of seventeen chapters that start with object oriented concepts and progress through graphics, swing, networking, I/O, RMI and deployment issues. I really like the Code Kitchen project. It is built in an incremental fashion on the material covered in the later chapters. In each chapter there is a group of exercises to challenge your retention of the material. But even more powerful are the learning concepts that the book is based on. Kathy and Bert are experienced instructors, but they have taken their knowledge of the content and merged it with the latest information in learning concepts to create a book that is fun to read, but a tremendous teaching tool. Dry and boring authors beware; tedious technical tomes are no longer acceptable, if they ever were.

The book is an excellent investment in time and money for anyone that wants to learn Java, but if you prefer a more serious tone, there is always "Thinking in Java" by Bruce Eckel, another of my favorites. However, we liked the book so much that we bought several copies to start some of our staff down the Java road. One last point, do the exercises. They may seem a little trivial, but like calisthenics, they are very effective.

I've been teaching and working professionally in programming, analysis, and design using object-oriented technologies for about 15 years (C++, PowerBuilder, and now Java), and procedural languages (assembler, C, Pascal, and PL/I) for about 15 years before that (yes, I'm old). This is far and away the best programming book I have ever read. One of the biggest hurdles for anyone programming in Java (and C++), who came from a procedural background, is that the way to think about designing applications, as collaborations of objects, is not the way they're used to thinking in procedural programming. It is amazing how many ex-C programmers are out there, writing really terrible C++ and Java code (imho) because they write it like they used to write C. The great thing about this book is that it forces you to think differently, about learning and about programming. Don't let the pictures and jokes fool you - if you work through this book, cover to cover (which is probably the only way to do it), you'll learn some tough concepts and write some challenging code. As the authors and several reviewers have said before, if you want a reference guide, look somewhere else. However, if you are: new to programming, or, an experienced procedural programmer who wants to learn a different (OO) way of thinking and programming, this book should give you a high level of comfort with Java and object-oriented programming. You must also be willing to laugh a little and work hard - do as many of the exercises as you can, and study the answers for the ones you can't. If you don't work at it, you are cheating yourself. And while you might be annoyed by the weird graphics and jokes at first, they grow on you, if you don't take yourself too seriously!

I'm revising my review yet again. The reason is that I've read more Java books now and have come back to this one for a few reasons. I'll explain below.

I'm a C programmer and needed to understand the Object Oriented ways of programming. I understood the general syntax of Java, but got a bit lost when dealing with the OO (Object Oriented) areas. Since my current job is wanting me to learn Java for a few projects, they sent me to a 1 week crash course on Java, which didn't really help too much.

A week later, I picked up this book. There weren't any reviews on this book yet, so I just picked it up in [local store]one afternoon and started reading the introduction. Based on the introduction, I found it to be a book I wanted to actually buy. The introduction gave some great pointers on studying, how the common brain works and such. After buying it, 5 chapters in I was loving this book. As a matter of fact, I loved reading this book all the way through. It was quite an entertaining book. However, entertaining isn't always helpful. There were some areas that I think are much needed in programming texts that were either left to a vague description in the Appendix, or left out all together.

Despite all of the pictures and weird layout of the book, it did an *excellent* job at explaining Object Orientation. I think what helped me out the most were the little "Java Exposed" interviews with the parts of Java. While these were kind of silly, they truly did help me understand the material better. Also, the "Bullet Points" were a great help as well. It did what I wanted it to do, and that was to help me get a firm understanding of OO.

Also, the fact that it goes over I/O very well and also spends some time going over a bit of GUI development, made this book even better.

What this book did help me learn was Object Orientation. What it did not help me learn were a lot of the finer points of Java. These areas (such as why you should override equals() and hashCode() and what their tie-ins are) most definitely should be looked into by either reading some other books (Java 2 Sun Certified Programmer & Developer ISBN: 0072226846 is great!) or going to the java.sun.com site and reading their documentation. There are some finer points of Java that just weren't covered in the book due to it being a beginners guide. However, please seek further knowledge and don't consider this book the do all/say all of the entire Java language.

All in all, this book is great. I still wish they would of added some more small items such as a simple explanation of finalize() in the garbage collection chapter and also explain the purpose and maybe even a quick example of how to overried the equals() and hashCode() methods properly since they tend to talk about how important it is in the book. Anyway, now that I've read more Java books, I've found this one to be the most pleasing so far.

Hope this helped.