Java Programming (Advanced): Object Oriented Design UK Classes & Lessons (Development)

About this class

The product of object-oriented analysis is a conceptual model that must be transformed into an actual implementation. The process of design elaborates and transforms this conceptual model into something that can be implemented practically. Implementation strategies will vary from language to language.This course acts as the bridge between analysis and implementation knowledge, in many respects picking up where our Java programming and technology courses, and analysis and design courses, leave off.The course begins by looking at the conceptual model of a system and the modelling elements used to express it.

This is followed by an introduction to patterns, which are an essential concept in modern OO development. Patterns for architecture, design and language-level idioms are introduced and applied to the conceptual model. Technology issues such as persistence, distribution and multithreading are covered as options later in the course.This course is based on the UML (Unified Modelling Language) notation for describing object systems and the choice of Java as an implementation language.

This lecturer led course also involves a hands-on case study which is developed throughout the week from specification to the early stages of coding. The emphasis is very much on the design process rather than on the production of code.

Who will the lesson benefit?

IT professionals who already have some Java experience and are looking to further their skills or resolve any issues they may have with the more complex areas of its use.

Contents of this class

System Development

The development life cycle
Activities and deliverables
Use cases and scenarios

Static Modelling

Classes and object diagrams
Attributes and operations
Association, aggregation and composition
Stereotypes

Dynamic Modelling

Sequence diagrams
Collaboration diagrams
State diagrams

Constraints

Programming by contract
Specifying operation behaviour
Clarifying operation and attribute effects
Constraints between relationships

Patterns

Recognising, reusing and documenting recurring design solutions
The Composite pattern
The Iterator pattern
The Command pattern
Idioms as language level patterns
The use of inner classes
Listeners
Iterators

Architecture

Coupling and cohesion
Collaborations
Package, source code, execution and deployment architectures
Architectural patterns
Layered systems
Multi-tiered architectures

Functionality and Representation

Mapping attributes and operations to Java methods and fields
Mapping simple value types
Class methods and variables
Separation of policy from computation

Delegation

Delegation principles
The Object Adapter pattern
The Bridge pattern
The Proxy pattern
The Decorator pattern
The Template Method pattern

Class Relationships

Inheritance vs delegation
The role of interfaces
Multiple inheritance of interfaces
The Class Adapter pattern
The use of inner classes with adapters

Object Relationships

Resolving relationship multiplicity and link attributes
Implementation techniques for association, aggregation and composition
The Null Object pattern
Bidirectional relationships

Object State

Object life cycle models and state diagrams
Explicit and derived attributes for object state
State transition tables
The Objects for States pattern
The Collections for States pattern

Object Creation and Ownership

Garbage collection issues
Object factories
The Factory Method pattern
The Abstract Factory pattern
The Disposal Method pattern
The Singleton pattern

Exceptions

Handling constraint violations at runtime
Designing Java exceptions
Writing exception safe code

Events and Notification

Events and event propagation models
The pull model and polling
The push model and callbacks
The Chain of Responsibility pattern
The Observer pattern
The Java event model

Component Systems

Client versus server side components
Designing classes as JavaBeans
Multi-tier component models and EJB

Concurrency

Active and passive objects
Sequential, guarded and concurrent operations
Threaded objects
Mapping concurrency to Java threads
Thread safety and synchronized
Threading guidelines

Persistence

Serialisation
JDBC

Distributed Systems

Principles and consequence of distribution
The impact of RMI on class design
RMI guidelines
The impact of CORBA on class design
CORBA idioms