| Day |
Chapters & Strategies |
Topics |
| 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
- 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 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
|
