Customer Reviews

Learning Java

5 star:		(27)
4 star:		(18)
3 star:		(13)
2 star:		(5)
1 star:		(8)

 

 

I had purchased "Learning Java" out of the conviction that some patience and thought was all that was needed to make sense of the book. "Learning Perl" (also published by O'Reilly) had a somewhat steep but manageable learning curve-I thought "Learning Java" would be more of the same. Unfortunately, I found "Learning Java" to be a disappointment. The book begins by creating a simple "Hello, Java!" pop-up box along with brief explanations of the basic concepts of Java (class, methods, etc). The book, however, then gives an overview of syntax and tools with no practice exercises. The book essentially went like this: "This is what a class is. This is what a method is. This is what an exception is." And so on. The book spends a few paragraphs describing many important concepts of Java without adequate examples and no practice exercises. The author's organization and presentation of the materials made the book more of a dictionary than a tutorial.

Don't get me wrong, the book does provide an excellent overview of Java's history and heritage. It also serves as a handy (but incomplete) reference, although "Java in a Nutshell" is a much more complete reference. However, like some reviewers, I believe that the title was a bit misleading for those wanting to actually learn to program in Java. This book is not for someone new to programming. "Learning Java" is actually more like an overview or tour of Java that introduces the program's features and tools. It is not a tutorial.

My recommendation: See if you can get a hold of "Learning Java" and take a look at a few chapters. If you like the author's approach (and several reviewers did), then by all means purchase the book. I was originally going to recommend that only those with C or C++ programming experience give the book a try, but I've noticed several reviewers with such experience giving the book a poor review. If you are looking for a tutorial, try the deceptively named but excellent "Teach Yourself Java in 21 Days" by Laura Lemay.

Learning Java by O'Reilly is an excellent book for someone who already knows the basics of programming(i.e - knows about syntax, decision statements, and a cursory understanding of objects). However, as a teaching tool in a classroom this book does not cover in depth the basic ins and outs of a language that would really hit home the concepts necessary to a learn how to program or to use java for a beginner.

Now from a professionals point of view or an college students point of view(I am both being an Engineer at RIT which has a coop program which is rotating work and school in your chosen field every quarter after your second year) this book gives a good explantion of the advanced topics such as Applets, Remote Method Invocation, sending seroalized objects, web programming, threads and a couple of others. So if you are looking to expand your programming base with a completely portable language this is the book for you or if you just want to get the background of the power house tools of Java this book is also for you!

I have experience in C but not C++. Prior to this I tried to read Eckel's thinking in java which I found to be overly pedantic and at times, irritating (with many exercises trying to display arcane syntactic or semantic points). In comparison this book is very refreshing and I feel I am learning new stuff really easily.

This book is dense but motivates using simple code. Explanations may not be complete (esp in Chap 2) but really this is a good compromise.

This is definitely for someone with a background in programming (preferably in C or C++). Ideally one should have a programmers editor on and keep trying the code snippets as one reads (which is why the online version at safari.orielly.com is handy). So, in a sense, this book is not for the uninititated. But for those who have some exposure this is well worth the money and effort.

The author also has a useful open source tool (BeanShell) which suggests some depth.

Some Tips for readers new to java on windows:

1. Download and install jdk 1.4.x
2. Get a simple programmers editor (editplus.com for example)
3. Get Jikes compiler as a replacement for javac (copy it to the jdk bin directory) as its really fast and use it to compile within the editor.
4. Make sure your classpath and path variables are set properly. The former could include the jdk jre/lib/rt.jar and . the current directory; the latter could include the jdk bin dir. in XP these can be set using the controlpanel advanced setting for environment variables

Once you can experiment with the code as you read, it becomes more interesting.

I would say the book deserves at least 4 stars; I am giving it a 5 to offset some really low ratings :-)

Programmers who have learned such languages such as C++ will find that learning Java is easy, and somewhat painless since both use Object Oriented Programming. But what about those who do not have such experience?

For those who have experience in O.O.Programming, this book will suit you just fine. However, for the rest of us, this book will be difficult to get through, let alone understand. You can read the book, understand the syntax, but unless you understand O.O.Programming, you will not be able to make effective use of this book.

