At the end of the 1980s, as a hot spot for object-oriented technologies has made dozens of object-oriented methods for support software development. its
Methods of Booch, COAD / YOURDON, OMT, and Jacobson have been widely recognized in the object-oriented software development world. Particularly worth
One mentioned is a unified modeling language UML
(Unified Modeling Language), this method combines Booch, OMT, and Jacobson method
The advantages, unified symbolic systems, and absorb many concepts and techniques that have passed the actual inspection from other methods and engineering practices. UML
Since the last year, it has now developed to version 1.1, and has been submitted to the Object Management Group OMG, and the application is a standard for object-oriented methods.
Object-oriented methods support three basic activities: identifying objects and classes, describing the relationship between objects and classes, and by describing each
Class function definition object behavior.
In order to find objects and classes, developers want to find nouns and noun phrases in the documentation of system requirements and system analysis, including perceived
Things (car, pressure, sensor); role (mother, teacher, politician); event (landing, interruption, request); mutual effect
(Lending, meeting, intersection); personnel; place; organization; equipment; and location. Discover the important objects by browsing the script using the system
Its responsibility is an important technique for an object-oriented analysis and design process.
When important objects are discovered, the behavior of the relationships and objects between the classes are detailed through a set of interactive models, these models
Four different sides represent software architecture: static logic, dynamic logic, static physics and dynamic physics.
Static logic model description instantiation (class member relationship), association, aggregation (overall / part), and generalization (inheritance).
This is called an object model. The general relationship represents inheritance relationship between attributes and methods. The graphic symbol system defining the object model is usually used for
Data modeling entity is exported. A very important constraint for the design, such as the base (one-to-one, one-to-many, multi-to-many), also in the object
The model is represented in the model.
Dynamic logic model describes the mutual effects between objects. Mutual action through a group of synergistic objects, an orderly order of the object
Columns, participate in the visibility definition of objects to define behaviors at system runtime. Object interaction map in the Booch method is used to describe important
The mutual effect, showing the participating objects and the message to be sorted by time. The visibility map is used to describe the visible visibility of the objects in each other.
Sex. The object's visibility defines how an object is in a scope of the method of sending messages thereto. For example, it can be a method
The part of the number, local variable, new object, or object of the current method.
Static physical model describes the layout of the code through the module. Dynamic Physical Model Description Software Process and Thread Architecture.
In the following sections, we will briefly introduce the above-oriented methods and compare these methods.
*********************************************************** ********************
The process of the BOOCH method includes the following steps:
Identify classes and objects at a given abstract level
Identify the semantics of these objects and classes
Identify the relationship between these classes and objects
Implementation
These four activities are more than just a simple step sequence, but an iteration and gradual opening of the logic and physical view of the system.
Process.
The identification of classes and objects includes identifying the key abstraction and dynamic behavior of problem space. Developers can pass research
The term domain is found to be key abstraction. Semantic identification is mainly to establish the meaning of classes and objects identified by the previous stage. Developer determined
The behavior of the class (ie method) and the mutual effects between classes and objects (ie, the behavioral specification description). This phase uses a model of the state of the object to describe the state of the object, using a timing diagram (timing constraint in the system) and the object map (the mutual action between the object).
Describe the static and dynamic relationship models in the relational identification phase. These relationships include use, instantiation, inheritance, association, and aggregation. Class and
The visibility between the objects is also determined at this time.
In the implementation phase of the class and objects, consider how to use selected programming language, how to organize classes and objects into modules.
In object-oriented design methods, BOOCH emphasizes the physical logic view based on classes and objects to physics based on modules and processes.
The difference between the figure. He also distinguishes the static and dynamic model of the system. However, his method is biased towards the static description of the system, for dynamic description
Support less.
The power of the Booch method is its rich symbolic system, including:
Class map (class structure - static view)
Object map (object structure - static view)
Transfer map (class structure - dynamic view)
Times (object structure - dynamic view)
Module (module architecture)
Process diagram (process architecture)
Symbol systems for class and object modeling use annotations and different icons (such as different arrows) express detailed information. Booch suggestion
In the early stage of the design, you can use a subset of symbolics, followed by continuously adding details. There is also a text form for each symbol system,
Composed of the description template of each primary structure. The symbol system is defined by a large number of icon, but its syntax and semantics are not strictly defined.
Righteousness.
*********************************************************** ********************
Rumbaugh's OMT method is described in three perspectives, which provides three models, object models, dynamic models, and functional models accordingly. Correct
Icon model describes the static structure of the object and the relationship between them. The main concepts include:
Class
. Attributes
Operation
Inheritance
Relation (ie, relationship)
Gather
Dynamic Model Description System These main concepts have:
State
Status and super status
Incident
Behavior
Activity
Function model describes the conversion of internal data values in the system, and its main concepts are:
Machining
. data storage
. data flow
Control flow
Role (source / pool)
This method divides the development process into four stages:
1 analysis
Establish a model of real world based on problem and user needs. The products in the analysis stage are:
. Problem Description
Object model = object map data dictionary
Model = status map global event flow map
Function model = data flow diagram constraint
2 system design
Combined with the knowledge and target system of the problem (seeking the domain), decompose the target system into a subsystem.
3 object design
The system design is completed based on the implementation details added to the analysis model and the architectural structure in the quench domain. The main products include:
Object model
Dynamic model
Functional model
4 implementation
Convert design to specific programming languages or hardware while maintaining traceability, flexibility, and scalability.
*********************************************************** ********************
The COAD / YOURDON method strictly distinguishes object-oriented OOA and object-oriented design OOD. This method uses five levels and activities to define and recording system behavior, input, and output. These five levels of activities include:
Discovery class and object. Describe how to find classes and objects. Start recognition and objects from the application area, forming the basis of the entire application,
Later, accordingly, the system is responsible.
Identification structure. This phase is divided into two steps. First, identify the general - special structure, the structure captures the level of identifying classes
Constitution; second, identify the overall-part structure, which is used to indicate how an object is part of another object, and multiple objects
How to set up a larger object.
Define the topic. The subject consists of a set of classes and objects, which is used to divide the class and object models into larger units, which is convenient for understanding.
Define properties. This includes an instance connection between an instance (object) defined.
Define service. This includes a message connection between the objects.
In an object-oriented analysis phase, the result after five levels is a problem domain model divided into five levels, including theme,
Five levels of class and object, structure, attributes, and services, are represented by classes and object maps. The order of five levels is not important.
Object-oriented design models need to further distinguish four parts:
Problem section (PDC). The results of object-oriented analysis are placed directly into the portion.
Human-machine interaction part (HIC). This part of the activities include scripts that are classified by users, describe human-computer interaction, design command hierarchy,
Design detailed interaction, generate the prototype of the user interface, define the HIC class.
The activities of this part of the task management section (TMC) include identifying tasks (processes), the service provided by the task, the priority of the task,
The process is an event-driven or clock driver, and how the task is communicated with other processes and the outside world.
Data Management section (DMC). This part relies on storage technology. Is it a file system or a relational database management system, or
To the object database management system.
*********************************************************** ********************
The Jacobson method is different from the above three methods, which involves the entire software lifecycle, including demand analysis, design, implementation, and testing.
Waiting four stages. Demand analysis and design are closely related. The activities of the demand analysis phase include defining potential characters (roles refer to people using the system)
And the soft, hardware environment of the system, the identification of objects and relationships in the problem domain, based on demand specifications and roles need to be found
Use Case, described in detail using Uses. The design phase includes two main activities, discovers design objects from demand analysis models, as well as
Environmental Adjustment Design Model. The first activity includes discovering design objects from the description of the USE CASE and describes the properties of the object, behavior, and
. Here you still have to assign the behavior of the USE CASE to the object.
In activities and relationships of the identification domain objects and relationships in the demand analysis phase, developers recognize classes, attributes, and relationships. Relationships include inheritance, familiar
Read (association), constitute (aggregation) and communication associations. Define the activities of USE CASE and identify the activities of the design object, and the two activities are completed together
Description of behavior. The Jacobson method also divides the object zone into semantic objects (domain objects), interface objects (such as user interface objects) and control
Objects (control between interface objects and domain objects).
One key concept in this method is USE Case. Use case refers to behavioral-related transactions (Transaction) sequences,
The sequence will be executed by the user in a dialogue with the system. Therefore, each USE CASE is a way of using the system. When the user gives an input, execute an instance of a USE CASE and triggers an transaction that belongs to this USE CASE. Based on this system view, Jacobson will
The USE Case model is associated with other five system models:
Field object model. The USE Case model is represented according to the field.
Analysis model. The USE Case model is constructed by analysis.
Design model. The USE Case model is embodied by design.
Implement model. This model implements the USE Case model based on the specific design.
Test model. Used to test the US Case model.
*********************************************************** ********************
