Professional Java Programming

This is a great reference book that covers both simple and more advanced topics in Java. I bought this to help me prepare to teach a Java programming class, and now plan to recommend it to all my students. The writing is clear and to-the-point, unlike some other titles that tend to be a bit on the wordy side. Code samples are sprinkled liberally throughout most of the chapters, and like the writing, they are simple, easy to understand, and effective.In addition to a chapter on JDBC, this book includes a chapter that describes the various persistence options available to Java programmers, and nicely frames JDBC's role as one such option. That chapter also describes the InputStream, OutputStream, Reader, and Writer classes in the java.io package, along with an in-depth discussion of serialization. Another favorite of mine was the chapter on creating custom GUI components, a topic that I've not seen covered in many other places.My only complaint is that this book doesn't come with a CD-ROM, but the code listings in the book are at least downloadable from the publisher's web site.

Many titles focus on a single title, and they often seem to be packed full of material that's marginally useful at best and irrelevant at works. In contrast, this one tackles a large number of topics that many Java programmers will need to know about, and for the most part, it manages to cover those topics in more than enough depth to allow the reader to really understand and use the Java technologies that it covers. However, it doesn't just examine those technologies from an academic perspective, but includes lots of clear examples and code that could be very useful. In some cases, the code is appropriate for use directly within an application, while in other cases, utility programs are included that help the reader to understand or use the technology better. The best example of this latter case that comes to mind is in the chapter on layout managers, where the author provides a really useful utility program that makes it easy to play with GridBagLayout and see how modifying the various constraints affects the components within the layout. In that same chapter, he also describes how to create a custom layout manager (it turned out to be easier than I expected) and provides an example of one that's actually pretty useful, at least in the scenario described.   The areas where I felt this book was weak were in the chapters on object-oriented design and distributed objects. While those chapters were ok and easy to understand, they don't provide a great deal of depth, and if you want to know more on those subjects, you should probably look elsewhere, although this book might be a good starting point for a beginner. Overall, though, the chapters provided plenty of depth, and I consider this a really outstanding book. It took me a while to finish it, but it was definitely worth the effort, and I'd recommend it to anyone who has advanced beyond the most basic levels of Java programming.

I think I have a good understanding of basics of Java, but I almost didn't buy this title because I'm still pretty new to the language. But I got it because I needed to do printing and with Java 1.3 and was very pleasantly surprised with this book. It is very well written with lots of clear example code and with minimal 'jargon'. I haven't read the whole thing yet but I really found the printing chapter clear and easy to understand and I was able to use some of the code unmodified inside my application and some other with very little change. I also have been able to have some questions answered about JTABLE that I had before by flipping to the section in the table chapter of this book. So far its been a really good reference book for me and has chapters on a lot of other things that I will need to know about. Alot of times I'm disappointed with the quality of writing in the programming books I buy but this author is really good at making things simple and clear. Another thing I like about this book is that it covers both client and server topics (but no jsp or servlet info - just stuff like threading and distributed programming etc.) so it isnt limited to just one area of Java.

I really like the premise of this book. Too many of those on the market these days focus on a single topic and are padded with useless, irrelevant material to make them large enough to justify paying $40-$60 for, but this one takes a very different approach. It contains chapters on various different Java-related topics that don't warrant entire books, but that are complex enough to be given an entire chapter. My favorite chapters are the ones on printing, JTree, JTable, and internationalization and security. I was already familiar with the first three topics to some extent, but this book really increased the depth of my knowledge in those areas. The Java 2 security model was something of a mystery to me, but this book does an outstanding job of providing a simple but thorough explanation of it, how it works, and how to use it.As a previous reviewer noted, not all of the chapters are in-depth, such as the one on distributed programming. That's another area where I was already pretty knowledgeable, but for someone who's only marginally familiar with topics such as socket programming, CORBA, or RMI, this would be a great introduction.I was also impressed with the chapter on persistence, as it did a good job of summarizing the classes and interfaces in the java.io package and of examining the different persistence options available to a Java program. Some chapters provide an in-depth examination of the topics, others provide good reference material, and a few (like the persistence chapter) offer both.I would disagree with a previous reviewer who said that this wouldn't be a good book to read from cover to cover, because I learned new things even when reading the chapters that were devoted to topics I already felt pretty knowledgeable about.Some of the topics covered here haven't been written about anywhere else that I know of, but all of them are well-written and informative.

As its generic title implies, this book doesn't really focus on a single Java topic. Instead, it covers many different topics, most of which area relatively advanced, and does a decent job with almost all of them. Some of the chapters were on topics that are pretty basic, such as event handling and layout managers, but even in those areas I found lots of useful tips and tricks.My one complaint is that some of the examples were a bit contrived. On the other hand, the code samples were extremely clear and easy to understand, and I suppose that there's a tradeoff there between realism and simplicity. That's why I'm still giving this book five stars -- because even if the examples weren't "realistic", they were at least effective.Since the topics are largely unrelated to one another (with the obvious exception that they're all relevant to Java programmers), this isn't a book that I'd recommend someone read from cover-to-cover. However, I do consider it a very good reference for most of the subjects that it covers, and a good starting point for the remainder.