My other complaint for this book was the lack of problems for novices to try. Many other O'Reilly books on programming will put problems at the end of every chapter (e.g. Learning Perl, Practical C Programming, etc.) but not this one. I think that would help any new Java programmer immensely.

One last complaint for this book was the first couple chapters. The authors tried to give you some code to try out (obviously to get new Java programmers excited about Java), but did so before even presenting Java concepts, so a reader will find himself frustrated from the start.

I had to give this book 3 stars because the content overall was good, but was definitely assuming too much from the reader. For people with C++ background, you will definitely enjoy this book, but if not, you will find yourself most frustrated.

Approaching this book as a C/C++ programmer with essentially no knowledge of Java, I was not disappointed. "Learning Java" provides a broad overview of the many facets of Java, and it makes sure to point to other resources when the coverage is superficial. While many topics *are* only covered superficially, the sheer size of the Java APIs makes this necessary; at 826 pages, the book is certainly not a piece of fluff.
Contrary to many reviewers' opinions, I appreciated the conceptual overview that preceded the more concrete chapters; I find that addressing the 'why' first makes the 'how' more intuitive. If you disagree, just skip to Chapter 4 to get started with language constructs!
This book does not always spoonfeed the material; some of the examples require analysis to 'get'; however, I found the accompanying explanations to be sufficient, and I learn more when I have to pay attention. There are plenty of other reference books out there that provide more fluff...
My biggest complaint about "Learning Java" is the lack of attention paid to the examples. Several of them had small, silly errors that prevented them from working as written. For instance, one of the intro examples had a method call that didn't match the signature. In a later chapter, a variable was referenced by an incorrect name. In each case, I was able to fix the problem without difficulty, but it illustrates the lack of attention to detail. When one of the first examples in the book won't compile as written, you are bound to frustrate some readers.
Also, formatting in the examples could be challenging. The coding style tends to be compact and perhaps confusing when learning the language. A few times, indentation was just plain wrong, making transcription and understanding difficult.

Despite the weaknesses, I remain fond of this book. After reading it, I feel that I know Java well enough to dive into more complex topics on my own. A review by a careful and knowledgeable editor would probably win over some naysayers.

This book came as a surprise. O'Reilly is generally great in the "learning" space (Learning C# and Practical C Programming are great), but Learning Java misses the mark by comparison. Learning Java is definitely not a new-to-Java text.

This is not my first Java book, so I expected the first chapter to contain the ordinary byte code/virtual machine/OO discussion that is de rigeur. However, this text takes the opportunity to launch into a discussion of the class loader; Java's similarity to Smalltalk in that they are both statically typed, late-bound languages; threads; dynamic memory allocation et al. And yes, that's the *first* chapter.

The complexity continues: the second chapter's "intro" program (the also de rigeur K&R "Hello World") begins with a simple system.out.println and --- over the course of 20 pages --- adds a complete UI, two synchronized threads, a try-catch exception handling block and multiple classes. All this with minimal (a sentence or two) explanations of what's going on. At this point, I put the book down.

It is apparent that the authors know the material and are excited about it. However, this is certainly no introductory highway to Learn Java. The subtitle to the book, "Help for New Java Developers" should have the following appended: "Who have years of C++ experience, have read another Java book and want the dense technical nitty-gritty."

This book addresses a pragmatic issue. The fact is that no one single textbook or reference can hope to cover all of the details and issues surrounding the enormous Java language. Bookstore shelves are replete with books, including many excellent ones, covering transitions from C/C++ to Java, or developing a major comprehensive project, or focusing upon a specific facet of the language, such as threading, or networking. The Internet can play a major role in this as well. The Sun Java and IBM Developer Domain sites, for example, contain a wealth of information and tutorials. Even personal (home) websites can be found, describing the syntax and basics of Java, so popular a language it is.

A different approach is taken here. An intrepid beginner needs more than syntax, and already contains so much bubbling enthusiasm that personal projects will spring from imagination on their own. Two major questions are addressed in detail (albeit obliquely) in this book:

1. Why was the Java language created, when earlier languages purportedly address the same issues?

2. How have the designers formed the infrastructure of that particular aspect of Java, and how does an individual developer implement and expand upon it (at the lowest levels)?

This is the function which this book serves, in an ocean of already-existing manuals, tutorials, and references.

