Summary

Master Java 5.0 and TDD Together: Build More Robust, Professional SoftwareMaster Java 5.0, object-oriented design, and Test-Driven Development (TDD) by learning them together. Agile Java weaves all three into a single coherent approach to building professional, robust software systems. Jeff Langr shows exactly how Java and TDD integrate throughout the entire development lifecycle, helping you leverage today's fastest, most efficient development techniques from the very outset. Langr writes for every programmer, even those with little or no experience with Java, object-oriented development, or agile methods. He shows how to translate oral requirements into practical tests, and then how to use those tests to create reliable, high-performance Java code that solves real problems. Agile Java doesn't just teach the core features of the Java language: it presents coded test examples for each of them. This TDD-centered approach doesn't just lead to better code: it provides powerful feedback that will help you learn Java far more rapidly. The use of TDD as a learning mechanism is a landmark departure from conventional teaching techniques. bull; bull; Presents an expert overview of TDD and agile programming techniques from the Java developer's perspective bull; Brings together practical best practices for Java, TDD, and OO design bull; Walks through setting up Java 5.0 and writing your first program bull; Covers all the basics, including strings, packages, and more bull; Simplifies object-oriented concepts, including classes, interfaces, polymorphism, and inheritance bull; Contains detailed chapters on exceptions and logging, math, I/O, reflection, multithreading, and Swing bull; Offers seamlessly-integrated explanations of Java 5.0's key innovations, from generics to annotations bull; Shows how TDD impacts system design, and vice versa bull; Complements any agile or traditional methodology, including Extreme Programming (XP) copy; Copyright Pearson Education. All rights reserved.

Author Biography

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 (www.LangrSoft.com). 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.

www.langrsoft.com

About the Author

xix

Foreword

xxi

Acknowledgments

xxiii

Introduction

(2)

Who Is This Book For?

(1)

What This Book Is Not

(1)

How to Use This Book

(1)

Exercises

(1)

Conventions Used in This Book

(3)

An Agile Overview

(12)

What Is ``Agile?''

(2)

What Is Java?

(2)

Why OO?

(1)

What Is an Object?

(1)

What Are Classes?

(2)

Why UML?

(1)

What Is Inheritance?

(1)

Why Test-Driven Development?

(3)

Setting Up

(544)

Software You'll Need

(5)

Does It Work?

(1)

Compiling Hello World

(1)

Executing Hello World

(1)

Still Stuck?

(3)

Getting Started

(32)

Testing

(1)

Design

(1)

A Simple Test

(2)

JUnit

(2)

Adding a Test

(2)

Creating a Student

(1)

Creating the Student Class

(1)

Constructors

(1)

Local Variables

(2)

Returning a Value from a Method

(2)

Assertions

(3)

Instance Variables

(3)

Summarizing the Test

(1)

Refactoring

(2)

this

(2)

private

(2)

Naming Conventions

(2)

Whitespace

(1)

Exercises

(1)

Java Basics

(40)

CourseSession

(2)

Enrolling Students

(1)

int

(3)

Initialization

(1)

Default Constructors

(1)

Suites

(1)

The SDK and java.util.ArrayList

(2)

Adding Objects

(2)

Incremental Refactoring

(1)

Objects in Memory

(2)

Packages and the import Statement

(1)

The java.lang Package

(1)

The Default Package and the package Statement

(2)

The setup Method

(2)

More Refactoring

(1)

Class Constants

(2)

Dates

(1)

Overload Constructors

(5)

Deprecation Warnings

(1)

Refactoring

(3)

Creating Dates with Calendar

(1)

Comments

(1)

Javadoc Comments

(3)

Exercises

100

(3)

Strings and Packages

103

(30)

Characters and Strings

103

(3)

Strings

106

(1)

StringBuilder

107

(2)

System Properties

109

(1)

Looping Through All Students

110

(2)

Single-Responsibility Principle

112

(3)

Refactoring

115

(3)

System.out

118

(1)

Using System.out

119

(1)

Refactoring

120

(1)

Package Structure

121

(1)

Access Modifiers

122

(6)

Using Ant

128

(3)

Exercises

131

(2)

Class Methods and Fields

133

(30)

Class Methods

133

(4)

Class Variables

137

(1)

Operating on Class Variables with Class Methods

138

(3)

Static Import

141

(3)

Incrementing

144

(1)

Factory Methods

145

(2)

Simple Design

147

(1)

Static Dangers

147

(1)

Using Statics: Various Notes

148

(1)

Jeff's Rule of Statics

149

(1)

Booleans

150

(4)

Tests as Documentation

154

(3)

Supplemental Materials

What is included with this book?

The New copy of this book will include any supplemental materials advertised. Please check the title of the book to determine if it should include any access cards, study guides, lab manuals, CDs, etc.

The Used, Rental and eBook copies of this book are not guaranteed to include any supplemental materials. Typically, only the book itself is included. This is true even if the title states it includes any access cards, study guides, lab manuals, CDs, etc.

Excerpts

Introduction Introduction I am a software craftsman. 1 I have spent much of my software development career trying to quickly build solutions to problems. At the same time I have tried to ensure that my solutions demonstrate carefully crafted code. I strive for perfection in code, yet I know that it is unattainable, particularly with the constant pressure from business to get product out the door. I take modest pride in the code I build daily, yet when I look at the code I wrote the day before, I wonder, "What the heck was I thinking?" This is what keeps the craft challenging to me--the constant desire to figure out how to do things a little better the next time, and with a little less pain than this time. Agile Java represents a successful approach to learning and mastering Java development. It is based on the way I have learned to best teach programming and to learn new programming languages myself: Using test-driven development (TDD), a technique that introduces a large amount of low-level feedback. This feedback allows you to more quickly see the results of your actions. Using TDD, you will learn how to craft Java code to produce solid object-oriented designs and highly maintainable high-quality systems. I have used TDD in production systems for over four years and am still amazed at what it does for me. It has improved the quality of my code, it has taught me new things each week, it has made me more productive. I have also created and taught language courses using TDD, both at my own company and at Object Mentor (which continues to teach their language courses with this approach). Prior to learning TDD, I spent more than fifteen years learning, developing in, and teaching languages the "classic" way--without using tests to drive the development. The student builds and executes example code. The student obtains feedback on what the code is teaching by viewing the output from code execution. While this is a perfectly valid approach, my anecdotal experience is that using it results in less-than-ideal retention of language details. In contrast, the high volume of rapid feedback in TDD constantly reinforces correct coding and quickly points out incorrect coding. The classic code-run-and-observe approach provides feedback, but at a much slower rate. Unfortunately, it is currently the predominant method of teaching programming. Others have attempted more innovative approaches to teaching. In the 1990s, Adele Goldberg created a product known as LearningWorks designed for teaching younger students. It allowed a user to directly manipulate visual objects by dynamically executing bits of code. The user saw immediate results from their actions. A recent Java training tool uses a similar approach. It allows the student to execute bits of code to produce visual effects on "live" objects. The problem with approaches like these is that they are bound to the learning environment. Once you complete the training, you must still learn how to construct your own system from the ground up, without the use of these constrained tools. By using TDD as the driver for learning, you are taught an unbounded technique that you can continue to use in your professional software development career. Agile Java takes the most object-oriented approach feasible. Part of the difficulty in learning Java is the "bootstrapping" involved. What is the minimum you must learn in order to be able to write classes of some substance? Most books start by teaching you the prototypical first Java program--the "hello world" application. But it is quite a mouthful: class Hello { public static void main(String args) { System.out.println("hello world"); } }. This brief program contains at least a dozen concepts that you must ultimately learn. Worse, out of those dozen co