2. UML Applied - Object Oriented Analysis and Design using the UML This conceptual model will provide us with the foundations of the design. We then. Fundamentals of Object-Oriented Design in UML [Meilir Page-Jones] on site. com. *FREE* shipping on qualifying offers. Object technology is increasingly. Based in Bellevue, Washington,. Meilir Page-Jones is president and senior consulting methodolo- gist at Wayland Systems. He has extensive experience in .

Fundamentals Of Object-oriented Design In Uml Pdf

Language:English, French, Japanese
Genre:Personal Growth
Published (Last):12.03.2015
ePub File Size:24.31 MB
PDF File Size:12.42 MB
Distribution:Free* [*Sign up for free]
Uploaded by: HIEDI

OBJECT ORIENTED PROGRAMMING PRINCIPLES. Francis MK. JOMO KENYATTA UNIVERSITY OF AGRICULTURE AND TECHNOLOGY INSTITUTE OF. Object-Oriented Analysis & Design Using UML. Object-Oriented Analysis Fundamentals of Object-Oriented Design in UML. Addison-Wesley,. Reading, MA . Summary. Exercises. 2 Object-Oriented Analysis and Design. Fundamentals of an OOAD. A lightweight process.

Concrete class class that can be instantiated. Navigation arrows may be bidirectional. Usually a manual process done in a brainstorming session 3 X 5 note cards One card per class Front has responsibilities and collaborations Back has attributes needed 31 Example of CRC card 32 CRC cards procedure Because the process is to design, or realize, a single use case, start with a set of unused CRC cards.

Add a controller class Controller design pattern. Identify a problem domain class that has primary responsibility for this use case that will receive the first message from the use case controller.


For example, a Customer object for new sale. Use the first cut design class diagram to identify other classes that must collaborate with the primary object class to complete the use case.

Have use case descriptions and SSDs handy 33 CRC card procedure 2 Start with the class that gets the first message from the controller. Name the responsibility and write it on card. download this product.

This product is part of the following series. Click on a series title to see the full list of products in the series. To the barricades: Forward to the past: A brief digression: Design criteria governing interacting levels of encapsulation. The class invariant as a restriction on a state-space. A graphic illustration of contravariance and covariance.

Pearson offers special pricing when you package your text with other student resources. If you're interested in creating a cost-saving package for your students, contact your Pearson rep. Meilir Page-Jones is President and Senior Consulting Methodologist at Wayland Systems, and has extensive experience in training, consulting, and hands-on system development. The plausibility of this view will be considered in more detail in Section 2.

The purpose of this book is to explain the modeling concepts used by object-oriented methods, and to show how models can be expressed in the notation defined by UML. The focus of the book is on design and the use of design models in the development of software, but the same modeling concepts apply equally well to the production of analysis models. Analysis is a skill distinct from design, and there is much to learn about the techniques for carrying it out effectively, but the resulting analysis models can be perfectly well expressed using the notation presented in this book.

In most cases the complexity of the problem to be solved requires that intermediate development steps are taken, and that a number of abstract models of the program structure are produced.

These points apply equally well to developments involving Only One programmer and to conventional team developments. Over the years, many different strategies for developing software have been tried out, and those that have been found particularly successful or widely applicable have been formalized and published as methodologies. In software engineering circles, the term 'methodology' is often used or misused simply to mean a suggested strategy or method for developing software systems.

Diagrams such as Figures 1. A description of an industrial-strength methodology, however, would be a great deal more complicated than either of those diagrams. Methodologies usually offer guidance on at least two important aspects of software development. Firstly, a methodology defines a number of models that can be used to help design a system.

As explained in the previous section, a model describes a particular aspect of a system at an abstract level, and therefore enables discussions of the design of the system to proceed at a high level without becoming involved too soon in details of coding. A methodology will also define a set of formal notations in which the recommended models can be written down and documented. Often these formal notations are graphical, thus giving rise to the wide use of diagrams in software development.

The models together with the notation in which the models are documented are sometimes referred to as the language defined by the methodology. As well as defining a language, a methodology imposes some constraints on the order in which things must be done in the course of a development.

