Object Oriented Programming

Request more details:

submit request
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.
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