Object-oriented design is the process of planning a system of interacting objects for the purpose of solving a software problem. It is one approach to software design.

• 2Object-oriented design topics

Overview[edit]

You want to understand object-oriented programming, it is more important to first master the techniques and consider your options in code design; dependence on somebody else’s library for your developments should come a bit later. An important part of this book is the enclosed source floppy — it has a DOS file. Object Oriented Design Cheat Sheet from david. A handy guide to the basic principles of Object Oriented Programming and Design. Covers standard and accepted principles, design patterns, and more! This is not intended to teach OOP, but as a reminder for those who already learned.

An object contains encapsulated data and procedures grouped together to represent an entity. The 'object interface' defines how the object can be interacted with. An object-oriented program is described by the interaction of these objects. Object-oriented design is the discipline of defining the objects and their interactions to solve a problem that was identified and documented during object-oriented analysis.

What follows is a description of the class-based subset of object-oriented design, which does not include object prototype-based approaches where objects are not typically obtained by instantiating classes but by cloning other (prototype) objects.Object-oriented design is a method of design encompassing the process of object-oriented decomposition and a notation for depicting both logical and physical as well as state and dynamic models of the system under design.

Object Oriented Modeling and Design usung UML INTRODUCTION. An overview - Object basics - Object state and properties, Behavior, Methods, Messages. Object Oriented system development life cycle. Benefits of OO Methodology. Overview of Prominent OO Methodologies: a. The Rumbaugh OMT. The Booch methodology. Originally published with c and smaltalk code samples, design patterns are very popular in Java and C# can be applied in all object oriented languanges. In functional languages like Scala, certain patterns are not necesary anymore. Creational Design Patterns. Practical Object-Oriented Design, An Agile Primer Using Ruby (POODR) is a programmers tale about how to write object-oriented code. Written by Sandi Metz, it explains object-oriented design (OOD) using realistic, understandable examples.POODR. is a practical, readable introduction to how OOD can lower your costs and improve your applications. OOAD Tutorial in PDF. Previous Page. Preview Object Oriented Analysis Design Tutorial (PDF Version) Buy Now $ 9.99. Buy Now Rs 649.

Object-oriented design topics[edit]

Input (sources) for object-oriented design[edit]

The input for object-oriented design is provided by the output of object-oriented analysis. Realize that an output artifact does not need to be completely developed to serve as input of object-oriented design; analysis and design may occur in parallel, and in practice the results of one activity can feed the other in a short feedback cycle through an iterative process. Both analysis and design can be performed incrementally, and the artifacts can be continuously grown instead of completely developed in one shot.

Some typical input artifacts for object-oriented design are:

• Conceptual model: The result of object-oriented analysis, it captures concepts in the problem domain. The conceptual model is explicitly chosen to be independent of implementation details, such as concurrency or data storage.
• Use case: A description of sequences of events that, taken together, lead to a system doing something useful. Each use case provides one or more scenarios that convey how the system should interact with the users called actors to achieve a specific business goal or function. Use case actors may be end users or other systems. In many circumstances use cases are further elaborated into use case diagrams. Use case diagrams are used to identify the actor (users or other systems) and the processes they perform.
• System sequence diagram: A system sequence diagrams (SSD) is a picture that shows, for a particular scenario of a use case, the events that external actors generate, their order, and possible inter-system events.
• User interface documentations (if applicable): Document that shows and describes the look and feel of the end product's user interface. It is not mandatory to have this, but it helps to visualize the end-product and therefore helps the designer.
• Relational data model (if applicable): A data model is an abstract model that describes how data is represented and used. If an object database is not used, the relational data model should usually be created before the design, since the strategy chosen for object-relational mapping is an output of the OO design process. However, it is possible to develop the relational data model and the object-oriented design artifacts in parallel, and the growth of an artifact can stimulate the refinement of other artifacts.

Object-oriented concepts[edit]

The five basic concepts of object-oriented design are the implementation level features that are built into the programming language. These features are often referred to by these common names:

• Object/Class: A tight coupling or association of data structures with the methods or functions that act on the data. This is called a class, or object (an object is created based on a class). Each object serves a separate function. It is defined by its properties, what it is and what it can do. An object can be part of a class, which is a set of objects that are similar.
• Information hiding: The ability to protect some components of the object from external entities. This is realized by language keywords to enable a variable to be declared as private or protected to the owning class.
• Inheritance: The ability for a class to extend or override functionality of another class. The so-called subclass has a whole section that is derived (inherited) from the superclass and then it has its own set of functions and data.
• Interface (object-oriented programming): The ability to defer the implementation of a method. The ability to define the functions or methods signatures without implementing them.
• Polymorphism (specifically, Subtyping): The ability to replace an object with its subobjects. The ability of an object-variable to contain, not only that object, but also all of its subobjects.

