Object Oriented Design and Development Training

Object Oriented Design and Development Training

Click Here to Sign-Up and Become a Member of Intelligentedu.com

This training is available on our members site only. As a member, all of the training and tutorials are available to you. We will be adding more training materials here in the future. You can join now for only USD $15 total for 2 months, $25.00 for 4 months, $34.00 for 6 months, or $59.00 for 1 year. (Please note the local links to member training content do not work on this page.)

Back to Member Sign-up & Information Home Page

Object-Oriented Software Design and Construction

These are excellent online course notes by Dr. Dennis Kafura for this Virginia Tech computer science course.

Introduction to Object-Oriented Programming

Basic Concepts

Abstraction

Separation

Mapping Abstraction and Separation to Software

Composition

Generalization

Relation to Software Engineering

Using Objects of a Single Class

Classes and Objects

Structure of Classes

Creating Objects

Overloaded Methods

Default Arguments

Basic Input/Output

Arrays of Objects

Scope

Dynamically Created Objects

Using Objects of Multiple Classes

Using Objects for Communication

Communicating Objects by Copy

Anonymous Objects

Communicating Objects by Reference and by Pointer

Building Systems by Association

Self Referencing Classes

Implementing a New Class

Implementing a Class

Implementing the Methods of a Class

Organizing the Code

Compiling the code

Debugging

Makefile

Constant Methods, Parameters and Variables

Copy Constructors

Assignment Operator

Implementing a Class Using Aggregation

Implementing Classes that Share Common Properties

Introduction

Sharing Implementations

Inheriting Operations and Data

Overriding Inherited Operations

Type Casting

Interface Sharing

Factoring Base Classes

Templates

Templates with a Single Parameter

Template Parameters

Variables and Constant Template Parameters

Template with Related Parameters

Operator Overloading

Operator Overloading

Operator Overloading Using Non-Member Functions

Type Conversion Operators

Type Conversion and Operator Overloading

Object Oriented Design

Design Representations

Design Patterns

Projects

Project Number 1

Project Number 2

Project Number 3

Object-Oriented System Development

Written by Dennis de Champeaux, Douglas Lea, and Penelope Faure. Copyright 1993 by Hewlett-Packard Company. This book is intended to help the reader better understand the role of analysis and design in the object-oriented software development process. This text does not aim at defining yet another OO ``method''. Instead, we aim to give a minimum set of notions and to show how to use these notions when progressing from a set of requirements to an implementation.

Contents

Preface

1 Overview
Scope - Objects - Development Paradigms - Development Phases - Summary

Part 1: Analysis

2 Introduction to Analysis
Purpose - Models - Process - Summary

3 Object Statics
Instances - Classes - Attributes - Attribute Features - Constraints - Identifying Objects and Classes - Summary

4 Object Relationships
Relationships - Collections - Identifying Relationships - Summary

5 Object Dynamics
Describing Behavior - Transition Networks - Examples - Reducing Complexity - Summary

6 Object Interaction
Transitions - Sending and Receiving Events - Interaction Notations - Examples - Summary

7 Class Relationships
Property Inheritance - Subclasses - Multiple Inheritance- Sibling Relationships - Set Operations - Inheritance of Relations - Summary

8 Instances
Subclasses and Instances - Metaclasses - Parametric Instances - Summary

9 Ensembles
Ensembles - Other Decomposition Constructs - Ensembles as Systems - Summary

10 Constructing a System Model
Requirements Fragment - Use Cases - Subsystems - Vocabulary - Classes - Ensembles - Model - Summary

11 Other Requirements
Resources - Timing - Other Constraints - Summary -

12 The Analysis Process
Software Development Process - Default Sequence of Steps - OO Analysis of the OO Analysis Process - Alternative Processes - Tools - Summary

13 Domain Analysis
Models - Reuse - Summary

14 The Grady Experience

Part II: Design

15 From Analysis to Design
Continuity - Transformation - Design Phases - Design Criteria - Managing Design - Summary

16 Description and Computation
Translating Analysis Models - From Abstract to Concrete - Composing Classes - Controlling Transitions - Generic Classes - Generating Instances - Design for Testability Transformation and Composition - Summary

17 Attributes in Design
Defining Attributes - Concrete Attributes - Views - Exports - Composition and Inheritance - Summary

18 Relationships in Design
Relationships - Collections - Coordinators - Relations versus Composites - Summary

19 Designing Transitions
States and Guards - Atomicity - Timing Constraints - Concrete Transitions - Summary

20 Interaction Designs
Callbacks - Replies - Invocations - Control Flow - Summary

21 Dispatching
Selection - Resolution - Routing - Summary

22 Coordination
Joint Actions - Controlling Groups - Open Systems - Summary

23 Clustering Objects
Clustering - Cluster Objects - System Tools and Services- Persistence - Summary

24 Designing Passive Objects
Transformations - Storage Management - Passive Objects in C++ - Summary

25 Performance Optimization
Optimization and Evolution - Algorithmic Optimization - Performance Transformations - Optimization in C++ - Summary

26 From Design to Implementation
Testing - Performance Assessment - Summary

Appendix: Notation Summary
OAN - ODL

Search:
Enter a search string (any case insensitive perl regexp) to produce an HTML index of all occurrences in the book:

Errata for the first printing of the hardcover book version.
A brief overview of some of the book (mainly topics from Part II dealing with distributed objects) is available as a set of HTML-ized or Postscript slides.

More Object Oriented Design & Development Training

Allen Holub's series on the Object-Oriented Design Process takes you step by step through the entire OO Design process:

Getting Started: How to Prioritize

This article is the first of a series on the OO-design process. It discusses the process in very broad terms, focusing on the development philosophy and environment of design.

Beginning to Design Software

