Spotlight Reviews (What's this?)
Write an online review and share your thoughts with other customers.
Lean, mean and right on the money!, January 2, 2003Reviewer:
Patrick M Thompson (Sydney, NSW Australia) - See all my reviews
This book rules!
It is lean, terse (but all the more readable for the economy of words that are directed (and funny at times) rather than self-aggrandising verbosity) but is is focused right at that which you need to know. These guys just dish it up: it's like ok, here's what you need to know, and here's how it works...and have a fully functional program to see it in practice and in context.
This is without question a highly usable and worthy book. It might be a little too fast for the complete novice, but anybody with some programming should be okay. These guys will guide you and feed you bite sized peices that are relevant and succinct.
If you like bloat and prattle...don't buy this book. You need a story book. This is for see the hill- take the hill kind of people who don't have time to wade through pages of drivel. But of course, you still have to earn it: you needs some brains!
Covers the basics and should put you in good stead for the the next onslaught: Core Java 2 - Advanced!
Good for experts, not so good for everyone else, June 24, 2003Reviewer:
A reader
If you're an experienced C++ programmer, this book might be right for you. However, this book starts too quickly for someone who doesn't have experience with this language or an equivalent language. For example, the "Welcome to Java" program in chapter 1 uses an array and a loop without explaining the details of this syntax works. If you're an experienced programmer, you can probably follow along. Otherwise, you might want to opt for another book. I think Murach's Beginning Java 2 is one of the best for people new to object-oriented programming.
One problem with Core Java is that the topics aren't presented in an effective order. Often, skills that are critical to most Java applications are presented after skills that aren't usually necessary. For example, handling exceptions (a skill that's critical to all types of Java applications) isn't covered until after chapters on graphics programming and Swing components (which aren't necessary for many types of Java applications).
Another problem is that topics aren't broken down into manageable chunks. For example, Swing components are presented in a single chapter and that chapter is a monster -- over 100 pages long. Although there's some good material in this chapter, it's hard to digest due to its sheer size.
To be fair, there are some good things about this book. The author is obviously an expert programmer, and some of the code examples are useful and illuminating. But if you don't have a lot of experience with other object-oriented languages, you might want to start with another book.