Lesson 1

The object design phase is indeed a crucial step in shaping your application to meet your design expectations. It's where you translate the high-level concepts from the analysis phase into a blueprint for your object-oriented program. Here's a breakdown of how it achieves conformity to design expectations:
From Analysis to Design:

• The object design phase follows the analysis phase in the software development lifecycle (SDLC) specifically focused on object-oriented programming (OOP).
• During the analysis phase, you gather requirements, define functionalities, and identify the overall system architecture.
• The object design phase takes this foundation and delves deeper into how objects will be structured and interact to fulfill the identified requirements.

Key Activities in Object Design:

• Identifying Objects: You analyze the functionalities and data needs of your application and map them to real-world entities or concepts that can be represented as objects.
• Defining Classes and Attributes: You create classes as blueprints for objects, specifying the attributes (data members) each object will hold.
• Defining Methods: You define methods (functions) within classes to encapsulate the behavior and operations that objects can perform.
• Relationships and Collaborations: You establish relationships between objects, such as inheritance, association, and aggregation, to model how objects interact and collaborate to achieve the desired functionalities.

Ensuring Design Expectations: By carefully considering these activities, the object design phase helps ensure your application conforms to your design expectations in several ways:

• Object-Oriented Principles: The use of objects, classes, and their relationships adheres to the core principles of OOP, promoting modularity, reusability, and maintainability of code.
• Data Representation: Defining attributes within classes ensures data is organized and encapsulated within objects, promoting data integrity.
• Functionality Modeling: Methods within classes encapsulate specific functionalities, making the code more organized and easier to understand and modify.
• Object Interaction: Defining relationships between objects dictates how they work together to achieve the overall system behavior as envisioned in the design.

Overall, the object design phase acts as a bridge between the high-level design goals and the actual implementation of your application. By carefully crafting the object-oriented structure, you lay the groundwork for a program that adheres to your design expectations and delivers the desired functionalities.

Remember that during design you are still not coding. Many people who progress through the ranks from programmer to designer to architect tend to think through every problem in terms of final code. But design is still a language and technology-independent activity. Of course, there is a relationship between implementation and the design. In an ideal world, you could create a pure design and go straight to code. In the real world, languages and technologies constrain the design by the features and mechanisms they employ. The goal of design is to establish the target for what the code must do. As the implementation choices are finalized, the design may need to be altered. Alterations will reflect the features of the implementation environment.

Your application should do what users expect it to do. Object design is the phase in which you decide how to make your application conform to these expectations. You have defined these expectations in project initiation using the use cases. You have defined all of the resources that the system needs to manage during problem analysis using the object model and the interaction diagrams. During architectural analysis you partitioned the system into units based on the problem domain use cases (domain partitions) and the architecture best suited to support the goals of the system. In the remainder of this course, you will learn about and practice the activities that make up the object design phase. You will work on each partition to define the control mechanisms within the software and the interfaces between these software pieces.
After completing this module, you will be able to:

1. Describe the diagrams used during design and explain how they interact with one another
2. Explain why and how the statechart diagram is used during design
3. Build a statechart from multiple sequence diagrams
4. Apply the state design pattern to handle complex state-specific behavior