Designing concepts[edit]

• Defining objects, creating class diagram from conceptual diagram: Usually map entity to class.
• Identifying attributes.
• Use design patterns (if applicable): A design pattern is not a finished design, it is a description of a solution to a common problem, in a context.^[1] The main advantage of using a design pattern is that it can be reused in multiple applications. It can also be thought of as a template for how to solve a problem that can be used in many different situations and/or applications. Object-oriented design patterns typically show relationships and interactions between classes or objects, without specifying the final application classes or objects that are involved.
• Define application framework (if applicable): Application framework is usually a set of libraries or classes that are used to implement the standard structure of an application for a specific operating system. By bundling a large amount of reusable code into a framework, much time is saved for the developer, since he/she is saved the task of rewriting large amounts of standard code for each new application that is developed.
• Identify persistent objects/data (if applicable): Identify objects that have to last longer than a single runtime of the application. If a relational database is used, design the object relation mapping.
• Identify and define remote objects (if applicable).

Output (deliverables) of object-oriented design[edit]

• Sequence diagram: Extend the system sequence diagram to add specific objects that handle the system events.

A sequence diagram shows, as parallel vertical lines, different processes or objects that live simultaneously, and, as horizontal arrows, the messages exchanged between them, in the order in which they occur.

• Class diagram: A class diagram is a type of static structure UML diagram that describes the structure of a system by showing the system's classes, their attributes, and the relationships between the classes. The messages and classes identified through the development of the sequence diagrams can serve as input to the automatic generation of the global class diagram of the system.

Some design principles and strategies[edit]

• Dependency injection: The basic idea is that if an object depends upon having an instance of some other object then the needed object is 'injected' into the dependent object; for example, being passed a database connection as an argument to the constructor instead of creating one internally.
• Acyclic dependencies principle: The dependency graph of packages or components (the granularity depends on the scope of work for one developer) should have no cycles. This is also referred to as having a directed acyclic graph.^[2] For example, package C depends on package B, which depends on package A. If package A also depended on package C, then you would have a cycle.
• Composite reuse principle: Favor polymorphic composition of objects over inheritance.^[1]

See also[edit]

References[edit]

1. ^ ^abDesign Patterns: Elements of Reusable Object-Oriented Software. Addison-Wesley. 1995. ISBN0-201-63361-2.
2. ^'What Is Object-Oriented Design?'. Object Mentor. Retrieved 2007-07-03.

External links[edit]

• Object-Oriented Analysis & Design - overview using UML
• LePUS3 and Class-Z: formal modelling languages for object-oriented design

Object-oriented analysis and design (OOAD) is a popular technical approach for analyzing and designing an application, system, or business by applying object-oriented programming, as well as using visual modeling throughout the development life cycles to faster better stakeholder communication and product quality.

Object Oriented Design Tutorial Pdf

According to the popular guide Unified Process, OOAD in modern software engineering is best conducted in an iterative and incremental way. Iteration by iteration, the outputs of OOAD activities, analysis models for OOA and design models for OOD respectively, will be refined and evolve continuously driven by key factors like risks and business value.

History[edit]

In the early days of object-oriented technology before the mid-1990s, there were many different competing methodologies for software development and object-oriented modeling, often tied to specific Computer Aided Software Engineering (CASE) tool vendors. No standard notations, consistent terms and process guides were the major concerns at the time, which degraded communication efficiency and lengthened learning curves.

Some of the well-known early object-oriented methodologies were from and inspired by gurus such as Grady Booch, James Rumbaugh, Ivar Jacobson (the Three Amigos), Robert Martin, Peter Coad, Sally Shlaer, Stephen Mellor, and Rebecca Wirfs-Brock.

In 1994, the Three Amigos of Rational Software started working together to develop the Unified Modeling Language (UML). Later, together with Philippe Kruchten and Walker Royce (eldest son of Winston Royce), they have led a successful mission to merge their own methodologies, OMT, OOSE and Booch method, with various insights and experiences from other industry leaders into the Rational Unified Process (RUP), a comprehensive iterative and incremental process guide and framework for learning industry best practices of software development and project management.^[1] Since then, the Unified Process family has become probably the most popular methodology and reference model for object-oriented analysis and design.

Overview[edit]

The software life cycle is typically divided up into stages going from abstract descriptions of the problem to designs then to code and testing and finally to deployment. The earliest stages of this process are analysis and design. The analysis phase is also often called 'requirements acquisition'.

