How to Use Objects

Series
Addison-Wesley
Author
Holger Gast  
Publisher
Addison-Wesley
Cover
Softcover
Edition
1
Language
English
Total pages
832
Pub.-date
December 2015
ISBN13
9780321995544
ISBN
0321995546
Related Titles


Product detail

Product Price CHF Available  
9780321995544
How to Use Objects
71.30 approx. 7-9 days

Description

How to Use Objects is organized around three fundamental principles: contracts of methods lead to a discussion of interfaces, specifications, and correctness. The concept of events leads to an understanding of objects as reactive entities, introducing insights that lie at the heart of all frameworks. Finally, responsibility-driven design perceives applications as networks of collaborating objects, illuminating crucial concepts of design and architecture.

Features

  • The only book of its kind: helps students wield deep and powerful object-oriented techniques, principles, and patterns to write far more effective code
  • Organized around three crucial sets of principles: contracts, events, and responsibility-driven design
  • Places objects in context by illuminating the Eclipse platform's design, implementation, refactorings, and usage

Table of Contents

Preface xv

Acknowledgments xvii

About the Author xix

Introduction xxi

 

Part I: Language Usage 1

 

Chapter 1: Basic Usage of Objects 3

1.1 The Core: Objects as Small and Active Entities 3

1.2 Developing with Objects 9

1.3 Fields 18

1.4 Methods 30

1.5 Exceptions 58

1.6 Constructors 71

1.7 Packages 77

1.8 Basics of Using Classes and Objects 79

 

Chapter 2: Fundamental Object Structures 97

2.1 Propagating State Changes: Observer 97

2.2 Compound Objects 108

2.3 Hierarchical Structures 116

2.4 Wrappers: Adapters, Proxies, and Decorators 136

 

Chapter 3: Abstraction and Hierarchy 143

3.1 Inheritance 143

3.2 Interfaces 167

 

Part II: Contracts 185

 

Chapter 4: Contracts for Objects 187

4.1 The Core: Assertions Plus Encapsulation 188

4.2 Elaborating the Concepts by Example 201

4.3 Motivating Contracts with Hindsight 214

4.4 Invariants and Callbacks 215

4.5 Checking Assertions at Runtime 218

4.6 The System Boundary 219

4.7 Arguing About the Correctness of Programs 223

 

Chapter 5: Testing 243

5.1 The Core: Unit Testing 244

5.2 The Test First Principle 250

5.3 Writing and Running Unit Tests 253

5.4 Applications and Motivations for Testing 266

 

Chapter 6: Fine Print in Contracts 285

6.1 Design-by-Contract 285

6.2 Contracts and Compound Objects 297

6.3 Exceptions and Contracts 327

6.4 Inheritance and Subtyping 329

 

Part III: Events 339

 

Chapter 7: Introduction to the Standard Widget Toolkit 341

7.1 The Core: Widgets, Layouts, and Events 342

7.2 The WindowBuilder: A Graphical Editor for UIs 351

7.3 Developing with Frameworks 355

7.4 SWT and the Native Interface 363

7.5 Compound Widgets 367

7.6 Dialogs 374

7.7 Mediator Pattern 380

7.8 Custom Painting for Widgets 383

7.9 Timers 387

7.10 Background Jobs 393

7.11 Review: Events and Contracts 407

 

Chapter 8: A Brief Introduction to Threads 413

8.1 The Core: Parallel Code Execution 413

8.2 Correctness in the Presence of Threads 416

8.3 Notifications Between Threads 423

8.4 Asynchronous Messages 431

8.5 Open Calls for Notification 434

8.6 Deadlocks 437

 

Chapter 9: Structuring Applications with Graphical Interfaces 443

9.1 The Core: Model-View Separation 444

9.2 The Model-View-Controller Pattern 453

9.3 The JFace Layer 472

9.4 The MVC Pattern at the Application Level 494

9.5 Undo/Redo 505

9.6 Wrapping Up 520

 

Chapter 10: State Machines 523

10.1 The Core: An Object’s State and Reactions 524

10.2 State Machines in Real-World Scenarios 533

10.3 Implementing Finite State Machines 547

 

Part IV: Responsibility-Driven Design 565

 

Chapter 11: Responsibility-Driven Design 567

11.1 The Core: Networks of Collaborating Objects 568

11.2 The Single Responsibility Principle 586

11.3 Exploring Objects and Responsibilities 593

11.4 Responsibilities and Hierarchy 616

11.5 Fundamental Goals and Strategies 620

 

Chapter 12: Design Strategies 637

12.1 Coupling and Cohesion 638

12.2 Designing for Flexibility 652

12.3 Extensibility 678

12.4 Reusability 710

 

Part V: Appendix 727

 

Appendix A Working with Eclipse Plugins 729

A.1 OSGi: A Module System for Java 730

A.2 Launching Plugins 744

A.3 Where to Go from Here 749

 

Bibliography 751

Index 769

Author

Holger Gast graduated with a degree in computer science from the University of Tübingen, Germany, in 2000, and received a Ph.D. with a dissertation on type systems for programming languages in 2005 (Tübingen). As a post doctoral fellow, he worked on formal correctness proofs for software and finished his Habilitation for Computer Science in 2012 (Tübingen).

 

Since 2000, he has been teaching in the area of software engineering at different levels of the computer science curriculum, starting from introductory programming courses to lectures on software design and architecture. His other interests include scientific databases for the humanities and the model-driven construction of data-driven web applications.