With this function now clearly defined, the form follows systematically. Some full program examples are provided, when necessary. However, frequently only a program fragment is all that is required, and in fact is ideal, because it removes extraneous distracting details from the flow of the chapter section. After all, even in the excellent O'Reilly "Java Examples In A Nutshell" book, do you not spend much of the time before and after writing the program, hunting around for 'the main key' that makes the program really work?

Excellent graphs and class diagrams are provided, reminiscient of O'Reilly's "Java Foundation Classes In A Nutshell", along with developmental history and clear exposition on why that structuring was chosen above all others. Recreate the packages, classes, and relations yourself, independently, with pen and paper, and the utility of this book will quickly be realized: it serves as a bridge, between introductory works, and exhaustive focused references.

This book may spend a month or three on your bookshelf after you first buy it. You may even question why you did get it to begin with. Its value will come to you when reflection is needed (self-reflection, that is, not just the Java kind).

So, visit numerous websites...Download the .PDF files, and browse the .HTML references. Also, get books that this book supports, and not the other way around. This can include O'Reilly's "Java Examples In A Nutshell", and Wiley And Sons' "Effective VisualAge For Java Version 3". And whenever you need to slow down, and figure out how and why the inheritance and implementation was done the way it was, and which parts of a detailed program really make the gears mesh, dip into this book, write notes furiously, then put it back on the shelf until later, when you need it for succinct clarification once again.

The title of this book is highly inappropriate. This is not a book for someone who has not used Java before. If you have never used or seen Java before OR are not a very very comfortable C++ programmer(actually even that won't really help) this book is NOT for you. Explanations are very brief, concepts are not covered in depth and the examples concentrate on showing short cuts and 'tricks of the trade'. What good does that do when you don't know anything about JAVA? The author should have concentrated on teaching the basics of the language and explained things such as threading etc. much more thoroughly. An absolutely USELESS book.

I bought this book a few weeks back and have read about half of it. I have about 5 yrs of C++ behind me, and I wanted to learn Java. This book really did it for me. I must agree with some other reviewers that this is not a book to learn Java as a first programming language, because it doesn't spend a lot of time on syntax and stuff. But it covers the language extremely well and give many tips and warns against some pitfalls.

The book give an overview of all the base classes, so it's good to read it BEFORE you start coding. That way you will know all the Java classes and be able to pick the the best design right of the bat.

There is also a good section on programming Java using the SDK directly as opposed to some IDE. Personally I think it's very important to understand how things are done under the hood.

So a great book for learning Java, but some programming knowledge (preferably OO) is required to get the most of this book. If you liked other O'Reilly books, you'll like this one.

One expects a certain amount of intellectual gravity and reliability with the O'Reilly "animal series" books on technical subjects. I bought the book based solely on the fact that I needed an intro book on Java, and have never been disappointed with an O'Reilly book. Well, now I have been disappointed.

The book starts very well. The first two chapters take you through an engaging tutorial -- taking one idea in Java at a time, and slowly building up. However, after those first two chapters, the tutorial goes away and the book gets very dry. The organization of the content is not well thought-out for a beginner's book. Just for a couple of fairly trivial examples, the authors spend a few pages on the "assert" keyword before they explain arrays (a very fundamental concept). As a comparison, "Head First Java" (highly recommended, by the way) doesn't mention "assert" until an appendix, and only as one of the "Top Ten Things That Didn't Make it into The Book" list. Also, there is a wasted page on optimization and performance in chapter 6, which is about Subclassing and Inheritance. It would have been better for them to focus on getting code running, and doing what it's supposed to do, and leave optimization for an Appendix.

Good points of the book include a lot of detailed explanation on some of the Java API, including Swing and JavaBeans, as well as explanations on how to use the two most popular IDEs: NetBeans and Eclipse. RMI and the natural relationship between Java and the web are covered well. And the 3rd edition of the book has been expanded to cover topics new in Java 5.

The accompanying CD contains Eclipse, Tomcat, NetBeans, Ant, and other utilities -- all of which (except for scripting language written by one of the authors) are readily available from the web. So the CD doesn't really contain anything that you couldn't get by trolling the web for a half-hour and doing a few hundred MB of downloads. (Plus, getting the tools from the web ensures that you get the most up-to-date versions...)

So, this book is another reference work, another way to explain Java, but it's nowhere near the best.