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

..................Content has been hidden....................

You can't read the all page of ebook, please click here login for view all page.
Reset
18.191.223.123