In some approaches to software development—known collectively as waterfall models—the boundaries between each stage are meant to be fairly rigid and sequential. The term 'waterfall' was coined for such methodologies to signify that progress went sequentially in one direction only, i.e., once analysis was complete then and only then was design begun and it was rare (and considered a source of error) when a design issue required a change in the analysis model or when a coding issue required a change in design.

The alternative to waterfall models are iterative models. This distinction was popularized by Barry Boehm in a very influential paper on his Spiral Model for iterative software development. With iterative models it is possible to do work in various stages of the model in parallel. So for example it is possible—and not seen as a source of error—to work on analysis, design, and even code all on the same day and to have issues from one stage impact issues from another. The emphasis on iterative models is that software development is a knowledge-intensive process and that things like analysis can't really be completely understood without understanding design issues, that coding issues can affect design, that testing can yield information about how the code or even the design should be modified, etc.^[2]

Although it is possible to do object-oriented development using a waterfall model, in practice most object-oriented systems are developed with an iterative approach. As a result, in object-oriented processes 'analysis and design' are often considered at the same time.

The object-oriented paradigm emphasizes modularity and re-usability. The goal of an object-oriented approach is to satisfy the 'open closed principle'. A module is open if it supports extension, or if the module provides standardized ways to add new behaviors or describe new states. In the object-oriented paradigm this is often accomplished by creating a new subclass of an existing class. A module is closed if it has a well defined stable interface that all other modules must use and that limits the interaction and potential errors that can be introduced into one module by changes in another. In the object-oriented paradigm this is accomplished by defining methods that invoke services on objects. Methods can be either public or private, i.e., certain behaviors that are unique to the object are not exposed to other objects. This reduces a source of many common errors in computer programming.^[3]

The software life cycle is typically divided up into stages going from abstract descriptions of the problem to designs then to code and testing and finally to deployment. The earliest stages of this process are analysis and design. The distinction between analysis and design is often described as 'what vs. how'. In analysis developers work with users and domain experts to define what the system is supposed to do. Implementation details are supposed to be mostly or totally (depending on the particular method) ignored at this phase. The goal of the analysis phase is to create a functional model of the system regardless of constraints such as appropriate technology. In object-oriented analysis this is typically done via use cases and abstract definitions of the most important objects. The subsequent design phase refines the analysis model and makes the needed technology and other implementation choices. In object-oriented design the emphasis is on describing the various objects, their data, behavior, and interactions. The design model should have all the details required so that programmers can implement the design in code.^[4].

Object-oriented analysis[edit]

The purpose of any analysis activity in the software life-cycle is to create a model of the system's functional requirements that is independent of implementation constraints.

The main difference between object-oriented analysis and other forms of analysis is that by the object-oriented approach we organize requirements around objects, which integrate both behaviors (processes) and states (data) modeled after real world objects that the system interacts with. In other or traditional analysis methodologies, the two aspects: processes and data are considered separately. For example, data may be modeled by ER diagrams, and behaviors by flow charts or structure charts.

Common models used in OOA are use cases and object models. Use cases describe scenarios for standard domain functions that the system must accomplish. Object models describe the names, class relations (e.g. Circle is a subclass of Shape), operations, and properties of the main objects. User-interface mockups or prototypes can also be created to help understanding.^[5]

During object-oriented design (OOD), a developer applies implementation constraints to the conceptual model produced in object-oriented analysis. Such constraints could include the hardware and software platforms, the performance requirements, persistent storage and transaction, usability of the system, and limitations imposed by budgets and time. Concepts in the analysis model which is technology independent, are mapped onto implementing classes and interfaces resulting in a model of the solution domain, i.e., a detailed description of how the system is to be built on concrete technologies.^[6]

Important topics during OOD also include the design of software architectures by applying architectural patterns and design patterns with object-oriented design principles.

Object-oriented modeling[edit]

Object-oriented modeling (OOM) is a common approach to modeling applications, systems, and business domains by using the object-oriented paradigm throughout the entire development life cycles. OOM is a main technique heavily used by both OOD and OOA activities in modern software engineering.

Object-oriented modeling typically divides into two aspects of work: the modeling of dynamic behaviors like business processes and use cases, and the modeling of static structures like classes and components. OOA and OOD are the two distinct abstract levels (i.e. the analysis level and the design level) during OOM. The Unified Modeling Language (UML) and SysML are the two popular international standard languages used for object-oriented modeling.^[7]

The benefits of OOM are:

Efficient and effective communication

