Agile Java is a valuable tutorial and reference. It introduces the Java languagewith no assumptions about a developer's background in Java, object-orienteddevelopment, or TDD. The book will also retain significant value as acookbook that readers will turn to time and again to learn how to approachTDD with respect to various language features.Teh author stresses the importance of TDD by showing coded tests for everyJava feature taught. A programmer learning with this book will understand howto translate oral requirements into tests, and tests into working code. Readersalso learn how TDD impacts the design of the system, and vice versa. In short,anyone who wants to understand what it takes to build a professional, robustsoftware system using Java will want this book. Agile Java will be ideally timedto coincide with Sun's forthcoming release of Java 5 (J2SE 1.5).

Table of Contents:
About the Author. Foreword. Acknowledgments. Introduction.     Who Is This Book For?     What This Book Is Not     How to Use This Book     Exercises     Conventions Used in This Book An Agile Overview.     What Is “Agile?”     What Is Java?     Why OO?     What Is an Object?     What Are Classes?     Why UML?     What Is Inheritance?     Why Test-Driven Development? Setting Up.     Software You’ll Need     Does It Work?     Compiling Hello World     Executing Hello World     Still Stuck? Lesson 1: Getting Started.     Testing     Design     A Simple Test     JUnit     Adding a Test     Creating a Student     Creating the Student Class     Constructors     Local Variables     Returning a Value from a Method     Assertions     Instance Variables     Summarizing the Test     Refactoring     this     private     Naming Conventions     Whitespace     Exercises Lesson 2: Java Basics.     CourseSession     Enrolling Students     int     Initialization     Default Constructors     Suites     The SDK and java.util.ArrayList     Adding Objects     Incremental Refactoring     Objects in Memory     Packages and the import Statement     The java.lang Package     The Default Package and the package Statement     The setup Method     More Refactoring     Class Constants     Dates     Overload Constructors     Deprecation Warnings     Refactoring     Creating Dates with Calendar     Comments     Javadoc Comments     Exercises Lesson 3: Strings and Packages.     Characters and Strings     Strings     StringBuilder     System Properties     Looping Through All Students     Single-Responsibility Principle     Refactoring     System.out     Using System.out     Refactoring     Package Structure     Access Modifiers     Using Ant     Exercises Lesson 4: Class Methods and Fields.     Class Methods     Class Variables     Operating on Class Variables with Class Methods     Static Import     Incrementing     Factory Methods     Simple Design     Static Dangers     Using Statics: Various Notes     Jeff’s Rule of Statics     Booleans     Tests as Documentation     More on Initialization     Exceptions     Revisiting Primitive-Type Field Initialization     Exercises Lesson 5: Interfaces and Polymorphism.     Sorting: Preparation     Sorting: Collections.sort     CourseReportTest     Interfaces     Why Interfaces     Implementing Comparable     Sorting on Department and Number     The if Statement     Grading Students     Floating-Point Numbers     Testing Grades     Refactoring     Enums     Polymorphism     Using Interface References     ArrayList and the List Interface     Exercises Lesson 6: Inheritance.     The switch Statement     Case Labels Are Just Labels     Maps     Inheritance     Abstract Classes     Extending Methods     Refactoring     Enhancing the Grade Enum     Summer Course Sessions     Calling Superclass Constructors     Refactoring     More on Constructors     Inheritance and Polymorphism     The Principle of Subcontracting     Exercises Lesson 7: Legacy Elements.     Looping Constructs     Breaking Up a Student’s Name     The while Loop     Comparing Java Loops     Refactoring     Looping Control Statements     The Ternary Operator     Legacy Collections     Iterators     Iterators and the for-each Loop     Casting     Wrapper Classes     Arrays     Refactoring     Exercises Lesson 8: Exceptions and Logging.     Exceptions     Dealing With Exceptions     Checked Exceptions     Exception Hierarchy     Creating Your Own Exception Type     Checked Exceptions vs. Unchecked Exceptions     Messages     Catching Multiple Exceptions     Rethrowing Exceptions     Stack Traces     The finally Block     Refactoring     Logging     Logging in Java     Testing Logging     Logging to Files     Testing Philosophy for Logging     More on FileHandler     Logging Levels     Logging Hierarchies     Additional Notes on Logging     Exercises Lesson 9: Maps and Equality.     Logical Operators     Short-Circuiting     Hash Tables     Courses     Refactoring Session     Equality     The Contract for Equality     Apples and Oranges     Collections and Equality     Hash Tables     Collisions     An Ideal Hash Algorithm     A Final Note on hashCode     More on Using HashMaps     Additional Hash Tables and Set Implementations     toString     Strings and Equality     Exercises Lesson 10: Mathematics.     BigDecimal     More on Primitive Numerics     Integer Math     Numeric Casting     Expression Evaluation Order     NaN     Infinity     Numeric Overflow     Bit Manipulation     Java.lang.Math     Numeric Wrapper Classes     Random Numbers     Exercises Lesson 11: IO.     Organization     Character Streams     Writing to a File     Java.io.File     Byte Streams and Conversion     A Student User Interface     Testing the Application     Data Streams     CourseCatalog     Advanced Streams     Object Streams     Random Access Files     The Student Directory     sis.db.DataFileTest     Static Nested Classes and Inner Classes     sis.db.DataFile     sis.db.KeyFileTest     sis.db.KeyFile     sis.util.IOUtilTest     sis.util.IOUtil     sis.util.TestUtil     Developing the Solution     Exercises Lesson 12: Reflection and Other Advanced Topics.     Mock Objects Revisited     The Jim Bob ACH Interface     The Mock Class     The Account Class Implementation     Anonymous Inner Classes     Adapters     Accessing Variables from the Enclosing Class     Tradeoffs     Reflection     Using JUnit Code     The Class Class     Building the Suite     Class Modifiers     Dynamic Proxy     A Secure Account Class     Building the Secure Account Solution     The SecureProxy Class     Problems With Reflection     Exercises Lesson 13: Mulithreading.     Multithreading     Search Server     The Search Class     Less Dependent Testing     The Server     Waiting in the Test     Creating and Running Threads     Cooperative and Preemptive Multitasking     Synchronization     Creating Threads with Runnable     Synchronized     Synchronized Collections     BlockingQueue     Stopping Threads     Wait/Notify     Additional Notes on wait and notify     Locks and Conditions     Thread Priorities     Deadlocks     ThreadLocal     The Timer Class     Thread Miscellany     Summary: Basic Design Principles for Synchronization     Exercises Lesson 14: Generics.     Parameterized Types     Collection Framework     Multiple Type Parameters     Creating Parameterized Types     Erasure     Upper Bounds     Wildcards     Implications of Using Wildcards     Generic Methods     Wildcard Capture     Super     Additional Bounds     Raw Types     Checked Collections     Arrays     Additional Limitations     Reflection     Final Notes     Exercises Lesson 15: Assertions and Annotations.     Assertions     The assert Statement vs. JUnit Assert Methods     Annotations     Building a Testing Tool     TestRunnerTest     TestRunner     The @TestMethod Annotation     Retention     Annotation Targets     Skipping Test Methods     Modifying TestRunner     Single-Value Annotations     A TestRunner User Interface Class     Array Parameters     Multiple Parameter Annotations     Default Values     Additional Return Types and Complex Annotation Types     Package Annotations     Compatibility Considerations     Additional Notes on Annotations     Summary     Exercises Additional Lesson I: Swing, Part 1.     Swing     Getting Started     Swing Application Design     Panels     Refactoring     More Widgets     Refactoring     Button Clicks and ActionListeners     List Models     The Application     Layout     GridBagLayout     Moving Forward Additional Lesson II: Swing, Part 2.     Miscellaneous Aesthetics     Feel     Tables     Feedback     Responsiveness     Remaining Tasks     Final Notes Additional Lesson III: Java Miscellany.     JARs     Regular Expressions     Cloning and Covariance     JDBC     Internationalization     Call by Reference versus Call by Value     Java Periphery     What Else Is There? Appendix A: An Agile Java Glossary. Appendix B: Java Operator Precedence Rules. Appendix C: Getting Started with IDEA.     IDEA     The Hello Project     Running Tests     Taking Advantage of IDEA Agile Java References. Index.