These constraints are implied by the arrows in Figures 1. The process defined by a methodology is often defined much less formally than the language, and usually a large amount of flexibility is envisaged, allowing the methodology to be used in a wide variety of situations, for applications with differing requirements, and even with programmers who may be disinclined to design a program before writing it. The process defined by a methodology can be thought of as defining an outline schedule or plan for a project.

Each stage in such a process defines a particular 'deliverable work product', and the forms of these deliverables are usually specified by the language of the methodology.

Although this approach can be taken to extremes, it is clear that as well as helping in the technical aspects of software development, the use of a methodology can be of great assistance in project management. Classification of methodologies Great similarities can be observed among many published methodologies, and based on these it is possible to group methodologies into a number of broad classes.

The similarities arise from the fact that different methodologies can be based on a common understanding of how to describe the underlying structure of software systems. As a result, related methodologies will often recommend the use of very similar models in development. Sometimes, of course, the relationship between two models can be obscured by the fact that different notation is used for them- These surface differences can hide but do not remove the underlying structural similarities.

A well-known example of a class of methodologies is the so-called structured methods, including structured analysis, structured design and their many variants. The characteristic model used by these methodologies is the data flow diagram, which illustrates how data is passed between the different processes in a system. Structured methods picture a software system as being made up of a collection of data which can be processed by a number of functions external to the data.

These methodologies are particularly appropriate for the design of data rich systems, and are often used in the development of systems destined for implementation on relational databases.

A different class of methodologies consists of those described as object-oriented. Although there are similarities between the notation used in some object-oriented and structured methodologies, the object-oriented methods are based on a completely different understanding of the basic structure of software systems. This understanding is embodied in the object model described in Chapter 2. Although notational details differ widely, there is a high level of agreement among different object-oriented methodologies about the kinds of model that can usefully be applied when carrying out an object-oriented development.

Because of this, it is quite possible to talk about object-oriented design in a generic manner, without being constrained by the definitions of one methodology. It is important to use a consistent and clearly defined notation, however, and in this book that of the Unified Modeling Language will be used. The three principal designers of UML had each previously published their own methods, and the explicit purpose of UML was to integrate the insights of these three methods.

This integration was aided by the common framework, in the form of the object model, shared by the original methods, and also no doubt by the fact that the three individuals concerned ended up working for the same company. Because of its impressive pedigree, and assisted by its adoption as a standard by the Object Management Group, UML generated a lot of interest i n the software industry even before its publication in a definitive form, and it can be expected to be the dominant language used in object-oriented modeling for the foreseeable future, UML marks a significant departure from earlier methodologies in clearly and explicitly differentiating the language used to document a software design from the process used lo produce it.

As its name states, UML defines a language only, and as such provides no description or recommendations relating to the process of development, This eminently sensible approach recognizes that there is very little consensus in the software industry about process, and a growing recognition that the choice of process is crucially affected by the nature of the product and the environment in which the development will take place, UML is intended to be a well-defined language which can be productively used with a wide range of different processes.

The remainder of this section discusses some of the basic high-level concepts of UML, and describes the ways in which UML classifies models and presents them to software developers. As this figure clearly indicates, the model gets its name from the fact that a system's structure is described in five views, one of which, the use case view, has a special role to play in integrating the contents of the other four views.

Rattier, each view corresponds to a particular perspective from which the system can be examined. Different views highlight different aspects of the system which are of interest to particular groups of stake holders.

A complete model of the system can be formed by merging the information found in all five views, but for particular purposes it may be sufficient lo consider only the information contained in a subset of the views. The use case view defines the system's external behavior and is of interest to end users, analysts and testers. This view defines the requirements of the system, and therefore constrains all the other views, which describe certain aspects of the system's design or construction.

This is why the use case view has a central role and is often said to drive the development process. The design view describes the logical structures which support the functional requirements expressed in the use case view. It consists of definitions of program components, principally classes, together with specifications of the data they hold, and their behavior and interactions.

