The life cycle that software development experiences
Overall, software development goes through life cycle
- Analyze requirements: Analyze problem areas to understand user needs
- Software Design: The overall architecture of the design software, the entire software system is divided into large and small subsystems, design the specific structure of each subsystem
- Software Coding: Write software functions in selected programming languages and implement software blueprint outlined in software design phase
- Software Testing: Test whether the software implements specific functions and the performance of the software
- Software deployment: Install software system for users, help users to use the software correctly
- Software maintenance: Fix bugs in the software, modify the software module when the user's needs change (add new features, or change the way existing features are implemented)
In order to improve the efficiency of software development and reduce the cost of software development, a good software system should have the following characteristics
- Reusability: Reduce duplication of code in software and avoid repetitive programming
- Scalability: When the requirements of a software system must be changed, it is convenient to build a new subsystem on the basis of the existing architecture, without changing the existing structure of the software system without affecting other subsystems that exist.
- Maintainability: When a feature of a software system needs to be changed, only a small amount of code from the relevant subsystem can be modified without modifying multiple subsystems in the software system.
How can the software system have the above characteristics? Join it. The whole software system is decomposed into several small subsystems, and each subsystem is relatively independent to assemble these subsystems as flexible as the most bricks to form the whole large software system. This design of the software will certainly be able to obtain the above excellent characteristics. Subsystems in a software system have the following features:
- Structural Stability: When the software design stage divides a software system into smaller subsystems, the design is reasonable, and the structure of the system is robust and adaptable to the needs of the user's change.
- Extensibility: When the software has to add or subtract new functions, it can create a new subsystem on the basis of the existing subsystem, which inherits some characteristics of the original subsystem, and also has some new features, thus improving the reusability and expansibility of the system.
- Cohesion: Each subsystem only completes specific functions, and each subsystem does not overlap function
- Composable: A number of small subsystems together become a complete large system, the composable of subsystems will improve the maintainability and reusability of software and simplify the development process
- Loose coupling: Each subsystem is relatively independent, and modifying a subsystem does not affect other subsystems.
Object-oriented development:
In the object-oriented development method, the software system is regarded as a collection of objects, the object is the smallest subsystem, and a group of related objects can be combined into more complex subsystems. The object-oriented development approach has the following advantages
- The software system is a collection of objects, which is more in line with the natural way of thinking of human
- Software requirements change is often a function of the change, and the function of the performer ———— objects generally do not have much change this makes the system structure according to the object design is relatively stable
- Objects include attributes (data) and behaviors (methods) that encapsulate the implementation of the object's data and methods, which makes the method and the data associated with it no longer separate, improving the relative independence of the subsystem, thereby improving the maintainability of the software
- Supports encapsulation, inheritance, polymorphism, and abstraction for improved system reusability, maintainability, and scalability
Object Model:
In the object-oriented analysis and design phase, the object model of the simulation problem domain is set up, and the object model includes the bottom-up abstraction process and the top-down decomposition of the festive process.
The first step in building the object model is to start with the problem domain, thoroughly understand the user's needs, and then set up the correct object model, and the developers need to do a little self-thinking.
- The properties and behaviors of the problem domain are abstracted into concrete objects.
- Abstract objects with the same properties and behaviors into classes
- If there are commonalities in multiple classes (with the same attributes and behaviors), abstract these commonalities into the parent class
In the bottom-up abstraction process, a top-down modification may be required in order for subclasses to better inherit the properties and behavior of the parent class, making the class system more reasonable. Because the structure of this kind of system is from concrete to abstract, then from abstract to concrete, accord with human thought law, so can accomplish task better and faster.
An overview of object-oriented software development methods
