1

Overview

• Fundamental OO Design Principles
• Fundamental Design Patterns
• GoF Patterns
  • Creational Patterns
  • Structural Patterns
  • Behavioral Patterns

1

Business Concept Modeling (BCM)
The most powerful way to describe an organization's business concepts, rules and policies

This chapter presents how to model any business domain using the Unified Modeling Language (UML). BCM is a crucial topic for students to master the various Domain Models and Pattern Class Diagrams presented in the Design and Implementation chapters of this course.

• Overview
• Examples
• Model Elements: Theory, Syntax
• Examples and Exercises for:
  • Business Concepts
    • Class
  • Business Concept Relationships
    • Inheritance
    • Composition
    • Association
    • Association Role
    • Association Class
• BCM Decision Tree
• BCM Practice: an entire Business Domain
• The Composite Pattern

1-2

Object Design Fundamentals
The basis of all advanced OO principles, techniques, and patterns

This chapter explains the fundamental principles of object design and the best strategies to implement them.

We first cover the best basic OO Design techniques that implement Encapsulation & Specialization as well as Inheritance & Polymorphism. Then we explore the different polymorphism strategies.

The chapter finishes with the Role Pattern, which is used to implement flexible and powerful dynamic types and roles. Roles are essential parts of problem domains that require solutions ranging from static, non-changing roles to flexible, changing roles, assuming multiple roles and providing polymorphism across all roles.

• OO Principles
  • Encapsulation
  • Specialization
  • Self-Sufficiency
  • Interface
  • Instantiation
  • Abstraction
  • Inheritance
  • Polymorphism
• Encapsulation & Specialization
• Inheritance & Polymorphism
• Polymorphism Strategies:
  • Replacement Method Pattern
  • Extension Method Pattern
  • Template Method Pattern
  • Strategy Pattern
• The Role Pattern
  • Inheritance Roles
  • Association Roles
  • Role Classes
  • Role Class Generalization
  • Association Class Roles
  • Association Class Roles with Role Type

2

Link Management
The complete coverage of all relationship implementation issues and strategies

Implementing a domain model typically includes writing elaborate code for instantiating and managing the different types of object relationships at runtime. We cover all the details about relationship implementation and show how they can be managed efficiently with minimum coding overhead.

• Association Implementation
• Implementing Association Ends
• Link Management Strategies:
  • Client-Managed Associations
  • Object-Managed Associations
  • Link Factory Pattern
  • Introspective Link Factory
• Composition Implementation
• Association Class Implementation
• Ternary Association Implementation
• Reflexive Associations

2-3

Domain Model Implementation
Proper OO design and patterns for implementing business logic in a domain model

We explore how objects can collaborate and use each other based upon Specialization and Delegation to implement specific functional requirements.

These techniques quickly lead us towards the Propagation Pattern, the most powerful approach to implement elaborate Business Logic. This topic is then complemented by the Visitor Pattern that shows how Domain functionality can be encapsulated outside the Business Classes, keeping the Domain lean and easy to manage.

• Object Collaboration
  • The Iterator Pattern
• The Propagation Pattern
• The Visitor Pattern (Advanced)

3

Application Architecture
Structuring an application's architecture around its domain model

A look at the big picture. This chapter shows the architecture of a typical enterprise application and where the domain model fits in.

• Layering of an Enterprise Application
• Enterprise Architecture
• Domain Persistence
  • The Importance of Domain
  • Domain Persistence Strategies
    • Object-Oriented Persistence
    • Relational-Dependent Persistence
  • Using All Options
  • Relationship between OO and Relational Models

3

Object Construction I
Key strategies for managing complex object construction logic

In object-oriented languages we use constructors to create objects. Using constructors directly has certain limitations that can convolute the application code and make it hard to reuse and understand.

In this chapter we discuss powerful patterns for properly encapsulating object creation logic. These solutions maximize reuse and keep client code simple and free of detailed instantiation code.

• Constructors & Their Limitations
• Encapsulating Construction Logic
• The Creation Method Pattern
• The Object Factory Pattern
• The Singleton Pattern
• The Prototype Pattern
  • Object Cloning
  • Object Identity & Equality

3

Object Construction II
Advanced strategies for object construction

Some design situations require a higher degree of abstraction and extensibility in which case simpler methods of structuring creation logic fail to provide the desired flexibility.

This chapter shows advanced object construction patterns that make heavy use of inheritance & polymorphism to provide very elegant and flexible designs.

• The Factory Method Pattern
• The Abstract Factory Pattern
• The Builder Pattern

3-4

More Structural Patterns
Combining objects to form more complex structures

• The Façade Pattern
• The Adapter Pattern
• The Decorator Pattern
• The Proxy Pattern
• The Bridge Pattern
• The Flyweight Pattern

4

More Behavioral Patterns
Assigning responsibilities among objects and the communication between them

• The Command Pattern
• The Observer Pattern
• The Mediator Pattern
• The Memento Pattern
• The Chain of Responsibility Pattern
• The State Pattern
• The Interpreter Pattern

4-5

Design Patterns in Java & JEE
Deepening understanding by looking at real-world use of patterns

• Java Collections API
• Java AWT & Swing
• Java I/O
• Java Reflection API
• JDBC
• Java Servlets & JSP

5

The Rules Engine Framework (Advanced)
Offering Dynamic Behavior to End-users or Business Experts

Business rules change more frequently than any other aspect of your enterprise applications. Historically, business rules have been hard-coded as part of the business logic. To provide greater flexibility and control it is a far better approach to encapsulate the rules separately from the domain model, make them dynamic and manage them with a Rules Engine. In this chapter we go over the entire OO analysis and design of a simple but powerful Rules Engine. We analyze what rules are, build a UML model, design a Rules Engine, explore its code and finally extend the engine with additional features during a lab. This is a great opportunity to not only understand Rules Engines but also apply many of the OO Development techniques studied in this course.

Furthermore, this chapter introduces additional Design Patterns like "Command", "Composite", and "Façade". Students appreciate how these patterns solve the Rules Engine specific problems. This is the most effective way to learn Design Patterns.

• Definition
• Class-based / object-based rules
• Object rules challenges and solutions
• Rules Engine features
• Commonly used Rules Engines
• Rules Engine architecture
• Rule instance examples and analysis
• Rule UML model essentials
• Rules narrative, UI and "soft" coding
• Elaborated model
• Rules Structure
  • "Composite" rule
  • "If" structure
  • "Comparison" model
  • "Test", "Value", and "Method"
• Design Patterns used
  • Composite
  • Command
  • Façade
  • Interpreter
• Summary and conclusions
• Rules Engine Lab
  • Creating your own rules
  • Extending the Rules Engine
• Deciding if/when you need a Rules Engine