Users typically have difficulties in understanding comprehensive documents and programming language codes well. Visual model diagrams can be more understandable and can allow users and stakeholders to give developers feedback on the appropriate requirements and structure of the system. A key goal of the object-oriented approach is to decrease the 'semantic gap' between the system and the real world, and to have the system be constructed using terminology that is almost the same as the stakeholders use in everyday business. Object-oriented modeling is an essential tool to facilitate this.

Useful and stable abstraction

Modeling helps coding. A goal of most modern software methodologies is to first address 'what' questions and then address 'how' questions, i.e. first determine the functionality the system is to provide without consideration of implementation constraints, and then consider how to make specific solutions to these abstract requirements, and refine them into detailed designs and codes by constraints such as technology and budget. Object-oriented modeling enables this by producing abstract and accessible descriptions of both system requirements and designs, i.e. models that define their essential structures and behaviors like processes and objects, which are important and valuable development assets with higher abstraction levels above concrete and complex source code.

Principles Of Object Oriented Programming

See also[edit]

• ATLAS Transformation Language (ATL)
• Class-Responsibility-Collaboration card (CRC cards)
• Domain Specific Language (DSL)
• Domain-specific modelling (DSM)
• Meta-Object Facility (MOF)
• Model-driven engineering (MDE)
• Model-based testing (MBT)
• Unified Modeling Language (UML)
• XML Metadata Interchange (XMI)

Object Oriented Analysis & Design Pdf

{{div col end}}

References[edit]

1. ^'Rational Unified Process Best Practices for Software Development Teams'(PDF). Rational Software White Paper (TP026B). 11/01. Retrieved 12 December 2013.Check date values in: |date= (help)
2. ^Boehm B, 'A Spiral Model of Software Development and Enhancement', IEEE Computer, IEEE, 21(5):61-72, May 1988
3. ^Meyer, Bertrand (1988). Object-Oriented Software Construction. Cambridge: Prentise Hall International Series in Computer Science. p. 23. ISBN0-13-629049-3.
4. ^Jacobsen, Ivar; Magnus Christerson; Patrik Jonsson; Gunnar Overgaard (1992). Object Oriented Software Engineering. Addison-Wesley ACM Press. pp. 15, 199. ISBN0-201-54435-0.
5. ^Jacobsen, Ivar; Magnus Christerson; Patrik Jonsson; Gunnar Overgaard (1992). Object Oriented Software Engineering. Addison-Wesley ACM Press. pp. 77–79. ISBN0-201-54435-0.
6. ^Conallen, Jim (2000). Building Web Applications with UML. Addison Wesley. p. 147. ISBN0201615770.
7. ^Jacobsen, Ivar; Magnus Christerson; Patrik Jonsson; Gunnar Overgaard (1992). Object Oriented Software Engineering. Addison-Wesley ACM Press. pp. 15, 199. ISBN0-201-54435-0.

Further reading[edit]

Object Oriented Analysis Design Pdf

• Grady Booch. 'Object-oriented Analysis and Design with Applications, 3rd edition':http://www.informit.com/store/product.aspx?isbn=020189551X Addison-Wesley 2007.
• Rebecca Wirfs-Brock, Brian Wilkerson, Lauren Wiener. Designing Object Oriented Software. Prentice Hall, 1990. [A down-to-earth introduction to the object-oriented programming and design.]
• A Theory of Object-Oriented Design: The building-blocks of OOD and notations for representing them (with focus on design patterns.)
• Martin Fowler. Analysis Patterns: Reusable Object Models. Addison-Wesley, 1997. [An introduction to object-oriented analysis with conceptual models]
• Bertrand Meyer. Object-oriented software construction. Prentice Hall, 1997
• Craig Larman. Applying UML and Patterns – Introduction to OOA/D & Iterative Development. Prentice Hall PTR, 3rd ed. 2005.,mnnm,n,nnn
• Setrag Khoshafian. Object Orientation.
• Ulrich Norbisrath, Albert Zündorf, Ruben Jubeh. Story Driven Modeling. Amazon Createspace. p. 333., 2013. ISBN9781483949253.

Principles Of Object Oriented Design Pdf

External links[edit]

• Article Object-Oriented Analysis and Design with UML and RUP an overview (also about CRC cards).
• Applying UML – Object Oriented Analysis & Design tutorial
• OOAD & UML Resource website and Forums – Object Oriented Analysis & Design with UML.
• Software Requirement Analysis using UML article by Dhiraj Shetty.
• Article Object-Oriented Analysis in the Real World

Object Oriented Design Uml Pdf