The information contained in this view is of particular interest to programmers, as the details of how the system's functionality will be implemented are described in this view. The implementation view describes the physical components out of which the system is to be constructed. These are distinct from me logical components described in the design view, and include such things as executable files, libraries of code and databases.

The information contained in this view is relevant to activities such as configuration management and system integration. The process view deals with issues of concurrency within the system, and the deployment view describes how physical components are distributed across the physical environment, such as a network of computers, that the system runs in.

These two views address non-functional requirements of the system such as fault-tolerance and performance issues.

The process and deployment views are relatively undeveloped in UML, compared in particular with the design view which contains much of the notation that would informally be thought of as design-related. Models A model in UML terms is defined as a 'semantically closed abstraction of a system'.

Chapter 10 Object-Oriented Design Principles

This means that a model should be complete in the sense that the entire system is covered by the model.

However, a model is an abstraction, so not every detail of the system need be included in every model. Different models of a system may be produced at different levels of abstraction. For example, as explained in Section 1. It then becomes important to define the relationship between these models, and to ensure their mutual consistency. Model elements Models are composed of model elements.

These are the 'atoms' of modeling, and UML defines a wide range of different types of model element, including such familiar concepts as classes, operations and function calls, A model is a structure built up of a number of interrelated model elements.

If a CASE tool is being used to support development, it will maintain a database storing all the information that has been declared about the model elements known to the system. The sum total of this information, the entire contents of the database, makes up a complete model of the system.

Diagrams A model is normally presented to a designer as a set of diagrams. Diagrams are graphical representations of collections of model elements. Different types of diagram present different information, typically about either the structure or behavior of the model elements they depict.

Each diagram type has rules staling what kinds of model elements can appear in diagrams of that type, and how they are to be shown. UML defines nine distinct diagram types, which are listed in Table 1.

When learning UML it is natural to place emphasis on learning the details of the various types of diagram. Conceptually, however, a diagram should be thought of as simply presenting to the user certain aspects of the underlying system model. If a CASE tool is being used, for example, a diagram provides a convenient way of examining some of the information stored in its database. Table 1. Graphical notations are rather limited, however, in terms of what they can easily express, so it is common to supplement UML with a textual specification language such as the Object Constraint Language, which is described in Chapter 9.

UML design diagrams are also documents which specify a system, but ones which may not be able to be directly translated into executable code.

Source code and design diagrams therefore share the properly of specifying aspects of a desired system, but they differ in expressing this at different levels of abstraction. Almost by definition, a program gives a complete description of a system: the code that executes is simply a translation of what is defined in the source code of the system.

Design models, on the other hand, omit much of the detail that is found in code, and in particular much procedural detail. However, it is not unreasonable to view a source program as being simply a very concrete design model, as the purpose and nature of the two types of artifact are very similar. This point is particularly clear in the case of object-oriented languages, in which much program structure is expressed using exactly the same concepts as appear in object-oriented design languages. Programs, then, define the run-time properties of executing systems.

When writing a program, programmers often try to visualize the behavior of the code they are writing by thinking of the effects that their program will have when it runs. However, it is unusual for programmers to think in terms of the raw addresses and binary data that is being manipulated by the machine. Instead, they tend to work with an abstract model of what is happening when a program runs. In particular, programmers in object-oriented languages tend to use abstract models of program execution which talk in terms of objects being created and destroyed as a program runs, and objects knowing about other objects and being able to communicate with them.

These subtract models are called object structures in Figure 1. The arrow on the right-hand side of the diagram shows that object structures are abstractions of what really happens when a program runs, in the same sort of way as a design diagram is an abstraction of the information contained in a source program, The significance of all this is that object structures, the abstract models that we use lo understand programs, are also used as a semantic foundation for UML's design models, as indicated by the top arrow in Figure 1.

It also means that UML can largely be understood in terms of concepts which are familiar from programming. Two conclusions can be drawn from this discussion. Firstly, the diagrams defined in a language such as UML are not just pictures, but have a definite meaning in terms of what they specify about the run-time properties of systems.

