Object Oriented Software Engineering
Object-oriented programming is an evolutionary development in software engineering. The foundation for many object-oriented languages were established by decades of software engineering experience that motivated the invention of language features such as closed. Advanced Software Engineering Object Oriented is a popular design approach for analyzing and designing an application. Most of the languages like C. Object Oriented Software Engineering Practical Software Development using UML and Java. Download with Google Download with Facebook. Create a free account to download. Download PDF Package. Premium PDF Package. Download Full PDF Package.
- Object-oriented Software Engineering By Bernd Bruegge
- Object-oriented Software Engineering Lecture Notes
- OOAD Tutorial
- OOAD Useful Resources
- Selected Reading
We know that the Object-Oriented Modelling (OOM) technique visualizes things in an application by using models organized around objects. Any software development approach goes through the following stages −
- Analysis,
- Design, and
- Implementation.
In object-oriented software engineering, the software developer identifies and organizes the application in terms of object-oriented concepts, prior to their final representation in any specific programming language or software tools.
Phases in Object-Oriented Software Development
The major phases of software development using object–oriented methodology are object-oriented analysis, object-oriented design, and object-oriented implementation.
Object–Oriented Analysis
In this stage, the problem is formulated, user requirements are identified, and then a model is built based upon real–world objects. The analysis produces models on how the desired system should function and how it must be developed. The models do not include any implementation details so that it can be understood and examined by any non–technical application expert.
Object–Oriented Design
Object-oriented design includes two main stages, namely, system design and object design.
System Design
In this stage, the complete architecture of the desired system is designed. The system is conceived as a set of interacting subsystems that in turn is composed of a hierarchy of interacting objects, grouped into classes. System design is done according to both the system analysis model and the proposed system architecture. Here, the emphasis is on the objects comprising the system rather than the processes in the system.
Object Design
In this phase, a design model is developed based on both the models developed in the system analysis phase and the architecture designed in the system design phase. All the classes required are identified. The designer decides whether −
- new classes are to be created from scratch,
- any existing classes can be used in their original form, or
- new classes should be inherited from the existing classes.
The associations between the identified classes are established and the hierarchies of classes are identified. Besides, the developer designs the internal details of the classes and their associations, i.e., the data structure for each attribute and the algorithms for the operations.
Object–Oriented Implementation and Testing
In this stage, the design model developed in the object design is translated into code in an appropriate programming language or software tool. The databases are created and the specific hardware requirements are ascertained. Once the code is in shape, it is tested using specialized techniques to identify and remove the errors in the code.
1.7 Object-Oriented Programming and Software Engineering
Object-oriented programming is an evolutionary development in softwareengineering. The foundation for many object-oriented languages wereestablished by decades of software engineering experience thatmotivated the invention of language features such as closedprocedures, modules and abstract data types. Also important were thewidely recognized value of such software engineering techniques asinformation hiding, encapsulation, strict enforcement of interfaces,and layering.
Object-oriented programming address (at least) the three majorsoftware engineering goals shown in this figure:
The language features that address these issues are those of objects,classes, inheritance, polymorphism, templates, and design patterns.
Reusability is an important issue in software engineering for at leasttwo major reasons. First reusability is one means to cope with thepressures of producing ever larger and more functional systems in anever decreasing development cycle (time to market). Reusability allowsdevelopers to be more efficient because the same code can be developedonce and used in many different applications. Second, reliability canbe improved by reusing previously developed, and previously tested,components. The development of new code entails the additional costsin time and money of testing, validation, and verification of the newcode. Much of these expenses can be avoided by using 'off-the-shelf'components.
Software reuse is certainly not a goal unique to object-orientedprogramming. While libraries of procedures proved this approach to beuseful, in practice procedures were too primitive a unit to promoteextensive reuse. Objects and classes are more sophisticated mechanismsfor achieving software reuse because they bind together morecompletely all the aspects of an entire abstraction. Therefore, theabstraction can more easily be transported across applications. Any ofthe forms of generalization also contribute to reuse. A class in aninheritance hierarchy can be reused directly when it serves as ageneralized base class from which a new class is derived byspecialization. Templates can be reused by supplying differentparameters for the template arguments. Design patterns allow designexperience and success to be reused across designers.
Extensibility in software is important because software systems arelong-lived and are subject to user's demands for new features andadded capability. Object-oriented programming can help to satisfythis need through inheritance. Recall that inheritance is ageneralization/specialization hierarchy. Referring to the Windowhierarchy discussed earlier, extensibility is possible in twoways. The first way in which a generalization/specialization hierarchysupports extensibility is that any new attributes or behavior that isadded to a more generalized concept (e.g., Window) will automaticallybecome part of the attributes and behavior of its specializations(e.g., Frame, Item, Button). For example, as shown below, if theWindow abstraction is enhanced to include a color with which theWindow would be displayed on the screen, then the attribute'currentColor' and the behavior 'setColor' might be added toWindow. It would then be possible to manipulate the color of a Windowbut all its specializations as well.
The second way in which a generalization/specialization hierarchysupports extensibility is that the hierarchy itself can beextended. New additions can be made under any existing node. Forexample, as shown below, the TextWindow might be specialized to aHyperTextWindow by including additional attributes and additionalbehavior that distinguishes ordinary words from those words that arehyperlink and can be clicked-on to transfer to another place in thetext.
Flexibility in software systems means, in part, that additions, variations ormodification can be made without the need to modify numerous placesin the system's code. Historically, many software systems were verybrittle in that the addition of a small change could only beaccomodated by making modifications in many, and often aparrentlyunrelated, parts of the existing system. This brittle property stoodin marked contrast to the prevaling notion that, nlike hardwaresystems, software system were supposed to be extremelymaleable and changes can be made easily.
Object-oriented Software Engineering By Bernd Bruegge
Object-oriented programming contributes to flexibility in twoways. First, the separation of an interface from its implementationallows the user of the interface to remain unaffected by changes inthe implementation. Thus, a modification can be made to theimplementation (e.g., to improve its efficiency or reliability)without requiring any changes in the code that uses theinterface. Second, polymorphism allows variations and additions to bemade to the set of classes over which the polymorphism applies. Forexample, referring to the Window hierarchy, consider adding a new kindof interaction Item, a RadioButton. Since Items can be placed in aPanel, it would seem necessary to modify the Panel to allow a Panel tomanipulate the newly created RadioButton. However, the Panel can usepolymorphism so that the Panel's algorithms only rely on the moregeneral attributes and behavior of an object (i.e., that it is a kindof Item) and does not need to be aware of the exact 'type' (i.e.,RadiButton) of the object. Using this approach, the Panel can bedesigned to operate on Items. Any newly created Item, even one - likethe RadioButton - that is created after the Panel is already written,automatically can be manipulated by a Panel without changing the codeof the Panel.
Object-oriented Software Engineering Lecture Notes
|