This article continues the series, introducing the formal "problem statement." A simple first attempt at a problem statement for the Bank-of-Allen project is presented.

Refining the Problem Definition

This article continues the series, refining the "problem statement" started last month.

Verifying the Analysis

This article continues the process, discussing prototypes and mock ups, and how to use them to verify your problem statement.

Use Cases, an Introduction

This article Introduces the notion of formal use-case analysis, presenting a general form that you can use for specifying your use cases.

Use Case Planning

This article is the first of three that develops an actual use case for the Bank of Allen project. This installment is a bit lightweight, but the next two will be more meaty. (The editors at IBM decided that short is better for some reason.)

Use Cases Applied, Part 1

This article is the second of three that develops an actual use case for the Bank of Allen project. This installment delves into the the meat of things, filling out the first half of the items in the template that I presented in Part 5.

Use Cases Applied, Part 2

This article finishes up the discussion of formal use cases, filling out the last half of the items in the template that I presented in Part 5. This month's stuff is really the heart of the use case: the scenarios and workflow. You'll find examples of UML activity (workflow) diagrams here.

An Introduction to Object-Oriented Design
This talk is meant to introduce you to object-oriented design. It is particularly useful if you've just started C++ and you're wondering how to decide what classes to use and what goes in them - that's exactly what design is about.

A Road Map For OOA and OOD
The purpose of this road map is to help keep you grounded during the process of designing your object-oriented program. It will explain the purpose of each step in the system, and give some brief examples of good practice. The goal is for you to have some guidance as you go about designing and building your first object-oriented programs.

Object Oriented Design Course Slides
These slides provide a quick but in depth introduction to the following topics: Design by Contract, Exceptions, RTTI and Reflection, Dynamic Proxies, Extreme Programming, Refactoring, Introduction to Frameworks, Frameworks & the Swing Case Study, Components & the COM Case Study and design patterns. (zip download)

Design Patterns Lecture Slides
These slides provide a quick but in depth introduction to design patterns. The slides cover the following patterns: abstract factory, composite, strategy, builder, prototype, factory method, singleton , flyweight, decorator, bridge, command, observer, mediator, iterator, visitor, proxy, state, chain of responsibility, adapter, facade, template method, interpreter, and momento. (zip download)

Design Principles and Design Patterns
Below the architecture related to the software application is the architecture of the modules and their interconnections. This is the domain of design patterns, packages, components, and classes. This is the level that this chapter is concerned about.

Design Patterns Tutorial
After completing this tutorial, you will be able to:

Explain what a pattern is.

Explain the origin of pattern usage.

Utilize patterns in future programming projects.

Object Oriented Analysis and Design using CRC Cards
After completing this tutorial, you will be able to:

Think in an Object Oriented manor.

Use a responsibility-driven approach to object oriented development.

Run a CRC card session.

Use CRC cards of analysis and design.

The Essence of Objects
This is chapter 2 from The Essence of Object Oriented Programming with Java and UML.

Object-Oriented Application Frameworks
An editorial by Mohamed Fayad and Douglas C. Schmidt

Mapping objects to relational databases
What you need to know and why.

Two Online Training Lessons (quizzes not available):

Object-Oriented Analysis & Design: Introduction

Object-Oriented Analysis & Design: System

Object-Oriented Programming Concepts:

What Is an Object?

An object is a software bundle of related variables and methods. Software objects are often used to model real-world objects you find in everyday life.

What Is a Message?

Software objects interact and communicate with each other using messages.

What Is a Class?

A class is a blueprint or prototype that defines the variables and the methods common to all objects of a certain kind.

What Is Inheritance?

A class inherits state and behavior from its superclass. Inheritance provides a powerful and natural mechanism for organizing and structuring software programs.

What Is an Interface?

An interface is a contract in the form of a collection of method and constant declarations. When a class implements an interface, it promises to implement all of the methods declared in that interface.

How Do These Concepts Translate into Code?

This section looks at a small applet, and shows you the code that creates objects, implements classes, sends messages, establishes a superclass, and implements an interface.

Questions and Exercises: Object-Oriented Concepts

Test your understanding of objects, classes, messages, and so on by doing some exercises and answering some questions.

Object-Oriented Programming and Design Using C++
137 page book of lecture notes by Professor Terry Chapman of De Montfort University. This is very well organized and presented. He also also written these:

Introduction to O-O Languages and Programming (11 pages)

Classes (9 pages)

Overloaded Operators (9 pages)

Chapters from REALbasic: The Definitive Guide, 2nd Edition:

Chapter 3: Objects, Classes, and Instances

Chapter 4: Class Relationships and Class Features

Chapters from Object-Oriented Software Construction, Second Edition:

How to find the classes and objects (chapter 22)

Using Inheritance Well (chapter 25)

Object-Oriented Design
When you have read this chapter (from Software Engineering 6th Edition) you will:

Understand how a software design may be represented as a set of interacting objects that manage their own state and operations.

Know the important activities in a general object-oriented design process.

Understand different models that may be used to document an object-oriented design.

Have been introduced to the representation of these models in the Unified Model Language (UML)

Return to Top

Back to previous page

Be sure to check out our new Blogs and discover all the new Free Training!

Community Content:

Object-Oriented Software Design and Construction

Object-Oriented System Development

Contents

More Object Oriented Design & Development Training

Getting Started: How to Prioritize

Beginning to Design Software

Refining the Problem Definition

Verifying the Analysis

Use Cases, an Introduction

Use Case Planning

Use Cases Applied, Part 1

Use Cases Applied, Part 2

What Is an Object?

What Is a Message?

What Is a Class?

What Is Inheritance?

What Is an Interface?

How Do These Concepts Translate into Code?

Questions and Exercises: Object-Oriented Concepts