In this respect, diagrams are just like programs, but more abstract. Secondly, the model that is used for explaining the meaning of UML notations is very similar to the models that object-oriented programmers use to help them visualize the behavior of the programs they are writing.

Thus UML and object-oriented languages have the same semantic foundations, which means that it is relatively easy to implement a design, or conversely to document an existing program, with some confidence that the two representations of the system are consistent. Chapter 2 describes the object model in detail, shows ways of defining object structures in UML, and explains how diagrams can be used to visualize the properties of programs.

Traditionally, a linear or 'waterfall' model of the software development process has been proposed. In such a model, activ ities are carried out in order, and the results of one stage are carried forward to serve as the starting point for work in the following stage.

A small example of this is the characterization of analysis and design 'phases' that was discussed in Section 1. In much of the literature on object-oriented design, however, the assumption of an underlying linear process is contradicted by the recognition that system development very often actually proceeds in an iterative manner.

This means that it is acknowledged that earlier steps in the process must be revisited when the work done there needs to be corrected or modified. An iterative model allows a welcome and necessary degree of flexibility to enter the software development process, and is a more accurate reflection of the way much software is in fact developed. On the other hand, changing a piece of work that was completed at an earlier stage in the process can cause changes to cascade throughout the entire project, and in general the earlier in the process the initial change is made, the greater the knock-on effects will be.

Considerations like this might suggest that linear software development processes should be followed wherever possible. Empirical research suggests, however, that except in very simple or well understood cases, systems are never developed by progressing through a simple sequence of steps such as those outlined above.

Related titles

One prominent reason for this is that a linear process assumes that a system's requirements are fixed and do not change throughout the development process. This is a very unrealistic assumption. In many cases, system development starts without a clear idea of what the system should do. This can either be because the users do not clearly understand what they want, or because a completely new type of product is being developed. Worse still, the experience of seeing a system take shape often suggests many other ways in which the system could be used, thus generating new requirements, In this way, the very process of developing a system often causes instability in he requirements.

Another factor undermining the linear development process is the fact that software design is still a rather experimental activity. Design decisions are often taken without a full understanding of the effect that they will have on subsequent development, and it is inevitable that in some cases decisions will turn out to have been mistaken. In these cases it is necessary to be able to backtrack, and to explore the possibility of alternative approaches, something that is not allowed for in strictly linear models.

In practice, then, systems are rarely developed according to the strict linear process specified by traditional design methodologies. There will always be iteration in the process, where earlier stages in the work, right back to the requirements, are revisited and altered or corrected later in the development.

Some writers have taken this further, and suggested that software should be developed In an evolutionary or incremental manner, where certain core functionality is implemented initially, and a complete system is gradually 'grown' by adding more and more functionality to it until a complete implementation is obtained.

It has even been suggested that every project needs a unique development process defined for it.

Nevertheless, when a completed system is being documented there are strong reasons for pretending that a linear process has been followed. Documentation of a system should concentrate on describing the structure of what has been produced in such a way someone new to the system can quickly come to understand its functionality, its design, and the rationale for the various design decisions that were made.

In such a description it can be very helpful to present first the requirements, then the system's architecture, and then the details of its implementation in a manner very reminiscent of the traditional stages of the life cycle.

In the case studies and examples presented in this book, this style of presentation will be used, even though it is very far from being an accurate reflection of how the programs were in fact developed. This normally implies the production of models to help understand the structure and design of the system.

Methodologies define both a language and a process. The language defines the models to be used and the notation for expressing them. The process states what order to produce the models in. UML is a language for expressing object-oriented design models, It is not a complete methodology, though its authors consider it to be suitable for use with an iterative and incremental development process, UML defines a number of views of a system, which represent properties of the system from various perspectives and relative to various purposes.

Information contained in a model is communicated in graphical form, using various types of diagram Design models and source code share a common semantic foundation, the object model. This ensures that it is possible to maintain a close relationship between the design and the code of a system.

