Appendix A "teaches" you how to get the JDK (java development kit) configured. It is a night mare for someone like me, a beginner. Here are the problems:

1) It wasn't mentioned in the "Running Programs in MS-DOS" that you are supposed to restart your computer after configuring the environment variables, the only place it was mentioned was for Experienced users, and I'm not one of them! Do you know how long it took me to figure that out! I had to reread Appendix A three times! And guess!

2) No where in Appendix A was it mentioned for the "inexperienced user" that you need to include a period for the class path. It was only mentioned for the "experienced user" which, I am not! I skipped over the "experienced user" instructions, because the book said, "For inexperienced MS-DOS users, the following section covers in detail how to set the PATH and CLASSPATH variables on a Windows system" --FALSE!!!!

3)The website tutorial for appendix a touches on the period issue, but not well enough. It has this ".;" which I thought was a typo because no where else was it mentioned. And the picture on the site showed the period after the semi-colon. What the heck?

Please GOD, don't let the rest of the book be this way!

The only thing I like about the book is the one day at a time approach. Any one else know of a good alternative to this book?

Likes:
A co-worker recommended the book to me and let me borrow it briefly. I found I liked the pacing in the book and the attempt by the authors to modularize each of the chapters making them correspond to days in a week. Due to other "life" distractions I found myself not necessarily able to keep up with the Java in 21 days but I still found it easier to progress through this book as opposed to other similar "[Insert language, application, software, etc., here] in X number of days" books. The examples are good and the authors get the book text to correspond well with the examples. I felt I understood the general concept of what the authors were trying to convey and I enjoyed working through the examples and exercises at my own pace. I felt that the modular chapters of the book would allow me to read through the chapters in most any sequence with the same ease as reading from beginning to end.

I found the website more convenient to use than the CD and the author seems to keep the book's online portion fairly current.

Dislikes:
The installation of Java instructions in Appendix A are aimed more at Windows and UNIX users but little or no mention is given to Mac OS X users. I would have preferred some assistance with upgrading Java on the Mac with help from the book or CD. I managed to get by however with Java 5 in Mac OS X. Some Mac users not familiar with installing/updating Java may encounter difficulty if they rely on the book and/or CD alone, particularly the CLASSPATH used in Mac OS X.

There are a couple of typos and errors that need to be fixed (i.e., for some odd reason the references in the book to signed/unsigned data-types are incorrect).

Overall:
I'm still going through the book and the things I like about the book, CD and website outweigh what I dislike about each of these items. Despite my dislikes I felt the book deserved 4 out of 5 starts (well 3.5 out of 5 but I can't give half a star).

I am a certified programmer for java 1.4, and I bought this book on the title alone to get me up to date with the upgrades to version 6. What a disappointment to find that annotations are not covered at all, and generics only partially. Furthermore the collections framework is largely ignored. I looks like a java 1.3 book with some added examples to make it look like a version 6 book, but it is NOT. So if you need a book to study for the certification exam, this book is definitely NOT the one to get.
I found it a complete waste of money.

The book does a pretty good job introducing the fundamentals of Java. It took me about 4 days to go through it. It's not very good as a reference, but then again there are the Java docs at Sun which are comprehensive.

Great book, i was migrating from DBXL (dont laugh) to Java 6 and this was the first book i read. The structure is sometimes out of whack and i found myself reading chapters out of order on 2 occasions but asside from this i found it to be an EXCELLENT way to upgrade my knowledge!

This is a good, quick introduction or review of Java. Also good as a reference.

My closest experience to Java was C++ coding some 7 years ago. Then I got a job requiring Java.
After reading this book, I had all the confidence I needed to jump in and do well.
Great examples and up to date. Highly recommended!

Well I'm not new to programming or IT, if fact I'm a self-employed IT engineer and have been for over 10 years. At school I taught myself BASIC and then moved up to Z80A machine code programming. I've also taught myself VBA and Windows scripting.

The whole point I'm making is that this book moves too fast for me, so I can hardly see how it can be a beginners guide. I've got to the end of chapter 7 and I've given up. The printed examples in 7 don't work and even the code on the supporting web site isn't correct.

The first seven chapters deal exclusively with the logic of Java. It's very heavy weather with no fun or light relief. It would have been nice to deal with some stuff like graphics or sound to liven things up but it's all just dry logic. I found the book extremely challenging to read, it really does a good job of losing the reader, it is to be frank - stone cold DEAD BORING!

Give yourself an even break - don't buy this book.

This books didactical approach is great, with lots of good examples convers pretty much everything you need to get started in the world of Java. So that once you finish the book, you can start practicing and programming without any problem.

This book really helps with learning the in and outs of Java 6. I would recommend it to anyone.

Having had incredible success from The Visual Basic edition of this same title line, I was optimistic about this book. I was quite intimidated by Java but this book has not disappointed me in terms of making me interested and making it easy to learn.

However, I am only now finished with chapter 2 and have found an overwhelming amount of errors in quantity and severity. There are errors in the definitions of primitive types, there is a total mess in one of the code samples... one sample has several lines of code completely reversed, while the comments inserted are the same for one section of code as they are for another section performing the exact inverse calculations! It is an utter mess.

I really hope these errors are cleaned up in the next edition of the book. I've already written to the author, and I'll either want a written guarantee for a free copy of the next edition, or I'm returning the book.

My fear is that as I progress, I will encounter errors that I'm not sharp enough in the language to catch, and will end up with confusion, frustration and time wasted.

So, from what I can tell so far, the book's technique seems like it will be very successful in teaching me the basics of the language, but if the quantity and severity of errors persist as I've seen thus far, I'd have to say that there's got to be a better alternative.

