Home > Store > Software Development & Management > Object Technology

How to Use Objects: Code and Concepts

Register your product to gain access to bonus material or receive a coupon.

How to Use Objects: Code and Concepts

Best Value Purchase

Book + eBook Bundle

  • Your Price: $70.19
  • List Price: $116.98
  • Includes EPUB, MOBI, and PDF
  • About eBook Formats
  • This eBook includes the following formats, accessible from your Account page after purchase:

    ePub EPUB The open industry format known for its reflowable content and usability on supported mobile devices.

    MOBI MOBI The eBook format compatible with the Amazon Kindle and Amazon Kindle applications.

    Adobe Reader PDF The popular standard, used most often with the free Adobe® Reader® software.

    This eBook requires no passwords or activation to read. We customize your eBook by discreetly watermarking it with your name, making it uniquely yours.

More Purchase Options

Book

  • Your Price: $51.99
  • List Price: $64.99
  • Usually ships in 24 hours.

eBook (Watermarked)

  • Your Price: $41.59
  • List Price: $51.99
  • Includes EPUB, MOBI, and PDF
  • About eBook Formats
  • This eBook includes the following formats, accessible from your Account page after purchase:

    ePub EPUB The open industry format known for its reflowable content and usability on supported mobile devices.

    MOBI MOBI The eBook format compatible with the Amazon Kindle and Amazon Kindle applications.

    Adobe Reader PDF The popular standard, used most often with the free Adobe® Reader® software.

    This eBook requires no passwords or activation to read. We customize your eBook by discreetly watermarking it with your name, making it uniquely yours.

About

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

Description

  • Copyright 2016
  • Dimensions: 7-3/8 X 9-1/8
  • Pages: 832
  • Edition: 1st
  • Book
  • ISBN-10: 0-321-99554-6
  • ISBN-13: 978-0-321-99554-4

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.

Extras

Author's Site

Please visit the author's site here.

Sample Content

Online Sample Chapter

Structuring Applications with Graphical Interfaces

Sample Pages

Download the sample pages (includes Chapter 9 and Index)

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

Updates

Submit Errata

More Information

Unlimited one-month access with your purchase
Free Safari Membership