Object Oriented Programming

Course Description

The maximum benefits of adopting OO are gained only if the software is appropriately designed. The choice of classes, and the distribution of tasks between the objects, is of crucial importance. Nontrivial systems include many recurring design problems whose solutions are commonly repeated from place to place, and from programmer to programmer. The essence and basic structure of a solution may be repeated many times, even though the realization is different in each case. Patterns offer a technique for capturing good design, and offer a quick way to become proficient at Object Oriented design. This course introduces patterns from the ground up, presenting principles as well as concrete examples in UML and Java. It develops understanding through lectures, discussion, and some exercises to reinforce the concepts by putting them into practice.
5 Days
Contact us for pricing
 

Prerequisites

Ideally this training would be preceded by the course: design and develop Java applications.

OO design

Introducing the principles of OO design
aims of OO design
OO designs are based on the 'real' world
what's an object?
distribution of responsibilities
objects, classes, messages and methods
decoupling for flexible software
interfaces and the 'implements' relation
types and object specifications
class extension

OO analysis

layering design decisions: abstraction
exposing gaps and inconsistencies: precision
traceable designs: continuity
clear, ready communication: a language for design
a vanilla process: development from scratch (brief overview)
system requirements models
responsibilities and collaborations
persistence, GUI, distribution
coding in an OO language
component-based design (brief overview)
robust, flexible software
components and interfaces
components kits and architecture
component and reuse culture
patterns (brief overview)

Modelling with UML

static models
objects, types, attributes, snapshots
subtypes
dynamics
use-cases and tasks
event charts
state charts
building a business model
finding use-cases
connecting use-case and class views
the dictionary
UML notation review
uses of business model
architecture of business process
context for software requirements
basis for component interface definition
documentation style

Analysis and requirements

system context models
high-level operation specs
state charts for system models
meaning of 'model'
how to start abstract and get more detailed
event charts: horizontal and vertical expansion
elaborating models
relating the levels of detail
building a system spec
system context
defining system use-case goals
modelling patterns

Basic design

separating core from GUI, persistence, and other layers
selection of control objects
designing system operations with messages
decoupling, extensibility, reusability
CRC 'cards'
dependencies and visibilities
the class dictionary
translation to code

Patterns

basic form
problem and forces
solution and consequences
an example: the Composite pattern
documenting patterns
documenting pattern use

Organizing patterns

pattern catalogues
the "Gang of Four"
"Pattern-Oriented Software Architecture" (POSA)
strategic versus tactical patterns
review of organizational patterns
review of analysis patterns
review of architectural patterns
review of design patterns and idioms
pattern languages

Delegation patterns

basic principles
Adapter and its variations
Proxy
Bridge
Manager

Domain coupling

GUIs
reification of use-cases in UI objects
persistence and proxies
building atop object and relational DBs
networks and layering)

Decoupling patterns

layers
Interface Decoupling
Role Decoupling
Observer
The Law of Demeter

Creational patterns

Factory Method
Disposal Method
Singleton (and issues)
Cloning
Copy Constructor

Value patterns

value-based programming
Whole Value
Value Object
Enumeration Values
Class Factory Method
Copied Value
Immutable Value
Mutable Companion

Functional patterns

Named Selector
Command
Command Processor
Command Adapter
Composite Command
Composite Exception
Block
Active Object)

Sequential patterns

Combined Method
Finally for Each Release
Execute-around Method

Iteration patterns

Iterator
Combined Iterator
Enumeration Method

Selection patterns

Null Object
State-based Selection
Objects for States (State)
Collections for States

OOAD process review

the main tasks and artefacts
business/conceptual modelling
specification/requirements modelling
architecture
design, Implementation
integration and test
short-cycle development
spiral model
phased development
role of prototyping
Object Oriented ProgrammingOOP