A person learning something brand new from a book should not have to be the one to discover and correct errors in the book. Who's teaching who?

I'm an absolute beginner when it comes to Java, though I have a little experience with programming and have worked professionally with scripting languages.

If you're in a similar position, you'll find this book a great companion to Eckel's "Thinking in Java" and / or "Head First Java" which was published by O'Reilly.

Beginning programmers with a sincere interest in Java will benefit from this book. The 21 pieces in which the book is divided are well-balanced and distribute the workload very well.

First le me say that as a professional developer with 20 years of C++ under my belt I found this book quite useful. It got me up to speed on how building Java applications differs from the same operations in C++. Unfortunately the book appears to be an introduction to java for beginners. I don't think a real beginner would find it easy to use.

First in most of the book minus signs have been omitted before negative numbers. Thus we are told that a byte has a range of 128 to 127, and a short has a range from 32,768 to 32,767. Anyone who can supply the minus signs doesn't need the information anyway. I saw some other mistakes I don't remember, and would probably found more if I hadn't skimmed many of the early chapters. Maybe the type setting program did this, but why would a company like SAMS let a book with this kind of errors get on the shelves.

If you already know how to program, and just want to transfer your skills to Java you can use this book. Most of the writing is clear, and so far all the code examples I have typed in compile and run. If you are a true beginner don't waste your money.

The "Teach Yourself Java" series of books either authored or co-authored by Laura Lemay has been a good one, dating back to 1996 when its primary concern was teaching web programmers how to design splashy looking applets. The focus has changed with the times, and this is a pretty good book for readers whose skill levels vary from those that are somewhat new to programming to those who are experienced in previous versions of Java. However, if you are in the latter group you might be somewhat bored with much of the material since the book spends a good bit of time teaching Java from the ground up. Thus, this book isn't really about Java 6. This book is actually about teaching you Java, and it just happens to incorporate Java 6 as the version it is using. It is not some kind of "Early Adopter" book for readers just seeking information on the new features of Java. The book has a learn by doing approach in which you create several programs each day that demonstrate the concepts being introduced. There should be a companion website with the source code for these programs as well as other supplementary material, but although the website is active, these features are not present at the time I am writing this. The book does a very good job of introducing each topic incrementally and starting with small pieces of code and then building on them, explaining everything each step of the way. Each chapter concludes with a summary, Q&A session, a Quiz, and exercises. The quiz includes the kinds of questions you'd expect to see on a Java programming certification test, and the answers are either immediately following the questions in the case of simple questions, or they are supposed to be at the book website in the case of more complex ones. The exercises are almost exclusively programming assignments. Once again, when it is active, solutions should be available at the book's website. The book has the following format:

In the first week, you learn about the Java language itself:
Day 1 covers the basics--what Java is, why to learn the language, and how to create software using an innovative style of development called object-oriented programming. You create your first Java application.
On Day 2, you dive into the fundamental Java building blocks--data types, variables, and expressions.
Day 3 goes into detail about how to deal with objects in Java--how to create them, use their variables, call their methods, and compare them.
On Day 4, you give Java programs cognitive skills using conditionals and work with arrays and loops.
Day 5 fully explores the creation of classes--the basic building blocks of any Java program.
On Day 6, you discover more about interfaces and packages, which are useful for grouping classes and organizing a class hierarchy.
Day 7 covers three powerful features of Java--exceptions, the ability to deal with errors; threads, the ability to run parts of a program simultaneously; and assertions, a technique for making programs more reliable.

Week 2 is dedicated to the most useful classes created by Sun for use in your own Java programs:
On Day 8, you are introduced to data structures that you can use as an alternative to strings and arrays--vectors, stacks, maps, hash tables, and bit sets--and a special for loop that makes them easier to use.
Day 9 begins a 5-day exploration of visual programming. You learn how to create a graphical user interface using Swing, an extensive set of classes for interfaces, graphics, and user interactions.
Day 10 covers more than a dozen interface components that you can use in a Java program, including buttons, text fields, sliders, scrolling text areas, and icons.
Day 11 explains how to make a user interface look good using layout managers, a set of classes that determine how components on an interface are arranged.
Day 12 concludes the coverage of Swing with event-handling classes, which enable a program to respond to mouse clicks and other user interactions.
On Day 13, you learn about drawing shapes and characters on a user interface component such as an applet window.
Day 14 demonstrates how to use Java Web Start, a technique that makes installation of a Java program as easy as clicking on a web page link, and SwingWorker, a class that improves application performance by using threads.

Week 3 moves into advanced topics:
Day 15 covers input and output using streams, a set of classes that enable file access, network access, and other sophisticated data handling.
Day 16 introduces object serialization, a way to make objects exist even when no program is running. You learn to save them to a storage medium, such as a hard disk, read them into a program, and then use them again as objects.
On Day 17, you extend your knowledge of streams to write programs that communicate with the Internet, including socket programming, buffers, channels, and URL handling.
Day 18 shows how to connect to relational databases using Java Database Connectivity (JDBC) and JDBC-ODBC. You learn how to exploit the capabilities of Derby, the open source database that's included for the first time in Java 6.
Day 19 covers how to read and write RSS documents using the XML Object Model (XOM), an open source Java class library. RSS feeds, one of the most popular XML dialects in use today, enable millions of people to follow site updates and other new web content.
Day 20 explores how to write web services clients with the language and the Apache XML-RPC class library.
Day 21 covers servlets and Java Server Pages - techniques for writing Java applications that are run by web servers.

You might want to wait on the next edition of the book. The end of chapter answers are not available on the author's website yet, and the book has a fair amount of minor mistakes in code listings.