Cursus Object Georiënteerde Analyse en Design

Cursus Object Georiënteerde Analyse en Design

Een efficiënte object georiënteerde analyse (OOA) is noodzakelijk voor het uitvoeren van projecten met Java of .Net technologie. OO talen zijn erg geschikt om hergebruik, modularisatie en tijdswinst te bereiken, maar het uiteindelijke succes van een software project, hangt af van een correct gebruik van de object georiënteerde programmeertechnieken. Deze cursus behandeld het verzamelen van de vereisten voor het project, de analysefase, het design en de implementatie en testfase van een software project. De cursist is na het volgen van de cursus in staat om met behulp van alle fasen van OOAD te komen tot een volledig object georiënteerd systeem.

Cursus beschrijving

De OOAD training is opgevat als een totaalpakket, waarbij de cursist de volgende belangrijke onderwerpen zal leren: de werking van objecten (OO), de notatie taal (UML) voor de analyses, onze best practices (Patterns) voor het design, en de veelgebruikte methodologie (Unified Process) voor de globale aanpak van een software project. Deze en andere onderwerpen worden georganiseerd rond een concrete case studie met veel levensechte problemen en voorbeeldoplossingen.

Cursus indeling

Dag 1: introductie. Waarom OOAD? De verschillende UML diagrammen. Wat is een methodologie? Welke zijn de meest gebruikte methodologiën? Wie doet wat tijdens de uitvoering van een software project? Het gebruik van de Unified process methodologie. Aanvang van Inceptie. Rolverdeling.

Dag 2: basisconcepten. Wat zijn klassen en objecten? Het verzamelen van requirements. Aanmaken van een use case. Welke informatie moet men uitdrukken in een Use case diagram? Wat zijn actors? Het systeem en zijn functionaliteit uittekenen. Overgang van Inceptie naar Elaboratie. Focus op Analyse. De eerste intermediaire release.

Dag 3: het gebruik van sequence diagrammen. Het tonen van de interacties tussen de gebruikers en het systeem. Wat zijn systeem events? Het sequence dagram als ‘filter’ voor de use case. Wat is een domein model? Welke concepten plaatst men in een domein model? Toevoegen van associaties en multipliciteit.

Dag 4: aanmaken van een operatie contract. De pre en post condities van een operatie contract. Aantonen hoe het domein model gebruikt wordt om de use case te ‘realiseren’. Denken in termen van objecten. Het collaboratie diagram. Gebruiken van patterns. Welke verantwoordelijkheden toekennen aan welke objecten? Aanvang van de Implementatie fase.

Dag 5: gebruik van objecten en berichten. Het klassendiagram. Hoe maakt men een klasse diagram? Van diagram naar code toegaan. De testfase. Wie test wat? Aanmaken van scripts. Aanvang van Transitie, of de overgang naar de ‘nieuwe’ situatie. Beta testen. Aanmaken van documentatie. Opleveren van de ‘finale release’.

Cursus inhoud

• Introduction Why use models. Difference between model and methodology. What is the Unified Modeling Language? The 3 Amigos and their work. Introducing UML, the notation. Identifying business processes. Notation, Patterns and Methodology. Which Methodology to choose?
• Requirements Analysis Requirements gathering. Tools and techniques for identification and analysis of requirements. Identifying business objects. Use-Case driven Requirements analysis.
• RUP - Inception The Rational Unified Process. (RUP) The four phases of the RUP. Mastering the workflows (disciplines) of the RUP. Development of a business vision. Overview of Object Oriented Analysis & Design. Actors, Use Cases and the System. Creation of Use Cases.
• Other Requirements The supplementary specification. What goes into the supplementary specification? Making a Glossary document. Deciding on a Go/No-Go for the Project.
• RUP - Elaboration Structuring of a high-level business use-case. Describing detailed Use Cases.
• Sequence Diagrams Sequence diagrams to detail the Use Case. Emphasis on the time-ordered flow. UML Sequence diagram notation and events.
• Domain Model Definition of the domain model. Adding associations to the domain model. Identifying attributes for the domain model.
• Operation Contracts Operation contracts. Detailing pre-and post conditions.
• GRASP Patterns What are GRASP patterns? Identifying the 5 first patterns. Assigning responsibilities to classes and objects.
• Collaboration Diagrams Detailing object behavior. The link between message and method. Associations and links. Message sequencing. Conditional messages.
• Object Visibility Attribute and parameter visibility. Global and Local visibility.
• Class Diagrams Design of class diagrams. Adding methods to the class diagram. From class diagram to code.
• RUP - Construction Activities and artifacts during this iteration. Refining and enriching the diagrams. Using feedback from the customer.
• OCL (Object Constraint Language) When to use object constraint language? Using collections. Tools that support OCL.
• Relationships between Use Cases Extending and Including Use Cases. Abstract Use Cases. Inheritance between Actors and Use Cases.
• Fine tuning the Domain Model Composition and Aggregation. Association classes. Qualified associations. Inheritance and Specializations.
• Collaboration Diagram Specifics Operations translated in collaboration diagrams. UML Objects and messages. Notation of message structure and iteration.
• Additional Patterns and their usage. Applying best practices to refine the domain model. Polymorphism and other advanced patterns.
• Coding Phase Tips and tricks for creating code from classes. Order of Implementation. Detailing method signatures for the developer.
• State Diagrams Identification of state and transitions. When to use UML automates?
• Implementation Diagrams Component diagrams. When to use Deployment diagrams.
• RUP - Transition Some more details on the Unified Process. Customizing the Unified Process. Best practices in the UP. Tools that support the UP. Versions and prototypes.
• GOF (Gang of Four) Patterns When to use Design patterns. Some common examples. The composite pattern. The State and Singleton pattern.
• Case Study Requirements Gathering. Creation of Use Cases, high level and detailed. Making the Sequence diagrams. How to obtain a Domain model. Operation contracts. Deriving Collaboration diagrams. Updating the Class diagrams. Elaborating some sample code.
• Conclusions When to use UML and the RUP. What about UML 2.0 The future: executable UML.