Java Computer Book Reviews

Now integrating Java 5 throughout, this reference introduces Java programming fundamentals – including problem-solving, object-oriented programming, GUI programming, data structures, networking, internationalization, advanced GUI programming, and Web programming. Includes many new illustrations. Enhances examples throughout, using small, simple, and stimulating examples to demonstrate concepts and techniques. Offers anearlier introduction to writing programs than the previous edition. Features a new chapter on recursion, expanding treatment from earlier editions. A useful reference for anyone interested in learning more about programming.

As a veteran developer at Sun, the author shares his considerable insight into the design choices made over the years in Sun's own Java libraries (which the author acknowledges haven't always been perfect). Based on his experience working with Sun's best minds, the author provides a compilation of 57 tips for better Java code organized by category. Many of these ideas will let you write more robust classes that better cooperate with built-in Java APIs. Many of the tips make use of software patterns and demonstrate an up-to-the-minute sense of what works best in today's design. Each tip is clearly introduced and explained with code snippets used to demonstrate each programming principle.

Early sections on creating and destroying objects show you ways to make better use of resources, including how to avoid duplicate objects. Next comes an absolutely indispensable guide to implementing "required" methods for custom classes. This material will help you write new classes that cooperate with old ones (with advice on implementing essential requirements like the equals() and hashCode() methods).

The author has a lot to say about class design, whether using inheritance or composition. Tips on designing methods show you how to create understandable, maintainable, and robust classes that can be easily reused by others on your team. Sections on mapping C code (like structures, unions, and enumerated types) onto Java will help C programmers bring their existing skills to Sun's new language. Later sections delve into some general programming tips, like using exceptions effectively. The book closes with advice on using threads and synchronization techniques, plus some worthwhile advice on object serialization.

Whatever your level of Java knowledge, this title can make you a more effective programmer. Wisely written, yet never pompous or doctrinaire, the author has succeeded in packaging some really valuable nuggets of advice into a concise and very accessible guidebook that arguably deserves a place on most any developer's bookshelf. --Richard Dragan

Topics covered: Best practices and tips for Java Creating and destroying objects (static factory methods, singletons, avoiding duplicate objects and finalizers) Required methods for custom classes (overriding equals(), hashCode(), toString(), clone(), and compareTo() properly) Hints for class and interface design (minimizing class and member accessibility, immutability, composition versus inheritance, interfaces versus abstract classes, preventing subclassing, static versus nonstatic classes) C constructs in Java (structures, unions, enumerated types, and function pointers in Java) Tips for designing methods (parameter validation, defensive copies, method signatures, method overloading, zero-length arrays, hints for Javadoc comments) General programming advice (local variable scope, using Java API libraries, avoiding float and double for exact comparisons, when to avoid strings, string concatenation, interfaces and reflection, avoid native methods, optimizing hints, naming conventions) Programming with exceptions (checked versus run-time exceptions, standard exceptions, documenting exceptions, failure-capture information, failure atomicity) Threading and multitasking (synchronization and scheduling hints, thread safety, avoiding thread groups) Serialization (when to implement Serializable, the readObject(), and readResolve() methods)
Customer Review: Still Effective
With so many reviews on this book, I will put it short. Java language has been evloved and adopted significantly since its debut in 1995, a lot of features have been added to enrich and enhance it. But the advices in this book are still and will be held solid. Some of these advices are design principles not specific to Java but shown how to Java to realize, others are the core fundation of the language itself. Also the book lists some anti-pattern/principle codes made by author himself or other developers to alarm the reader to avoid such pitfalls.
Customer Review: Any serious Java programmer should have this book
First, the disclaimer -- I know Josh, and to know him is to like him. I work at Sun, and used to call him from time to time for advice. Josh is the force behind the initial versions of the Java Collections API, a good example of how to design using interfaces. I was really struck by this book when I read it -- it was exactly what I was looking for. Other books will teach you how to use Java; this one assumes you know that much and then teaches you how to use Java *well*. It's a bit like knowing how to draw cartoon-like figures and then learning to draw lifelike images. I also find his writing style very natural; believe it or not this was, for me, a page-turner. The book is slightly dated since it does not reflect the many significant Tiger (5.0) features. In fact, I think Josh himself obsoleted some of his own advice by giving us a really good enum implementation. Still, most of the content is very relevant, and even the dated stuff is still important if for some reason you are stuck using 4.x. It also helps you understand why enums were done the way they were. [...] He hinted that he might make an updated version of the book; if so, I'm in for one -- this is *bar-none* my favorite Java book. In fact, I should ask whether people have read "Effective Java" when conducting interviews, and then ask them to articulate some of what Josh said. Hmmm.

