How to Use Objects: Code and Concepts

While most developers today use object-oriented languages, the full power of objects is available only to those with a deep understanding of the object paradigm. How to Use Objects will help you gain that understanding, so you can write code that works exceptionally well in the real world.

Author Holger Gast focuses on the concepts that have repeatedly proven most valuable and shows how to render those concepts in concrete code. Rather than settling for minimal examples, he explores crucial intricacies, clarifies easily misunderstood ideas, and helps you avoid subtle errors that could have disastrous consequences.

Gast addresses the technical aspects of working with languages, libraries, and frameworks, as well as the strategic decisions associated with patterns, contracts, design, and system architecture. He explains the roles of individual objects in a complete application, how they react to events and fulfill service requests, and how to transform excellent designs into excellent code. Using practical examples based on Eclipse, he also shows how tools can help you work more efficiently, save you time, and sometimes even write high-quality code for you.

Gast writes for developers who have at least basic experience: those who’ve finished an introductory programming course, a university computer science curriculum, or a first or second job assignment.

Coverage includes

• Understanding what a professionally designed object really looks like

• Writing code that reflects your true intentions—and testing to make sure it does

• Applying language idioms and connotations to write more readable and maintainable code

• Using design-by-contract to write code that consistently does what it’s supposed to do

• Coding and architecting effective event-driven software

• Separating model and view, and avoiding common mistakes

• Mastering strategies and patterns for efficient, flexible design

• Ensuring predictable object collaboration via responsibility-driven design

Register your product at informit. com/register for convenient access to downloads, updates, and corrections as they become available.

 

Table of Contents

 

Preface

Introduction

Part I: Language Usage

Chapter 1: Basic Usage of Objects

1. 1 The Core: Objects as Small and Active Entities

1. 2 Developing with Objects

1. 3 Fields

1. 4 Methods

1. 5 Exceptions

1. 6 Constructors

1. 7 Packages

1. 8 Basics of Using Classes and Objects

Chapter 2: Fundamental Object Structures

2. 1 Propagating State Changes: Observer

2. 2 Compound Objects

2. 3 Hierarchical Structures

2. 4 Wrappers: Adapters, Proxies, Decorators

Chapter 3: Abstraction and Hierarchy

3. 1 Inheritance

3. 2 Interfaces

Part II: Contracts

Chapter 4: Contracts for Objects

4. 1 The Core: Assertions plus Encapsulation

4. 2 Elaborating the Concepts by Example

4. 3 Motivating Contracts with Hindsight

4. 4 Invariants and Callbacks

4. 5 Checking Assertions at runtime

4. 6 The System Boundary

4. 7 Arguing about the Correctness of Programs

Chapter 5: Testing

5. 1 The Core: Unit Testing

5. 2 The Test First Principle

5. 3 Writing and Running Unit Tests

5. 4 Applications and Motivations for Testing

Chapter 6: Fine Print in Contracts

6. 1 Design by Contract

6. 2 Contracts and Compound Objects

6. 3 Exceptions and Contracts

6. 4 Inheritance and Subtyping

Part III: Events

Chapter 7: Introduction to the SWT

7. 1 The Core: Widgets, Layouts, Events

7. 2 The WindowBuilder: A Graphical Editor for UIs

7. 3 Developing with Frameworks

7. 4 SWT and the Native Interface

7. 5 Compound Widgets

7. 6 Dialogs

7. 7 Mediator Pattern

7. 8 Custom Painting for Widgets

7. 9 Timers

7. 10 Background Jobs

7. 11 Review: Events and Contracts

Chapter 8: A Brief Introduction to Threads

8. 1 The Core: Parallel Code Execution

8. 2 Correctness in the Presence of Threads

8. 3 Notifications between Threads

8. 4 Asynchronous Messages

8. 5 Open Calls for Notification

8. 6 Deadlocks

Chapter 9: Structuring Applications with UIs

9. 1 The Core: Model-View Separation

9. 2 The Model-View-Controller-Pattern

9. 3 The JFace Layer

9. 4 The MVC at the Application Level

9. 5 Undo/Redo

9. 6 Wrapping Up

Chapter 10: State Machines

10. 1 The Core: An Object's State and Reactions

10. 2 State Machines in Real-World Scenarios

10. 3 Implementing Finite State Machines

Part IV: Responsibility-driven Design

Chapter 11: Responsibility-driven Design

11. 1 The Core: Networks of Collaborating Objects

11. 2 The Single Responsibility Principle

11. 3 Exploring Objects and Responsibilities

11. 4 Responsibilities and Hierarchy

11. 5 Fundamental Goals and Strategies

Chapter 12: Design Strategies

12. 1 Coupling and Cohesion

12. 2 Designing for Flexibility

12. 3 Extensibility

12. 4 Reusability

Part V: Appendix

Appendix A: Working with Eclipse Plugins

A. 1 OSGi: A Module System for Java

A. 2 Launching Plugins

A. 3 Where to Go From Here

References

Index