Does the same answer hold for programming languages? Can you identify any common features of the tasks you have identified as being most suitable for graphical support? Does the activity of software design share these features? The object model is the common computational model shared by UML and object-oriented programming languages. Programming and design languages express facts about programs at different levels of abstraction, but our understanding of both types of language is based on the abstract description of running programs provided by this model.

This chapter describes the essential features of the object model, introducing them in the context of a simple application.

The notation provided by UML for illustrating these concepts is presented, and the chapter also illustrates how they can be implemented, thus making clear the close connections between design and programming languages. As the name suggests, the object model assess that the best way to understand an executing program is as a collection of objects. Individual objects are responsible for maintaining part of a system's data and also for implementing aspects of its overall functionality.

At the very least, objects will contain functions to access and update the data that they contain. Objects therefore combine two fundamental aspects of computer programs, namely data and processing, that are often kept separate in other approaches to software design.

Objects tend to be highly dynamic: as a system evolves and the data stored fry the system changes, objects are frequently created and destroyed to reflect these alterations. An individual object only implements a small fragment of a system's functionality. The global behavior of the system is generated by the interaction of a number of distinct objects. The objects in a system must therefore be linked together in such a way as to permit communication between them. By means of this interaction, objects can cooperate to support behavior that transcends the data or processing capabilities of individual objects.

In summary, then, the underlying approach to software proposed by the object model is to view an executing object-oriented program as being a dynamic network of intercommunicating objects. A program is thought of as a graph, or network, whose structure can change from moment to moment.

Objects form the nodes in this graph, and the arcs connecting the objects are known as links. The objects are discrete packages comprising a small subset of the program's data, together with the functions which operate on that data.

Objects can be created and destroyed at run-time, and the topology of the object network can also be changed at run-time. The structure of the network is therefore dynamic. The links between objects also serve as communication paths which enable objects to interact by sending messages to other objects.

Messages are analogous to function calls: they are requests to the receiving object to carry out some operation, and can be accompanied by data parameterzing the message. In this way, computation can take place in the network. The role of the object model The object model provides the semantic foundation for UML's design models. The meaning of any design construct or notation in UML can be explained by rephrasing it in terms of assertions about a set of connected and intercommunicating objects.

Static models describe the kinds of connections that can exist between objects and the possible topologies the resulting object network can have. Dynamic models describe the messages that can be passed between objects and the effect that receiving a message has on an object. At the same time, the object model provides a very natural way of thinking about the run-lime properties of object-oriented programs.

A 'network of objects' is only a slight abstraction of a computer's memory in which objects occupy memory at certain addresses and can store references to other objects that are also in memory. This dual role of the object model establishes a direct link between UML design notations and actual programs, and explains why UML is a suitable language for designing and documenting the design of object-oriented programs.

A stock control example In manufacturing environments a common requirement is to keep track of the stock of parts held, and the way in which these parts are used. In this chapter we will illustrate the object model with a simple program which models different kinds of parts and the ways in which these parts are used to construct assemblies of arbitrary complexity. The program will have to manage information describing the different kinds of part known to the system.

This son of information might be available in a firm's catalogue, for example. For the purposes of this example, we will assume that we are interested in the following three pieces of information about each part, 1. Its catalogue reference number an integer.UML is a language for expressing object-oriented design models, It is not a complete methodology, though its authors consider it to be suitable for use with an iterative and incremental development process, UML defines a number of views of a system, which represent properties of the system from various perspectives and relative to various purposes.

These articles encompass the development, refinement, and current state of OMT, Computers Jun 27, - Jim Arlow, Ila Neustadt - "This book manages to convey the practical use of UML 2 in clear and understandable terms with many examples and guidelines. Inheritance, Abstraction, encapsulation and polymorphism. Part objects no longer hold any data.

Although this approach can be taken to extremes, it is clear that as well as helping in the technical aspects of software development, the use of a methodology can be of great assistance in project management. Readings are taken and transcribed onto the printer every five minutes. Polymorphism plays an important role in allowing objects having different internal structures to share the same external interface.

WENDOLYN from Bonita Springs
I do like reading comics kiddingly. Look over my other posts. I absolutely love cestoball.