Agile Java?: Crafting Code with Test-Driven Development

Agile Java?: Crafting Code with Test-Driven Development

By: Jeff Langr (author)Paperback

Up to 2 WeeksUsually despatched within 2 weeks

£35.19 RRP £43.99  You save £8.80 (20%) With FREE Saver Delivery


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).

About Author

Jeff Langr has more than twenty years of development experience. He currently consults on software development, design, and agile processes through his company, Langr Software Solutions ( Langr worked for Uncle Bob Martin for two years at Object Mentor. He is the author of Essential Java Style (Prentice Hall PTR, 1999), and has published widely on Java and TDD in Software Development, C/C++ Users Journal, and diverse online magazine sites and portals. (c) Copyright Pearson Education. All rights reserved.


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 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.

Product Details

  • ISBN13: 9780131482395
  • Format: Paperback
  • Number Of Pages: 792
  • ID: 9780131482395
  • weight: 1210
  • ISBN10: 0131482394

Delivery Information

  • Saver Delivery: Yes
  • 1st Class Delivery: Yes
  • Courier Delivery: Yes
  • Store Delivery: Yes

Prices are for internet purchases only. Prices and availability in WHSmith Stores may vary significantly