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