This was the required book for a Java class I recently took at our local community college and I'm thankful. Not only was it a bargain compared to so many of the extremely overpriced college texts, but it's been a great read. The authors have taken a less mainstream approach to teaching the subject. This is not one of the 800 page "Unleashed" type reference books.

Instead of pages of dry text and syntax they've taken the approach to introduce a concept, give some "usually" runable code examples and further reinforce the concept with pictures/diagrams, humor and then wrap the chapter up with puzzles and other exercises. If you're starting out learning Java this is a great first step.

More than once when a rather complicated concept was introduced and I went, "Huh?", the authors would continue to clarify the concept. They know the source material very well and seem to know the primary target audience very well.

I had read some of the other reviews and one person claimed to have finished the book but stated the fact that they didn't learn enough to write any Java code. I find that statement impossible to believe. Even just working through the chapters you write lots of small programs from games to a music synthesizer. This book is intended to be the first step on your path to learning Java and while you won't be a master Java programmer after reading it, you will most definitely be on your way to building a solid foundation.

This book does expect the reader to have decent knowledge of computers and at least some basic knowledge of programming concepts but other than that each chapter introduces the concepts in nice bite-sized chunks.

My community college class only covered half the book but this book is easily useable for self-learning. I plan to re-read the book from the start and then continue through the 2nd half.

I'm a fairly well versed programmer in some of the older style languages like C and C++. If you have some archaic C question, I may be your woman. I'm not so familiar with Java - in fact the last time I touched the language I could run to the local coffee shop, get a coffee, and get back to my program and it would just be starting up (back in the dark days, when java was really slow). Fast forward 12 years and not only is Java nimble and performant, but its something I need to know. Yesterday. Knowing this, I turned to the Head first series as they get their points across quickly and cleanly.

Head First really does teach the topics so that you'll remember them. Most into programming books give you an example and you work through it. In Head First, yes there is an example, but the examinations happen via stories, diagrams, pictures, games and really good (bad) humor. What this means is that no matter how you learn, you'll find something that helps the concepts stick. Each chapter builds upon the last and each chapter reinforces lessons from before. You can tell that people who really know how to teach designed these books.

Now this book is basic. I personally didn't mind reading about Objects and Object-Oriented design yet again. I also didn't mind reading about polymorphism, encapsulation, et al. The main reason for this is the presentation. Well that and there are a few subtle differences between C++ and Java that they talk about that I need to know. But mostly its the fun way they present the topics. I mean even if you know these topics cold, I still found some of their examples and comparisons well thought out and memorable. So much so in fact that I can see using them to help explain concepts to people I'll mentor or to marketing folks.

If, however, you have programmed in Java before and are comfortable in the world of OO, and are looking for something to take you to the next step, I'd suggest you keep moving onto other books (Effective Java by Bloch is amazing). However, if you are new to Java, and even new to programming, you'll love the Head First books. The writing is clear and engaging (and correct!), the examples make sense, and way they tailor lessons to trigger different parts of your learning brain is really well done.

When you first glance through this book you will notice all of the retro pictures and half jokes. I've never read a Dummys/Idiots book on programming, but I can imagine them having the same look and feel. But then when you dig into the actual content...

This book, to me, felt like a good class on Java programming from a great professor who has real world experience - the tone is conversational and the topics selected that make the most real world sense. There are a few large "class projects" that have a very real world feel to them (a networked beatbox anyone?). Important points are pounded home. It is the class but without the text book...

The topics covered also seemed to have a "real person" feel as opposed to a textbook feel. I read another popular Java book just before this one. It threw 2 chapters on GUI basics as almost an afterthought, there was no networking, nothing about inner classes, nothing about making distribution packages, etc. In that book the basic ideas were gone over in great depth, greater than here, but these more practical topics were skipped or had the briefest mentioned.

With this book you start using Swing just a little more than half way through the book. All the topics in the last paragraph (plus many others) were covered in a practical method.

This book, however, isn't perfect. As mentioned above, this book is like a good class on Java programming without the textbook. Sometimes the textbook is needed. When I was in school I always read the textbook no matter how good the prof - it was needed to get the full benefit of the info. I also like having good reference books that I can leaf through when I have an issue. This book is a mediocre, at best, reference book and admits it.