In a conversational style, best-selling author Walter Savitch teaches programmers problem solving and programming techniques with Java. Introduces object-oriented programming and important computer science concepts such as testing and debugging techniques, program style, inheritance, and exception handling. Includes thorough coverage of the Swing libraries and event-driven programming. Provides a concise, accessible introduction to Java that covers key language features. Covers objects thoroughly and early, with an emphasis on applications over applets. A useful reference for programmers who want to brush up on their Java skills.

* Memory model * Cancellation * Portable parallel programming * Utility classes for concurrency control

The Java platform provides a broad and powerful set of APIs, tools, and technologies. One of its most powerful capabilities is the built-in support for threads. This makes concurrent programming an attractive yet challenging option for programmers using the Java programming language.

This book shows readers how to use the Java platform's threading model more precisely by helping them to understand the patterns and tradeoffs associated with concurrent programming.

You will learn how to initiate, control, and coordinate concurrent activities using the class java.lang.Thread, the keywords synchronized and volatile, and the methods wait, notify, and notifyAll. In addition, you will find detailed coverage of all aspects of concurrent programming, including such topics as confinement and synchronization, deadlocks and conflicts, state-dependent action control, asynchronous message passing and control flow, coordinated interaction, and structuring web-based and computational services.

The book targets intermediate to advanced programmers interested in mastering the complexities of concurrent programming. Taking a design pattern approach, the book offers standard design techniques for creating and implementing components that solve common concurrent programming challenges. The numerous code examples throughout help clarify the subtleties of the concurrent programming concepts discussed.
Customer Review: 5 for knowledge; 0 for the writing -> 2.5 -> 2
Sure he knows his stuff but doesn't have a clue on how to write. This is appallingly poorly written. It is one of the most ridiculously disorganized collections of academic 'verbage' (verbiage subsumes garbage) I have ever read. It's almost useless as a reference: its very non-linear (say non-deterministic almost) in concept elucidation (perhaps he's taken the notion of multithreading too much to heart and tried multi-threaded writing???). It's useless as a book to learn from- since learning by example is not just a way to learn, but the only way to learn (Einstein) and this book largely disavows examples. What it needs is another edition with a ghost writer. Seriously it's not good. Try Paul Hyde for a good intro to threads. While those at guru-ish level may love this book, those of us for whom threads represent a means to an end, not an end in and of themselves, would probably want to throw this book in frustration of the author's inability to structure a coherent sentence with a clear point. This meanders on like great uncle herb's war stories and is equally will sapping. Avoid if you can or check it out when you reach guru-ness. It's a good cure for insomnia though.
Customer Review: If you want to program concurency in Java you need this book
This is a kind of book you'll need to start developing concurrent systems in Java. It shows details of what should be done to safely handle patterns for concurrent programs. I beleive this book is a must for every developer who want to start learning concurrency design priciples for Java.

If you have been wanting to learn Java, check out the newly revised fourth edition of the best-seller Sams Teach Yourself Programming with Java in 24 Hours. This step-by-step tutorial will teach you how to create simple Java programs and applets. Comprised of 24 one-hour lessons, this new edition focuses on key programming concepts and essential Java basics, has been improved by dozens of reader comments, and is reorganized to better cover the latest developments in Java. The book's coverage of core Java programming topics has also been expanded. A great starting point for learning Java, this book is also a great primer to reading sams Teach Yourself Java in 21 Days.

Although vital to modern software development, Java and object-oriented programming can pose significant challenges to newcomers. This text, unique in both scope and approach and accompanied by an interactive CD-ROM , addresses that learning curve by providing a careful, classroom-tested presentation of Java -- from the fundamentals of variables, types, and expressions to procedural concepts like loops and sophisticated object-oriented ideas.

Multimedia Introduction to Programming Using Java anchors its pedagogy in the CD-ROM ProgramLive, a complete multimedia module in itself. Containing over 250 recorded lectures with synchronized animation, ProgramLive allows users to see, first-hand and in real time, processes like stepwise refinement of algorithms, development of loops, execution of method calls and associated changes to the call stack, and much more. The disk also includes all programs from the book, 35 guided instruction sets for closed lab sessions, and a 70-page hyperlinked glossary.

Additional key features of this work:

Provides clear and accessible treatment of all aspects of a first course, along with more advanced topics such as recursion, exceptions, interfaces, inner classes, and GUIs.

Introduces objects and classes early in the exposition, rendering object-oriented programming intuitive and natural.

Develops programs, rather than simply showcasing them.

Supports all concepts through complementary lectures on the CD-ROM.

Contains numerous self-help exercises that encourage readers to practice programming.

Emphasizes rigor and accuracy through user-friendly exposition and a flexible organizational style.

With its comprehensive appendices and bibliography, systematic approach, and helpful CD, this exciting work provides the key tools they needed for successful object-oriented programming. It is ideal for use at the undergraduate and graduate beginning level, whether in the classroom or for distance learning; furthermore, the text will also be a valuable self-study resource or reference volume in any programmer’s library.

This broad-ranging guide can help programmers with varying levels of expertise to understand Java more completely and to maximize their coding effectiveness. This book's rules-based format examines 68 key topics on how to improve your code, providing crisp, well-written examples and solutions. All of the examples and solutions are accompanied by thorough explanations for achieving a working solution of your own. This practical approach to programming and design describes the best practices used by experienced programmers. Intended for the intermediate to advanced Java programmer, the Practical Java(tm) Programming Language Guide is organized into individual lessons, so it can either be read from cover to cover or by individual topic.

Topics discussed include:

* Objects and equality * Exception handling * Performance * Multithreading * Classes and interfaces

If you want to spend less time debugging, optimizing, and tuning your code, this example-oriented, down-to-earth guide is full of practical techniques for exploiting the Java programming language. The 68 topics were chosen based on their relevance to effective and efficient programming practices. A special section focusing on performance provides valuable insights into Java performance issues and useful performance improvement techniques. If you want real-world, sound advice on building applications using the Java programming language, this book is essential reading.
Customer Review: A good selection of Java coding best practices
Lots of great "common sense" best practices for Java, especially on things such as Exception handling - what goes in a finally block, what should and should not go in a try block etc. Probably not on a par with Josh Bloch's now classic "Effective Java" but a good adjunct.
Customer Review: Excellent source for guidelines
This book could be a very good source if you are developing your own company or project guidelines. The discussion is structured around lessons that are called PRAXES by author. Each PRAXIS has a well-chosen title which is expressed as a one sentence guideline. The book covers general Java/OO topics and, in addition to that, has extensive sections devoted to performance and multi-threading. Most guidelines are simple enough to be understood by any Java programmer. The discussion is on intermediate level in most cases with some advanced stuff included. Many examples, especially, in a performance section are illustrated by JVM bytecode snippets. The ability to read bytecode would be a plus for a reader but unfamiliarity with it should not prevent a reader from understanding material. Overall, the book is a worthy reading for any Java developer.

J2EE represents a serious attempt by Sun to make Java not just a viable language, but more importantly a viable platform for enterprise development. This book is about how to use Java for enterprise development, using the J2EE runtime architecture.

Wide range of technologies including: J2EE, RMI, JDBC, JNDI, LDAP, XML, XSLT, Servlets, JSP, EJB, JMS, JavaMail, CORBA, Performance, Scalability, Unit Testing, and Debugging

Benefits and limits of the typical real-world vendor implementations of the J2EE specification

The resulting practical aspects of real-word design using the J2EE technologies
Customer Review: This is an into book
This is a "intro" book from several authors. If you don't know the j2ee technology at all or you intend to know any part of the j2ee then this is a good start point. But if you liked to dig into a specific area or to develop an j2ee application then this book is not sufficient. Moreover this j2ee book is a bit obsolate, the 1.3 edition is a better choice though the j2ee tech goes to the 1.4 edition.
Customer Review: Most complete J2EE book I've seen
This is a great book for people wanting to learn more about the many features, services, packages and nuances of Enterprise Java. I have yet to see another book that as much breadth of information on J2EE. It explains what each part is, how it works, and how it integrates with other parts. While you would have to buy some additional books if you needed more in-depth information on a particular topic, this book will help you know which questions to ask. Granted, with so many authors there isn't much continuity, and being a Wrox book there will be errors in the examples. But as a reference book, especially for newbies, this one is hard to top.

Professional Java Tools for Extreme Programming is a practical, code-intensive guide to the tools that Enterprise Java developers need when using Extreme Programming (XP) methods. It covers the key tools used to automate the most complex parts of the XP process: application integration, testing, and deployment.

What does this book cover?

The book covers major new releases of Ant, JUnit, and Cactus, plus important new tools, inlcuding XDoclet, Maven, Anthill, and Eclipse.

The book begins with a brief introduction to XP methods. It then jumps right into the tools, providing a brief overview of the uses and features of each tool. Next come tutorials showing best practices for using the tools — the authors show how each tool is used to develop and test the same sample application, based on Sun's well-known Pet Store example. For each tool, the author provides lots of code examples and directions for setting up scripts for automating that development step.

Customer Review: Don't buy this book !!
I am an experienced Java developer and new to the J2EE field. I bought this book to learn how to use the open-source tools with the XP attitude. Mostly for the XDoclet and JUnit. Well, the examples are not so bad. There are SO MANY ERRORS *in the code itself*. It happens, I know. So I entered the web site to check for more information. Nothing !! No errata and the book's forum is not active AT ALL. I downloaded the source code for the examples. Half of the book's examples is not there. The web site (and the forum) won't mention anything about it. The other half is filled with errors. This is not a professional book ! I did learn something from it. A little bit XDoclet and which tools I should learn and know. But that's all. WROX publication lost a customer. I won't buy any books they publish.
Customer Review: Don't waste your time
I bought this book hoping for a quick jumpstart to getting a simple xdoclet/struts app up and running. The example code from the "Building Struts Apps with Ant and XDoclet" is so bad, it's a disgrace. I spent more time figuring out why their code wasn't even close to working, than I would have if I had just skipped their book altogether. It couldn't work, it never worked, and it shouldn't have been published.

Using a fundamentals-first approach, Liang explores the concepts of problem-solving and object-oriented programming. Beginning programmers learn critical problem-solving techniques, then move on to grasp the key concepts of object-oriented and GUI programming using Java 5. Starts readers with essential problem-solving and programming concepts (control statements, methods, and arrays); moves on to object-oriented programming, graphical user interface (GUI), and applets; and finally introduces exception handling, binary I/O, and recursion. Enables readers to write short, interesting, graphical game programs early on (starting from Chapter 2). Offers an exceptionally broad range of carefully chosen examples; reinforces key concepts with objectives lists, introduction and chapter overviews, easy-to-follow examples, chapter summaries, review questions, programming exercises, and an interactive self-test. A useful reference for anyone interested in learning more about programming.

The Knowledge You Need
Each section add new capabilities to a short, yet representative Java program. One such program displays the rating of a movie selected by a user, along with a movie poster. Any World-Wide-Web browser can fetch and run the program, on your computer, in response to a button click.

As you see the program evolve, you learn to

design class hierarchies

impose requirements using interfaces

follow the model-view approach to interface design

access applets from network viewers

use threads to implement dynamic applets and you learn to

exploit the features of Java 1.2 to access files via resources

exploit swing classes

draw using the Graphics2D class

generate Java beans for GUI builders

and much, much more.

Winston's proven approach Based on extensive teaching experience Features easily digested segments Illustrates ideas via short, yet complete programs Answers your natural questions in a natural order Stresses principles of good-programming practice Recapitulates key points as if--then rules
Customer Review: Great JAVA book
This is an excellent book for someone who already knows how to program but knows little about JAVA. Presents information simply and concisely.
Customer Review: Shortest Way to Learn Java Basics for the Advanced Developer
If your are an old C/C++ hand or if you learned Java a long time ago and did not use it for years, this is the perfect Java introduction for you. It contains high density contents organized in lists of items. No fluff just pure knowledge. Right now this is the first book I use to look up the simple Java concepts. I do not have to wade through long texts or examples to find or not to find something. If you prefer an easier paved or more pedagogical introduction you are probably better of with the books from Cornell, Eckel, van den Linden, which I use if I do not find what I look for in the Winston book. If you know have a good working knowledge of Java be warned. The content of this book is the basic and only the basic stuff. You might be bored by this book. If you have a grasp of the basics of the Java language, you should also learn a little about how to properly use Java and pick up a book like Joshua Bloch "Effective Java".

In the fourth edition, the coverage on defining classes has been made more accessible. The material has been broken down into smaller chunks and spread over two chapters, making it more student-friendly.

Also, new to this edition is the incorporation of Java 5.0 features, including use of the Scanner Class and the Formatter Class.

The hallmark feature of the book, Sample Development Programs, are continued in this edition. These provide students with an opportunity to incrementally, step by step, walk through program design, learning the fundamentals of software engineering.

Object diagrams, using a subset of UML, also continue to be an important element of Wu's approach. The consistent, visual approach assists students in understanding concepts. Handles: • Consistent Problem solving approach at the end of each chapter, that follows: o Problem Statement o Overall Plan o Design o Code o Test • Diagrams---SHOW Problem Solving • Placement of Objects first—Aids students in Problem Solving • 5.0 update is included in this revision ***With the 5.0 Revision is the: incorporation of two new classes. 1. The Scanner Class 2. Formatter Class Pedagogy— Tools to Problem Solve Design Guidelines Helpful Reminders Take my Advice Boxes You Might Want to Know Boxes Quick Check Exercises
Customer Review: Visual Java Teaching Book
A good visual book, teaching by the UML diagrams. Suitable for beginners to intermediate level and a bit more. Nice colorful book. With the help of "Sample Developments" this book will give you some real practical experiments throughout each chapter. My suggestion for those who want to begin Java with no prior programming experience is "Java 60 Minutes a Day" which you can find it in my review list. In my view, as an intermediat programmer, is a bit difficult to understand core java with this book.
Customer Review: Good for beginner
This book is good for java beginner and it is highly recommended for anyone who wants to learn java in a fun and with more graphic. However, there is less topic covered. It is highly expect that more area coverage in later edition.

The author employs a tutorial approach that provides a detailed look into the central workings of the technology and teaches the reader how to write real programs for the Java virtual machine. He describes methods to becoming a better programmer through an advanced understanding of the Java virtual machine and Java technology. Programming for the Java Virtual Machine offers comprehensive coverage of all the major elements of the Java virtual machine-classes and objects, control instructions, debugging, class loaders, compiling the Java programming language, performance issues, security, and threads and synchronization. The book provides an introduction to the Java(TM) Virtual Machine Specification (JVMS), with a collection of topics that help programmers understand the Java virtual machine and the JVMS better. In addition, the book features implementations of Prolog and Scheme, a language that runs on top of the Java virtual machine, generating Java virtual machine code as it runs and using a Java virtual machine class loader to load the generated code into the system.

You will find detailed information on such topics as:

* The Java virtual machine verification algorithm * How Java virtual machine security works, and what it can and can't do * Using class loaders to incorporate code and dynamically generated code from the Internet, the Java(TM) Foundation Classes, database queries, and other languages * The mechanics of compiling the Java programming language for the Java virtual machine * Implementing other languages using the Java virtual machine, including Scheme, Prolog, Sather, Eiffel, and regular expressions

Numerous examples illustrate techniques and concepts, and exercises with solutions help you gain practical experience.
Customer Review: Decode the JVM Specification
Java programming language can be visualized as being composed of 2 components 1. Java Compiler - Compiles the java programs we write to byte-code in .Class format. 2. Java Virtual Machine (JVM) - Executes the byte-codes that is in .Class format. This essentially means that the JVM only cares about the byte-codes, and not about the high-level language that was used to program it. As you can see, this seperation of concerns opens up a lot of possibilities like 1. You can write a java program and compile to byte-code 2. Directly write byte-codes 3. Write code in some asssembly language and assemble it to byte-codes 4. Write code in an interesting scripting language like Ruby or Python and compile it to byte-codes. All paths lead to the same destination; JVM can run the resulting byte-codes. The possibilities are endless if you have this understanding. In fact, there are more than a 100 languages that compile to java byte codes at present. In this book, the authors intention is to get you started with the JVM features and how you can write programs that can be executed by the JVM. In the process you will learn the following... 1. What is inside the class file: An assembly language called Oolong, whose mnemonics closely resemble the class file op-codes is used to explain this concept. The author has clearly done an excellent job in decoding the JVM spec for this purpose. 2. Class loading: Loading classes into class area, statics etc are well explained in this section. 3. Byte-Code verification: A very important topic that is addressed only at a shallow level here. This is acceptable, as the intention of this book is an introduction to get you started and not as a reference for the JVM. 4. Compilling other languages to byte-code: Languages like scheme and prolog are used as examples to show how to compile other languages to byte-codes 5. Security in the JVM If you are one among those who want to learn JVM, but not patient enough to digest a spec, then this book is for you. But, if you are a determined person who wants the full details of the JVM, then you should be typing in "The Java(TM) Virtual Machine Specification (2nd Edition)" in the Amazon Search box.
Customer Review: Good Tutorial Introduction to the Java Virtual Machine
The first five chapters of this book provide an introduction to programming in "Java assembly language" using the assembler included on the CD-ROM. This introduction does a good job of explaining the JVM instructions, but could have used more exercises to help the reader learn and practice using more of the instructions. Additionally, the chapters, appendices, and index could have been better organized so that I didn't have to keep flipping through pages to find the syntax and semantics of instructions. The remainder of the book explores various areas such as verification, debugging, the class file format, security, and most importantly, compiling Java and other languages into JVM code. Mostly, this material is a tutorial introduction to information provided in the Java Virtual Machine Specification, but there is some original material in the chapters devoted to compiling Scheme and Prolog. Be aware that this book contains numerous errors; you'll want to grab the errata list from the Addison-Wesley website.