1 ooad detailed 1.1 UML tools
STARUML, small, use more, there is a similar software, called Jude, with more.
1.2 Object-oriented
- Object-oriented is a system modeling technique, object-orientation, or OO.
- Object-oriented programming is a process of developing programs using OO methodology, object-orientation programming, or OOP.
- Describe or model a system by analyzing the interaction of objects within the system.
- Objects that interact are eventually organized in the form of classes.
- The OO approach consists of three parts: process, logo, and rule.
1.3 Objects
- is an objective and unique entity.
- Is the starting point and foundation of analyzing and solving problems in OOP process.
- have their own identity, data and behavior.
- Can be simple or complex.
- can be abstract or concrete.
- In OOP is a dynamic instance of a class.
Class 1.4
- A class is a template for an object.
- object is generated through the instantiation of the class.
- A class can create multiple objects.
1.5 OOAD
- Object-orientation Analysis and design is the process of analyzing and designing software based on OO methodology.
- OOA, analysis phase.
- OOD, design phase.
- Ideally, the practice often needs to be repeated.
1.5.1 OOA Stage
- The analysis phase mainly solves the problem:
① establishes a clear view of the business problem domain.
② lists the core tasks that the system must complete.
③ establishes a common glossary for problem domains.
④ lists the best solution for this problem domain.
- The core issue to be addressed at this stage is: what does?
1.5.2 Ood Stage
- The design phase mainly solves the problem:
① how to solve specific business problems.
② introduces the supporting elements required for the system to work.
③ defines the implementation strategy of the system.
- The core issues addressed at this stage are: how does?
Main features of 1.6 oop
- Abstract abstraction
- Package Encapsulation
- Inherit inheritance
- Polymorphic polymorphism
- Association Association
- Polymerization aggregation
- Combination composition
- Cohesion and coupling cohesion and coupling
1.6.1 Abstract
- The process of ignoring the details of an object or entity and focusing only on its essential characteristics.
- simplifies functionality and formatting.
- Helps users interact with objects.
1.6.2 Package
- Hide data and implementations.
- Provides a common way for users to invoke functionality.
- Two views of the object:
External view: The work an object can do.
Inner view: How the object completes its work.
1.6.3 inheritance
- A mechanism for defining new types through the types that exist.
- Typically there is a relationship between two types such as is a or kind.
- Inheritance enables the reuse of code, and inheritance is also the basis for polymorphism.
1.6.4 polymorphism
- A name, multiple forms.
- Inheritance-based polymorphism.
- The method is called according to the different choices of the object to be processed.
1.6.5 Association
- A way to refer to objects as they interact with each other.
- When an object uses another object's service or operation through a reference to another object, an association occurs between two objects.
1.6.6 Aggregation
- One of the associated relationships in which an object becomes part of another object.
- is a strong association.
- There is a relationship between the two objects that has a, an object that exists as a property of another object that can be specified by the client as an internal object associated with the external object when it is produced.
1.6.7 Combination
- When an object contains another object, the external object is responsible for managing the life cycle of the internal objects.
- One of the strongest associations in the relationship.
- The creation of an internal object is controlled by the external object itself.
- An internal object cannot exist when the external object does not exist.
1.7 Domain Model
- The domain model is object-oriented, and the domain model can also be a design model in object-oriented terminology.
- The domain model consists of a bit of content:
① with objects that have state and behavior.
② the relationship between domain objects:
- Association Association,
- Rely on Dependency,
- Gather Aggregation,
- Generalize (generalization) generalization
1.7.1 Association Relationship
- A one-to-many and a-to-many nature are the same, but the reference is not the same.
- One person, such as people and ID card.
- Many-to-many, such as students and courses.
1.7.2 Dependency
- A method that accesses the customer class in Businessservice and constructs an object of the customer class.
1.7.3 Aggregation
- Aggregation refers to the relationship between a whole and a part, which is common between entity domain objects.
1.7.4 generalization
- Generalization refers to the inheritance relationship between classes.
1.8 Cohesion and coupling
- Cohesion: A measure of the ability of a class to accomplish a task independently.
- Coupling: Measures the complexity of dependencies within or between systems.
- Design principle: High cohesion, low coupling
1.9 Overview of the development process
- Traditional development process: Waterfall model
- Unified software Development process (USDP)
1.10 Ooad Development process
- Large items are broken down into sub-projects.
- Use UML Tools.
- The unified software development process is an iterative, incremental development process.
1.10.1 iteration, incremental project life cycle
- The project is iterative and incremental.
- An iteration refers to a step in the life cycle.
- Iterations result in an "increment" or an increase in the entire project.
- Large items are broken down into sub-projects.
- At each iteration stage, the following work should be done:
① Selecting and analyzing related use cases
② design based on the selected architecture
③ implementation design at the component level
④ validating components to meet the needs of use cases
- When an iteration satisfies the target, the development enters the next iteration cycle.
- Inception---start up
- Elaboration---Refine
- Construction---Implement
- Transition---Promotion
- Each cycle contains one or more iterations.
- The end of a phase is called a milestone (milestone).
Process diagram:
1.10.2 initialization phase
- The increments of this phase are concentrated in:
① Project Launch
② Building a business model
③ Defining a business problem domain
④ Identify key risk factors
⑤ defining the extension of project requirements
⑥ documentation for creating a business problem domain
1.10.3 Refinement Phase
- The increments of this phase are focused on:
Analysis and design of high-①
② building the infrastructure of the project
③ oversight of major risk factors
④ Create a plan to achieve the objectives of the project
1.10.4 construction phase
- The main increments in this phase are: Code and function implementation
1.10.5 Handover Phase
- The increments of this phase are mainly focused on:
① Publishing Products to users
②beta Test (alpha test is internal test, beta test is user test)
③ perform performance tuning, user training and testing (for performance issues, we often encounter a performance bottleneck when developing a project, but when the project starts, it is not necessary to always be concerned about performance issues, performance should be considered at a later stage, if performance as an important indicator at the outset, will affect the development progress, Perhaps the performance problem at the beginning is not at all, performance tuning is a deep learning, should be based on a lot of testing and data to speak, based on experience or view code is not reliable.
1.10.6 Iteration Workflow
- Each increment consists of a 5-part workflow:
① demand and initial analysis
② Analysis
③ Design
④ implementation
⑤ Test
- The depth of the workflow is different for each iteration of the execution
- Early iterations cover the initial workflow in depth, and later iterations cover the post-workflow in depth.
- 80/20 Principles
Iteration Workflow:
1.10.7 Iterative, incremental advantage
- Reduce costs
- Facilitates better maintenance of project progress
- Facilitates collaborative development of the team
- Easy to adapt to the dynamic changes of user needs
Learning Notes---UML (ii)