It also often gets too cute. OK, sometimes that is needed, but it can get a little... As another reviewer mentioned, this books often seems to be aimed at collage age kids, not professional programmers. Not necessarily a bad thing - I've been out of my 20s longer than I care to admit and I never felt I was too old to be reading it.

I would recommend this book if you are just starting off in Java or are rusty and want to pick it back up. I would also recommend getting a more conventional book as foil and as a reference.

I have read this book in less than a week, and it is easily readable, and easy to understand (however, you have to read it from page 1 to the end, because it is organized like that so that you cannot skip pages). I knew some OOP before I bought it, and i have done some Java from before, so i didn't find anything hard to understand. This book has helped me a lot to fill the gaps i had in OOP and Java, since everything is well explained and visualized with images and drawings.

However, i think that this book is not for the total beginner, you have to have some experience in Java (or some other language), know at least how OOP works (this book will greatly improve how you think in OOP, and explain with example, but i think it is not beginner level, or you might need to take a longer time reading this book till you understand what is inside).

I also found that they spend a lot pages on really unnecessary things (like puzzles with fill in the gaps, and the crosswords, that i found really useless). Also there were some pages where some very simple things were being explained on 1-2 pages, things that can go in one sentence. Also useless were the bullets, where they (shortly) repeat what we read 2-3 pages ago. However, i liked a lot the Dumb questions (similar as FAQ's on sites)where they cover up almost every "dumb" question you might have though regards what you learned, and also liked the Brain Barbell.

So to sum it up:

Pros:

-Easy and fast to read and understand

-Well explained OOP

-Great for people with "some" experience for filling gaps

Cons:

-Many pages spent for non-useful things

-I expected more in-depth Java, but this book is just the basics

-You have to read it from page 1 without skipping

I know only one programming language well, Actionscript. I wanted to know Java, too, to make servlets (and also because Macromedia's many tools seem to be increasingly Java-related).

I was skeptical when I flipped through this book because of its goofy diagrams, but I bought it because of its price and the many glowing testimonials in the first pages.

I'm glad I did.

The first half covers syntax, datatypes and objects. This could have been tedious, because 80% of the material covers things any programmer would already know. But the structure and the style made it pleasant enough--and interesting enough to stay awake for that other, Java-specific %20.

Then, right at the midpoint (Serious Polymorphism), the book started to really engross me.

I had read a more technical book on OOP in Actionscript (Actionscript 2.0 by Colin Moock), and put that knowledge to good use, but I was almost embarrassed to realize that the goofy examples and diagrams were deepening my understanding of the way type-safety, polymorphism, interfaces, constructors and exception bubbling actually worked.

I also became increasingly jealous as the second half laid out Java's data structures (sets, enums), inner classes, interface-driven event structure, and native networking capability. I want that.

My interest piqued, in the second half I started actually doing the exercises, too. Many of them are just variants on debugging..and what better way to learn a language than debug it? It helps the material stick.

It's remarkable how much of the book consists of WRONG turns. That is, it takes a problem-solving approach, and investigates the wrong turns almost as much as the right ones. This makes learning-by-reading much more like learning-by-doing, which also makes the material stick.

There are a few cons: some of the exercises are grating or useless (to my taste); the proofreading isn't that great; the chapter on generics was confusing...but overall, this is probably the best programming book I've read.

This was my first Head First book that I had bought (around Nov '09), and I have bought 5 more since (to date, May '10).

After reading this Head First Java book, I was able to teach myself java within approximately a month.

I won't comment on the specific techniques and methods the Head First series implements, but I will tell you what these books do for me:

..

I am a VERY visual and global thinker (The kind that draws things when he/she's trying to explain something, and thinks of objects/maps instead of words and sounds). As such, I like to know what there is to learn about a subject before I dive in, and I don't like to sweat details until they're relevant. And that is EXACTLY what these books do; they construct a mental map of what there is to learn about a subject from the get go. As this mental map develops (simply by frickin' skimming these books, it's amazing!), you're better able to evaluate the context of things, and better apply and build upon ideas and concepts.

Now, these books are not per se good reference manuals, but that doesn't matter to me for two reasons. 1) The mental maps they paint are alone worth much much more than the price of the book (even if you don't download it illegally). 2) The 'interwebs' is a GREAT reference for programming - specifically for Java, VB, Javascript, C++, HTML, XML, etc.

I spend my free time teaching myself programming because I enjoy it so much now! .. hopefully that's not a bad thing

So, this can't be your first book on programming, the authors actually tell you this in the first few pages of the book, you need to at least have a background in any programming language even if you don't practice it. (PHP, Fortran 77, Pascal, Delphi, ASP, C#, Basic, etc...) Anything, but not HTML or CSS because those are not programming languages (seriously, they won't help you at all)

With that said, it is the best programming book that i have ever read, i am a C++ programmer with many years of programming under my belt, (although many of my programs would probably compile with a C compiler since i don't often use OO programming for my smaller projects)

The book is made in such a way that you don't need to memorize stuff, the book chats you into memorizing them effortlessly

although JAVA uses C syntax, this means absolutely nothing, under the hood JAVA seems to be very different, that person that told me that java is like C++, ++ed knows nothing about Java, this book indirectly tells you how java actually deals with things so that in case you did C++, you will not accidentally assume JAVA is the same.

And this is where this book kicks in, this book, through its super genius silly,, made my experience in learning java FAST, easy, and enjoyable.

I'm a programming/Java beginner, using Head First Java to start out my newly selected career in programming. I've taken some basic programming classes in high school and college, but still a relative newbie.

There are TONS of great reviews for Head First Java. And with good reason. It's easy to digest, sometimes overly so, beating simple concepts into readers' heads over and over again. Instead of reading something that looks like this:

fasle;jfe jefrjf wejeiofja esfoewfje efjiofef eif efjaweoa asefjeo awejfe ej

for pages and pages and pages on end, the book utilizes pictures, arrows, sidebar comments, subheadings, the whole shabang, resulting in a much easier read than:

fasle;jfe jefrjf wejeiofja esfoewfje efjiofef eif.

What I don't understand is that anyone who is trying to wrap ther brains around new concepts, especially in programming, knows that learning requires EXERCISE. The only remotely close thing to actual programming practices are fill-in-the-blanks, match code to output, pool puzzles, etc. While this may be nice mental exercise, it IS NOT real programming, and the concepts it introduces chapter-by-chapter are far too easily forgotten by the next one.

I've done it myself. It's a nice read, but if you're serious about learning Java from the beginning of your programming career, GET A BOOK THAT ACTUALLY REQUIRES YOU TO PROGRAM.

Livre trés intéressant qui revient sur les bases du langage Java. Il correspond à tous les profils débutants ou experts. Je le conseille vivement.

Primero que hay que decir que es un libro que explica Java de forma muy clara y concisa, evitando todo momento las lecciones clásicas.

Segundo, es que está escrito en un inglés bastante básico y asequible, no hay que tener un gran nivel para poder seguirlo.

Tercero, aunque no está adaptado a la última versión de Java, para empezar desde cero es muy buen libro.

Resumiendo, es un libro que hay que tener si uno quiere empezar a programar en Java, ya que con algo de esfuerzo se avanza con facilidad, adquiriendo los conocimientos. Después de acabar el libro, habría que comprar o buscar documentación para ver que novedades trae respecto a la versión java 5 ( ya vamos por la versión 8).

Muito bem escrito, este livro aborda o conteúdo de forma direta e simples. Possui muitos exemplos de códigos que facilitam o entendimento, definitivamente é o livro para quem está querendo iniciar os estudos em Java.

My experience with this book has been extremely positive. Even though I bought this book because it was the recommended text for the class I'm taking, I can see this being useful for anyone.

It is extremely easy to understand even for people without any previous programming knowledge. It uses pictures, cartoons and excises to teach. The pacing is great (i.e. it doesn't get really difficult really fast like some books) and I recommend it to anyone looking to learn java. This 50$ book is better at teaching you java than a 750$ university course.

Shipping was fast, I got it in 2 or so days with super saver shipping.

Ben fatto, pratico e di facile comprensione. Peccato solo che è un libro di ben 688 pagine, quindi non comodo da portare con sé