Robust Java: Exception Handling, Testing, and Debugging [Paperback]

Stephen Stelting (Author)

Book Description

Publication Date: September 12, 2004 | ISBN-10: 0131008528 | ISBN-13: 978-0131008526 | Edition: 1

This one-stop resource for exceptions and exception handling in the Javalanguage provides a comprehensive reference for Java developers. The abilityto create code that will properly deal with error conditions is crucial todeveloping effective applications in any programming language. This bookdescribes exceptions and exception handling in Java. It provides a referencethat both describes how exceptions work in Java technology, and explains howto effectively use them in applications. Incorporating helpful topics as bestpractices and discussions about how specific APIs represent error conditions,this book discusses the practice of exception handling from softwaredevelopment up to system architecture. In addition, it provides informationabout how to use exceptions during the phases of software development whichfocus on testing and debugging.

Editorial Reviews

From the Back Cover

Robust Java

Exception Handling, Testing and Debugging

Complete guide to Java platform exceptions and exception handling

Proven strategies for architects, designers, and developers

Key design patterns for exception management

Stephen Stelting

Your one-stop tutorial & reference for Java exceptions and exception handling

Sorry, you're not perfect. And neither is your code. But you can build more robust software: code that handles unexpected problems gracefully, and keeps on running. In Robust Java, Sun Java expert Stephen Stelting shows you how. Using extensive code examples, Steve covers every facet of Java exceptions and exception handling, encompassing architecture, design, development, testing, and debugging. With the help of this book, you'll:

• Discover best practices for Java exception handling
• Learn failure mode analysis: how to anticipate where errors are most likely to occur
• Understand the use of exceptions in complex APIs and frameworks including J2EE, JDBC, RMI, JMS, and more
• Master application-wide exception handling strategies
• Implement exceptions in complex distributed multi-tier systems
• Learn proven design patterns for handling exceptions in code
• Perform more effective Java testing and debugging using open source tools
• Understand key architectural decisions that will improve robustness

Robust Java covers the entire development lifecycle—and it will support you in any development role: programmer, tester, project manager, or architect. No book offers more useful, realistic guidance for building rock-solid, maintainable Java code.

U.S. $49.99

Canada $71.99

PRENTICE HALL
Professional Technical Reference
Upper Saddle River, NJ 07458
www.phptr.com

0131008528

Java programming

© Copyright Pearson Education. All rights reserved.

About the Author

About the Author

STEPHEN STELTING, an instructor for Sun's Center of Learning Excellence in Broomfield, CO, has taught a wide variety of introductory and advanced Java technologies to thousands of developers worldwide. A frequent speaker at conferences such as JavaOne, SunNetwork and the Colorado Software Summit, he is the co-author of Applied Java Patterns (Sun Microsystems Press/Prentice Hall PTR). He has well over a decade of experience in software development, consulting, and technical training.

© Copyright Pearson Education. All rights reserved.

See all Editorial Reviews

Product Details

• Paperback: 304 pages
• Publisher: Prentice Hall; 1 edition (September 12, 2004)
• Language: English
• ISBN-10: 0131008528
• ISBN-13: 978-0131008526
• Product Dimensions: 9.3 x 7.2 x 0.9 inches
• Shipping Weight: 1.7 pounds (View shipping rates and policies)
• Average Customer Review: 4.2 out of 5 stars  See all reviews (5 customer reviews)
• Amazon Best Sellers Rank: #1,736,069 in Books (See Top 100 in Books)

More About the Author

Discover books, learn about writers, read author blogs, and more.

Customer Reviews

Most Helpful Customer Reviews

15 of 17 people found the following review helpful:

2.0 out of 5 stars Maybe OK for newbies, May 16, 2005

By 

Blake Minghelli - See all my reviews
(REAL NAME)   

This review is from: Robust Java: Exception Handling, Testing, and Debugging (Paperback)

Unfortunately I am disappointed with this book. I guess I had high hopes that it was going to provide a lot of information that I didn't know and principles (backed by examples) that would help me learn some really valuable exception handling patterns.

I'm not sure who the intended audience is. The book is probably ok if you are relatively new to Java and it's exception handling features, but on the whole it did not add much to my skill set. But then there are also a couple of sections that reference concepts from Servlets/JSP and EJB, so if you are a newbie you might be confused.

In my opinion most of the book covers basic topics that you will already know or just as easily get from the API docs. For example, chapters 7-9 (130 pp.) talks about "core" Java classes, Collections, I/O, distributed APIs, and J2EE. It describes the various types of exceptions that can occur and what they mean. Unless you don't know how to read the javadocs, there is no new, useful info there.

It also seems to lack focus throughout. Too much of the book covers material outside of the scope of exceptions. For example, it discusses common software patterns and then just throws in a couple of sentences about exception handling to tie it back in. However, for the most part the exception handling techniques are not described well enough and lack thorough, concrete examples.

I wish the author would have made chapter 12, exception handling patterns, the bulk of the book. Then maybe I would feel closer to the book's claims of "Master application-wide exceptyion handling startegies" and "Learn proven design patterns for handling exceptions in code".

Maybe I was just expecting too much. After reading the books description I was expecting something like "Core J2EE Patterns" for the exception realm - something that would get me excited about applying a bunch of new patterns/techniques. But I really got a book of general information.

If you already have a solid grasp on exceptions (e.g. concepts like chaining, when to handle vs declare, custom application exceptions, multi-tier environments, etc) then I don't recommend this book.

4 of 5 people found the following review helpful:

5.0 out of 5 stars Best practice exception handling design, January 5, 2005

By 

Jack D. Herrington "engineer and author" (Silicon Valley, CA) - See all my reviews
(VINE VOICE)    (REAL NAME)   

This review is from: Robust Java: Exception Handling, Testing, and Debugging (Paperback)

Nobody wants to think about all of the things that can go wrong in an application. We all want to think about everything the application should do when everything goes right. But such is not always the case and we need to think about what happens when errors occur and exceptions are thrown.

This book starts with the basics of exception handling. Going through the do's and dont's in a very well written and informative manner. It then presents the exception handling specifics for each of the API, from the Java core, all the way through J2EE. Perhaps the most interesting part is saved for last as the author presents design patterns for exception handling.

This is an excellent work on error handling. It teaches the basics and leaves you with a good feeling that have you tools at your disposal to handle the errors. As opposed to trying to effectively disguise your head as you stick it in the sand.

3 of 4 people found the following review helpful:

5.0 out of 5 stars IT workers, do yourself a favor: read this book!, December 29, 2004

By 

M Allen (New York, NY) - See all my reviews

This review is from: Robust Java: Exception Handling, Testing, and Debugging (Paperback)

I've been using this for a couple of months now, and it's already paid for itself. I like that the author actually spelled out best practices for exception handling in the first part of the book. There are also good pointers for how to avoid common programming problems in Java.

In the second part of the book, there's a lot of good info about exceptions in the Java APIs. It's helpful that the author actually tells you reasons behind WHY code breaks and gives advice on how to deal with problems in code.