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.
