The document provides an introduction to UML diagrams, including use case diagrams, class diagrams, and state diagrams. It describes the purpose and notation of each type of diagram. Use case diagrams model user interactions and goals. Class diagrams describe the static structure of a system through classes, attributes, and relationships. State diagrams specify the different states an object can be in and the transitions between states. Examples of each diagram type are provided for common systems like a library management system.
The Unified Modeling Language (UML) is a general-
purpose, developmental, modeling language in the field
of software engineering, that is intended to provide a
standard way to visualize the design of a system.
The document provides an overview of the Unified Modeling Language (UML) including:
1) UML consists of 9 diagrams used at different stages of software development for requirements analysis, design, and deployment.
2) UML diagrams can be classified as static, dynamic, or implementation based on whether they depict the structural, behavioral, or deployment aspects of a system.
3) Popular UML tools should support features like generating code from diagrams, reverse engineering code into diagrams, and integrating with IDEs. Rational Rose is a widely used UML modeling tool.
This document provides an overview of the Unified Modeling Language (UML) including its building blocks, diagrams, and the Rational Unified Process (RUP) methodology. It defines UML, explains its advantages for visualizing, specifying, and constructing systems. It describes the different types of UML elements including structural things like classes and interfaces, behavioral things like interactions and state machines, and grouping and annotational things. It also outlines the different UML diagrams for modeling a system from various perspectives and the four phases of the iterative RUP methodology.
An architecture is very complicated and involves three types of decisions: how the system is structured as code units, how it is structured as runtime components and interactions, and how it relates to non-software elements. The document discusses several common architectural structures, including decomposition, uses, layered, class/generalization, process, concurrency, shared data/repository, client-server, deployment, implementation, and work assignment structures. It also discusses Kruchten's four views of logical, process, development, and physical.
This document discusses the evolution of the object model in programming. It describes how programming languages have evolved from procedural to object-oriented over several generations, with each generation incorporating new features like data abstraction, modularity, and object-oriented concepts. The core elements of the object model are explained as abstraction, encapsulation, hierarchy, and modularity. Minor elements like typing, concurrency, and persistence are also discussed. Examples are given throughout to illustrate object-oriented concepts.
UML deployment diagrams show the physical deployment of software components across hardware infrastructure. They depict the hardware elements like processors and devices, the software installed on each processor, and how the components connect. Deployment diagrams are created during system implementation to layout the physical architecture and are useful for embedded, client-server, and distributed systems to distinguish interfaces from data and host multiple software versions across servers.
This document provides an overview of UML class diagrams, including their purpose and essential elements. A UML class diagram visually describes the structure of a system by showing classes, attributes, operations, and relationships. Key elements include classes, associations, generalization, dependencies, and notes. The document also provides examples and tips for creating UML class diagrams.
UML (Unified Modeling Language) is a standard modeling language used to visualize, specify, construct, and document software systems. It uses graphical notation to depict systems from initial design through detailed design. Common UML diagram types include use case diagrams, class diagrams, sequence diagrams, activity diagrams, and state machine diagrams. UML provides a standard way to communicate designs across development teams and is supported by many modeling tools.
The Unified Modeling Language (UML) is a general-
purpose, developmental, modeling language in the field
of software engineering, that is intended to provide a
standard way to visualize the design of a system.
The document provides an overview of the Unified Modeling Language (UML) including:
1) UML consists of 9 diagrams used at different stages of software development for requirements analysis, design, and deployment.
2) UML diagrams can be classified as static, dynamic, or implementation based on whether they depict the structural, behavioral, or deployment aspects of a system.
3) Popular UML tools should support features like generating code from diagrams, reverse engineering code into diagrams, and integrating with IDEs. Rational Rose is a widely used UML modeling tool.
This document provides an overview of the Unified Modeling Language (UML) including its building blocks, diagrams, and the Rational Unified Process (RUP) methodology. It defines UML, explains its advantages for visualizing, specifying, and constructing systems. It describes the different types of UML elements including structural things like classes and interfaces, behavioral things like interactions and state machines, and grouping and annotational things. It also outlines the different UML diagrams for modeling a system from various perspectives and the four phases of the iterative RUP methodology.
An architecture is very complicated and involves three types of decisions: how the system is structured as code units, how it is structured as runtime components and interactions, and how it relates to non-software elements. The document discusses several common architectural structures, including decomposition, uses, layered, class/generalization, process, concurrency, shared data/repository, client-server, deployment, implementation, and work assignment structures. It also discusses Kruchten's four views of logical, process, development, and physical.
This document discusses the evolution of the object model in programming. It describes how programming languages have evolved from procedural to object-oriented over several generations, with each generation incorporating new features like data abstraction, modularity, and object-oriented concepts. The core elements of the object model are explained as abstraction, encapsulation, hierarchy, and modularity. Minor elements like typing, concurrency, and persistence are also discussed. Examples are given throughout to illustrate object-oriented concepts.
UML deployment diagrams show the physical deployment of software components across hardware infrastructure. They depict the hardware elements like processors and devices, the software installed on each processor, and how the components connect. Deployment diagrams are created during system implementation to layout the physical architecture and are useful for embedded, client-server, and distributed systems to distinguish interfaces from data and host multiple software versions across servers.
This document provides an overview of UML class diagrams, including their purpose and essential elements. A UML class diagram visually describes the structure of a system by showing classes, attributes, operations, and relationships. Key elements include classes, associations, generalization, dependencies, and notes. The document also provides examples and tips for creating UML class diagrams.
UML (Unified Modeling Language) is a standard modeling language used to visualize, specify, construct, and document software systems. It uses graphical notation to depict systems from initial design through detailed design. Common UML diagram types include use case diagrams, class diagrams, sequence diagrams, activity diagrams, and state machine diagrams. UML provides a standard way to communicate designs across development teams and is supported by many modeling tools.
The document discusses collaboration diagrams, which capture the dynamic behavior of objects collaborating to perform tasks. Collaboration diagrams illustrate object interactions through messages in a graph format. They show objects, links between objects, and messages to model control flow and coordination. Notations are used to represent classes, instances, links, messages, return values, self-messages, conditional messages, iteration, and collections of objects. Examples of converting sequence diagrams to collaboration diagrams for making a phone call, changing flight itineraries, and making a hotel reservation are provided.
The document discusses the Unified Modeling Language (UML). UML is a general-purpose modeling language used to specify, visualize, construct, and document software systems. It captures decisions and understanding about systems that must be constructed. The goals of UML included developing a modeling language that could be used across different domains and development methods. UML has three main building blocks - things, relationships, and diagrams. Things represent elements in a model like classes, components, and use cases. Relationships connect things and show dependencies, generalizations, and associations. Diagrams provide different views of UML models, including structural diagrams and behavioral diagrams.
UML (Unified Modeling Language) is a standard language for specifying, visualizing, constructing and documenting software systems. It uses mainly graphical notations to express design of software projects. There are two main categories of UML diagrams - structural diagrams which focus on static elements regardless of time, and behavioral diagrams which focus on dynamic features and business processes. Common UML diagram types include class, sequence, use case, activity, state machine, component, deployment and interaction diagrams.
The document discusses sequence diagrams, which show the interaction between objects and classes through a sequence of messages. Sequence diagrams are useful during the design phase to help understand system design and object interactions. They can also be used to document how existing systems work by showing the sequence of messages exchanged between objects.
The document discusses advanced structural modeling concepts in object-oriented software engineering, including advanced classes, relationships, interfaces, types and roles, packages, and object diagrams. It defines these concepts and provides examples to illustrate their usage and relationships.
UML (Unified Modeling Language) is a standard language for specifying, visualizing, and documenting software systems. It uses various diagrams to model different views of a system, such as structural diagrams (e.g. class diagrams), behavioral diagrams (e.g. sequence diagrams), and deployment diagrams. The key building blocks of UML include things (classes, interfaces, use cases), relationships (associations, generalizations), and diagrams. UML aims to provide a clear blueprint of software systems for both technical and non-technical audiences.
This document provides an introduction to the Unified Modeling Language (UML). It defines UML as a standard modeling language used to visualize, specify, construct and document software systems. The document outlines the basics of UML including common diagram types like use case diagrams, class diagrams and sequence diagrams. It also discusses modeling tools that support working with UML diagrams.
UML (Unified Modeling Language) is a standard modeling language used to specify, visualize, construct and document software systems. It uses graphical notations to express the design of object-oriented software projects. UML includes diagrams, relationships and elements that help design different perspectives of a system including design, implementation, process and deployment. The key building blocks of UML are things (like classes and use cases), relationships (like generalization and dependency), and diagrams (like class, sequence and deployment diagrams) which are used to model different aspects of a software system.
This document discusses threads and multithreaded programming. It covers thread libraries like Pthreads, Windows threads and Java threads. It also discusses implicit threading using thread pools, OpenMP and Grand Central Dispatch. Issues with multithreaded programming like signal handling, thread cancellation and thread-local storage are examined. Finally, thread implementation in Windows and Linux is overviewed.
The document discusses software architecture design. It defines software architecture as the structure of components, relationships between components, and properties of components. An architectural design model can be applied to other systems and represents predictable ways to describe architecture. The architecture represents a system and enables analysis of effectiveness in meeting requirements and reducing risks. Key aspects of architectural design include communication between stakeholders, controlling complexity, consistency, reducing risks, and enabling reuse. Common architectural styles discussed include data-centered, data flow, call-and-return, object-oriented, and layered architectures.
Unit 1( modelling concepts & class modeling)Manoj Reddy
The document discusses object-oriented modeling and design. It covers key concepts like classes, objects, inheritance, polymorphism, and encapsulation. It also discusses the Unified Modeling Language (UML) which provides standard notation for visualizing, specifying, constructing, and documenting models. The document is a lecture on object-oriented concepts for students to understand modeling using classes, objects, and relationships.
UML (Unified Modeling Language) is a diagramming language used for object-oriented programming. It can be used to describe the organization, execution, use, and deployment of a program. UML uses graphical notation to provide an overall view of a system, and is not dependent on any one programming language. There are several types of UML diagrams including class, component, deployment, object, package, and use case diagrams. Structure diagrams show objects in a system, while behavioral diagrams show how objects interact. Common diagrams include class, use case, activity, state machine, sequence, and communication diagrams.
The document discusses UML diagrams including state diagrams and activity diagrams. For state diagrams, it describes how they model the dynamic aspects and states of an object over time through states, transitions, and events. The key elements of a state diagram like states, transitions, and events are defined. It also provides an example state diagram. For activity diagrams, it describes how they model the flow of activities in a system through activity nodes and edges. The basic components of an activity diagram like activities, forks, joins, and decisions are outlined. It concludes with the main uses of activity diagrams to model workflows and business requirements.
Rumbaugh's Object Modeling Technique (OMT) is an object-oriented analysis and design methodology. It uses three main modeling approaches: object models, dynamic models, and functional models. The object model defines the structure of objects in the system through class diagrams. The dynamic model describes object behavior over time using state diagrams and event flow diagrams. The functional model represents system processes and data flow using data flow diagrams.
The document discusses various types of UML diagrams including use case diagrams, class diagrams, interaction diagrams (sequence and collaboration diagrams), state diagrams, and activity diagrams. It provides details on when each diagram should be used and includes examples to illustrate how to draw each type of diagram. The key points covered are that UML diagrams allow viewing a software system from different perspectives and varying degrees of abstraction, and each diagram type has a specific purpose to model different aspects of a system.
System Models in Software Engineering SE7koolkampus
The document discusses various types of system models used in requirements engineering including context models, behavioral models, data models, object models, and how CASE workbenches support system modeling. It describes behavioral models like data flow diagrams and state machine models, data models like entity-relationship diagrams, and object models using the Unified Modeling Language. CASE tools can support modeling through features like diagram editors, repositories, and code generation.
The document discusses UML (Unified Modeling Language) and object-oriented software development. It describes the software development life cycle and various modeling techniques used in UML, including use case diagrams, class diagrams, sequence diagrams, and collaboration diagrams. It explains key UML concepts such as classes, objects, attributes, operations, actors, and relationships. The benefits of visual modeling and UML are also summarized.
The document discusses domain modeling. It defines a domain model as a structural model showing the basic concepts and relationships in a domain. It describes the key components of a domain model including conceptual classes, attributes, associations, multiplicity, aggregation, composition, generalization and roles. The document provides an example domain model for a video rental shop showing customers who can buy or rent movies, and rent specific rental copies with attributes like due dates. It models members who get discounts and can reserve rentals, and includes reviews customers can provide.
The Unified Process (UP) is a popular iterative software development framework that uses use cases, architecture-centric design, and the Unified Modeling Language. It originated from Jacobson's Objectory process in the 1980s and was further developed by Rational Software into the Rational Unified Process. The UP consists of four phases - inception, elaboration, construction, and transition - and emphasizes iterative development, architectural drivers, and risk-managed delivery.
Software Engineering Tools and Practices.pdfMeagGhn
This document discusses software engineering practices and tools, including the software crisis and issues like increasing complexity, poor quality, high costs and delays. It introduces Unified Modeling Language (UML) as a standard way to visually model software systems using diagrams. It describes different types of UML models including structural, behavioral and architectural modeling. It also discusses concepts like the software development life cycle, configuration management, revision control systems and how to create UML diagrams like use case diagrams and sequence diagrams.
UML is a standard modeling language used to visualize the design of a system. It provides standard diagrams to model both structural and behavioral aspects of a system. The main structural diagrams are class, component, deployment, and package diagrams which show the static design. The main behavioral diagrams are state machine, activity, use case, sequence, and communication diagrams which show the dynamic behavior. UML helps with communication between teams and analysis during system design.
The document discusses collaboration diagrams, which capture the dynamic behavior of objects collaborating to perform tasks. Collaboration diagrams illustrate object interactions through messages in a graph format. They show objects, links between objects, and messages to model control flow and coordination. Notations are used to represent classes, instances, links, messages, return values, self-messages, conditional messages, iteration, and collections of objects. Examples of converting sequence diagrams to collaboration diagrams for making a phone call, changing flight itineraries, and making a hotel reservation are provided.
The document discusses the Unified Modeling Language (UML). UML is a general-purpose modeling language used to specify, visualize, construct, and document software systems. It captures decisions and understanding about systems that must be constructed. The goals of UML included developing a modeling language that could be used across different domains and development methods. UML has three main building blocks - things, relationships, and diagrams. Things represent elements in a model like classes, components, and use cases. Relationships connect things and show dependencies, generalizations, and associations. Diagrams provide different views of UML models, including structural diagrams and behavioral diagrams.
UML (Unified Modeling Language) is a standard language for specifying, visualizing, constructing and documenting software systems. It uses mainly graphical notations to express design of software projects. There are two main categories of UML diagrams - structural diagrams which focus on static elements regardless of time, and behavioral diagrams which focus on dynamic features and business processes. Common UML diagram types include class, sequence, use case, activity, state machine, component, deployment and interaction diagrams.
The document discusses sequence diagrams, which show the interaction between objects and classes through a sequence of messages. Sequence diagrams are useful during the design phase to help understand system design and object interactions. They can also be used to document how existing systems work by showing the sequence of messages exchanged between objects.
The document discusses advanced structural modeling concepts in object-oriented software engineering, including advanced classes, relationships, interfaces, types and roles, packages, and object diagrams. It defines these concepts and provides examples to illustrate their usage and relationships.
UML (Unified Modeling Language) is a standard language for specifying, visualizing, and documenting software systems. It uses various diagrams to model different views of a system, such as structural diagrams (e.g. class diagrams), behavioral diagrams (e.g. sequence diagrams), and deployment diagrams. The key building blocks of UML include things (classes, interfaces, use cases), relationships (associations, generalizations), and diagrams. UML aims to provide a clear blueprint of software systems for both technical and non-technical audiences.
This document provides an introduction to the Unified Modeling Language (UML). It defines UML as a standard modeling language used to visualize, specify, construct and document software systems. The document outlines the basics of UML including common diagram types like use case diagrams, class diagrams and sequence diagrams. It also discusses modeling tools that support working with UML diagrams.
UML (Unified Modeling Language) is a standard modeling language used to specify, visualize, construct and document software systems. It uses graphical notations to express the design of object-oriented software projects. UML includes diagrams, relationships and elements that help design different perspectives of a system including design, implementation, process and deployment. The key building blocks of UML are things (like classes and use cases), relationships (like generalization and dependency), and diagrams (like class, sequence and deployment diagrams) which are used to model different aspects of a software system.
This document discusses threads and multithreaded programming. It covers thread libraries like Pthreads, Windows threads and Java threads. It also discusses implicit threading using thread pools, OpenMP and Grand Central Dispatch. Issues with multithreaded programming like signal handling, thread cancellation and thread-local storage are examined. Finally, thread implementation in Windows and Linux is overviewed.
The document discusses software architecture design. It defines software architecture as the structure of components, relationships between components, and properties of components. An architectural design model can be applied to other systems and represents predictable ways to describe architecture. The architecture represents a system and enables analysis of effectiveness in meeting requirements and reducing risks. Key aspects of architectural design include communication between stakeholders, controlling complexity, consistency, reducing risks, and enabling reuse. Common architectural styles discussed include data-centered, data flow, call-and-return, object-oriented, and layered architectures.
Unit 1( modelling concepts & class modeling)Manoj Reddy
The document discusses object-oriented modeling and design. It covers key concepts like classes, objects, inheritance, polymorphism, and encapsulation. It also discusses the Unified Modeling Language (UML) which provides standard notation for visualizing, specifying, constructing, and documenting models. The document is a lecture on object-oriented concepts for students to understand modeling using classes, objects, and relationships.
UML (Unified Modeling Language) is a diagramming language used for object-oriented programming. It can be used to describe the organization, execution, use, and deployment of a program. UML uses graphical notation to provide an overall view of a system, and is not dependent on any one programming language. There are several types of UML diagrams including class, component, deployment, object, package, and use case diagrams. Structure diagrams show objects in a system, while behavioral diagrams show how objects interact. Common diagrams include class, use case, activity, state machine, sequence, and communication diagrams.
The document discusses UML diagrams including state diagrams and activity diagrams. For state diagrams, it describes how they model the dynamic aspects and states of an object over time through states, transitions, and events. The key elements of a state diagram like states, transitions, and events are defined. It also provides an example state diagram. For activity diagrams, it describes how they model the flow of activities in a system through activity nodes and edges. The basic components of an activity diagram like activities, forks, joins, and decisions are outlined. It concludes with the main uses of activity diagrams to model workflows and business requirements.
Rumbaugh's Object Modeling Technique (OMT) is an object-oriented analysis and design methodology. It uses three main modeling approaches: object models, dynamic models, and functional models. The object model defines the structure of objects in the system through class diagrams. The dynamic model describes object behavior over time using state diagrams and event flow diagrams. The functional model represents system processes and data flow using data flow diagrams.
The document discusses various types of UML diagrams including use case diagrams, class diagrams, interaction diagrams (sequence and collaboration diagrams), state diagrams, and activity diagrams. It provides details on when each diagram should be used and includes examples to illustrate how to draw each type of diagram. The key points covered are that UML diagrams allow viewing a software system from different perspectives and varying degrees of abstraction, and each diagram type has a specific purpose to model different aspects of a system.
System Models in Software Engineering SE7koolkampus
The document discusses various types of system models used in requirements engineering including context models, behavioral models, data models, object models, and how CASE workbenches support system modeling. It describes behavioral models like data flow diagrams and state machine models, data models like entity-relationship diagrams, and object models using the Unified Modeling Language. CASE tools can support modeling through features like diagram editors, repositories, and code generation.
The document discusses UML (Unified Modeling Language) and object-oriented software development. It describes the software development life cycle and various modeling techniques used in UML, including use case diagrams, class diagrams, sequence diagrams, and collaboration diagrams. It explains key UML concepts such as classes, objects, attributes, operations, actors, and relationships. The benefits of visual modeling and UML are also summarized.
The document discusses domain modeling. It defines a domain model as a structural model showing the basic concepts and relationships in a domain. It describes the key components of a domain model including conceptual classes, attributes, associations, multiplicity, aggregation, composition, generalization and roles. The document provides an example domain model for a video rental shop showing customers who can buy or rent movies, and rent specific rental copies with attributes like due dates. It models members who get discounts and can reserve rentals, and includes reviews customers can provide.
The Unified Process (UP) is a popular iterative software development framework that uses use cases, architecture-centric design, and the Unified Modeling Language. It originated from Jacobson's Objectory process in the 1980s and was further developed by Rational Software into the Rational Unified Process. The UP consists of four phases - inception, elaboration, construction, and transition - and emphasizes iterative development, architectural drivers, and risk-managed delivery.
Software Engineering Tools and Practices.pdfMeagGhn
This document discusses software engineering practices and tools, including the software crisis and issues like increasing complexity, poor quality, high costs and delays. It introduces Unified Modeling Language (UML) as a standard way to visually model software systems using diagrams. It describes different types of UML models including structural, behavioral and architectural modeling. It also discusses concepts like the software development life cycle, configuration management, revision control systems and how to create UML diagrams like use case diagrams and sequence diagrams.
UML is a standard modeling language used to visualize the design of a system. It provides standard diagrams to model both structural and behavioral aspects of a system. The main structural diagrams are class, component, deployment, and package diagrams which show the static design. The main behavioral diagrams are state machine, activity, use case, sequence, and communication diagrams which show the dynamic behavior. UML helps with communication between teams and analysis during system design.
The document provides an introduction to the Unified Modeling Language (UML). It discusses the key principles of modeling and an overview of UML. The UML is a standard language for writing software blueprints and can be used to visualize, specify, construct, and document software systems. The UML has building blocks like classes, objects, use cases and relationships. It consists of diagrams like class diagrams, sequence diagrams, and state machine diagrams. The UML addresses multiple views of a system including use case, design, interaction and implementation views.
The document discusses use case diagrams in UML modeling. It defines key components of use case diagrams including use cases, actors, the system boundary, and relationships like include, extend, and generalization. It provides examples of how to construct a use case diagram based on system functions and user goals. Specific use case diagram examples shown include an online ordering system and a vending machine.
Person
+Specialization:String
Employee:Person
+Dept:String
+Salary:float
Manager:Employee
+NoOfReports:int
Generalization
Inheritance
Specialization
Con...
Inheritance:
Is a mechanism in which one class acquires the properties and
behaviors of another class.
The inheriting class is called a subclass or derived class and the
class whose properties and behaviors are inherited is called a
superclass or base class.
Specialization:
Is a generalization relationship between a generalized entity and a
more specific entity.
Generalization
The document provides information on Unified Modeling Language (UML) and its various diagrams used for modeling software systems. It discusses the background and benefits of object-oriented modeling. It then describes UML as a modeling language comprising various diagram types to capture different views of a system, including structural, behavioral, implementation and user views. Specific diagram types covered include use case diagrams, class diagrams, sequence diagrams, and object diagrams. Examples are provided for each diagram type to illustrate their elements and notation.
This document discusses object oriented programming using Java and provides an overview of Unified Modeling Language (UML). It describes UML diagrams including use case diagrams, class diagrams, interaction diagrams, activity diagrams and state chart diagrams. It focuses on use case diagrams, explaining the different elements like actors, use cases, relationships between use cases, system boundary and packages. It provides examples of a use case diagram for a hospital management system.
The document provides an overview of the Unified Modeling Language (UML). UML is a general-purpose modeling language that is used to specify, visualize, construct, and document the artifacts of software systems. The document discusses the various UML diagrams including use case diagrams, class diagrams, sequence diagrams, state machine diagrams, activity diagrams, and package diagrams. It explains the key elements and concepts of each diagram type.
The document discusses object-oriented system development and modeling. It covers topics like:
1. The main stages of traditional system development life cycles like requirements, analysis, design, implementation, and installation. As well as common life cycle models like waterfall, V-model, spiral, and prototyping.
2. Phases of object-oriented development focus on the state of the system rather than activities, including inception, elaboration, construction, and transition.
3. Modeling techniques for object-oriented systems including the Unified Modeling Language (UML), Rational Unified Process (RUP), abstraction, decomposition, and class-responsibility-collaboration (CRC) cards.
4
1. UML is a standardized modeling language used to visualize, specify, construct, and document a system.
2. UML includes structural elements like classes, interfaces, components as well as behavioral elements like use cases, interactions, state machines.
3. UML diagrams like class, sequence, activity diagrams are used to represent different views of a system based on its design, implementation, processes, and deployment.
The document discusses the Unified Approach (UA) methodology for software development proposed by Ali Bahrami. The UA aims to combine the best practices of other methodologies like Booch, Rumbaugh, and Jacobson while using the Unified Modeling Language (UML). The core of the UA is use case-driven development. It establishes a unified framework around these methodologies using UML for modeling and documenting the software development process. The UA allows for iterative development by allowing moving between analysis, design, and modeling phases.
The document provides information about UML (Unified Modeling Language), including its goals, why it is used, and common diagram types. UML is a standard language for specifying, visualizing, and documenting software systems and other non-software systems. It uses mostly graphical notations to express the design of software projects. Common UML diagram types include use case diagrams, class diagrams, interaction diagrams, state diagrams, activity diagrams, component diagrams, and deployment diagrams. Each diagram type displays different aspects of a system and can be used at various stages of development.
The document provides information about UML (Unified Modeling Language), including its goals, why it is used, and common diagram types. UML is a standard language for specifying, constructing, and documenting software systems and business processes. It uses mainly graphical notations to express the design of software projects. Common UML diagram types include use case diagrams, class diagrams, interaction diagrams, state diagrams, activity diagrams, component diagrams, and deployment diagrams. Each diagram type shows different aspects of a system and allows developers and customers to view it from different perspectives.
Materi yang ada pada slide ini berisi :
Pengenalan UML Sebagai Alat Bantu Pemodelan Pada Pembangunan Perangkat Lunak Menggunakan Pendekatan Analisis dan Desain Berorientasi Objek
Notasi, Semantik, dan Stereotype Pada UML
Komponen pada UML (Use Case View, Logical View, Physical View, dan Process View)
Pengenalan Use Case Diagram sebagai Use Case View Pada UML
Penjelasan Aktor, Generalisasi Aktor, dan Use Case
Penjelasan Use Case Scenario
Use Case Refinement (Relasi Include, Extends, dan Generalisasi Use Case)
----------------------------------------------------------------------
Keep in touch with me in :
Twitter : https://twitter.com/rizkiadam_1991
Email : rizkiadamunikom@gmail.com
IG : @rizkiadamkurniawan
Workshop on Basics of Software Engineering (DFD, UML and Project Culture)Dr Sukhpal Singh Gill
Three days workshop on Basics of Software Engineering at Thapar University, Patiala on 7th-9th, 2013. Workshop on Basics of Software Engineering (DFD, UML and Project Culture)
This document provides an overview of the Unified Modeling Language (UML) for object-oriented data modeling. It describes UML as a complete language for capturing and communicating knowledge about a subject. The document outlines the goals of UML, the advantages it provides, and how it can be used. It also describes the different categories of UML diagrams including structural diagrams for describing static relationships and behavioral diagrams for describing dynamic relationships. Use case models and how they represent user interactions with a system are discussed. An example use case diagram for an order placement process is included.
This document provides an overview of the Unified Modeling Language (UML) for object-oriented data modeling. It describes UML as a complete language for capturing and communicating knowledge about a subject. The document outlines the goals of UML, the advantages it provides, and how it can be used. It also describes the different categories of UML diagrams including structural diagrams for describing static relationships and behavioral diagrams for describing dynamic relationships. Use case models and how they represent user interactions with a system are discussed. An example use case diagram for an order placement process is included.
Similar to Darshan sem4 140703_ooad_2014 (diagrams) (20)
Assessment and Planning in Educational technology.pptxKavitha Krishnan
In an education system, it is understood that assessment is only for the students, but on the other hand, the Assessment of teachers is also an important aspect of the education system that ensures teachers are providing high-quality instruction to students. The assessment process can be used to provide feedback and support for professional development, to inform decisions about teacher retention or promotion, or to evaluate teacher effectiveness for accountability purposes.
Introduction to AI for Nonprofits with Tapp NetworkTechSoup
Dive into the world of AI! Experts Jon Hill and Tareq Monaur will guide you through AI's role in enhancing nonprofit websites and basic marketing strategies, making it easy to understand and apply.
Executive Directors Chat Leveraging AI for Diversity, Equity, and InclusionTechSoup
Let’s explore the intersection of technology and equity in the final session of our DEI series. Discover how AI tools, like ChatGPT, can be used to support and enhance your nonprofit's DEI initiatives. Participants will gain insights into practical AI applications and get tips for leveraging technology to advance their DEI goals.
How to Add Chatter in the odoo 17 ERP ModuleCeline George
In Odoo, the chatter is like a chat tool that helps you work together on records. You can leave notes and track things, making it easier to talk with your team and partners. Inside chatter, all communication history, activity, and changes will be displayed.
Physiology and chemistry of skin and pigmentation, hairs, scalp, lips and nail, Cleansing cream, Lotions, Face powders, Face packs, Lipsticks, Bath products, soaps and baby product,
Preparation and standardization of the following : Tonic, Bleaches, Dentifrices and Mouth washes & Tooth Pastes, Cosmetics for Nails.
A review of the growth of the Israel Genealogy Research Association Database Collection for the last 12 months. Our collection is now passed the 3 million mark and still growing. See which archives have contributed the most. See the different types of records we have, and which years have had records added. You can also see what we have for the future.
This slide is special for master students (MIBS & MIFB) in UUM. Also useful for readers who are interested in the topic of contemporary Islamic banking.
Chapter 4 - Islamic Financial Institutions in Malaysia.pptx
Darshan sem4 140703_ooad_2014 (diagrams)
1. 1
UML Diagrams| 140703-OOAD
Computer Engineering | Sem -IV
Introduction to UML
- UML – Unified Modeling Language diagram is designed to let developers and customers view a software
system from a different perspective and in varying degrees of abstraction.
- One reason UML has become a standard modeling language is that it is programming-language
independent.
- Since UML is not a methodology, it does not require any formal work products.
- In an effort to promote Object Oriented designs, three leading object oriented programming researchers
joined ranks to combine their languages:
i. Grady Booch (BOOCH)
ii. James Rumbaugh (OML: object modeling technique)
iii. Ivar Jacobsen (OOSE: object oriented software eng) and come up with an industry standard [mid
1990’s].
Types of UML Diagram
2. 140703-OOAD
Prepared By: SWATI SHARMA 2
UML Diagrams
Structural Diagrams
- Structure diagrams emphasize on the things that must be present in the system being modeled.
- Since structure diagrams represent the structure, they are used extensively in documenting the software
architecture of software systems.
Behavioural Diagrams
- Behavior diagrams emphasize on what must happen in the system being modeled.
- Since behavior diagrams illustrate the behavior of a system, they are used extensively to describe the
functionality of software systems.
3. 140703-OOAD
Prepared By: SWATI SHARMA 3
UML Diagrams
Use Case Diagram
-----------------------------------------------------------------------------------------------------------------------------
Introduction:
- A use case diagram describes how a system interacts with outside actors.
- It is a graphical representation of the interaction among the elements and system.
- Each use case representation a piece of functionality that a system provides to its user.
- Use case identifies the functionality of a system.
- Use case diagram allows for the specification of higher level user goals that the system must carry out.
- These goals are not necessarily to tasks or actions, but can be more general required functionality of
the system.
- You can apply use case to capture the intended behavior of the system you are developing, without
having to specify how that behavior is implemented.
- A use case diagram at its simplest is a representation of a user's interaction with the system and
depicting the specifications of a use case.
- A use case diagram contains four components.
i. The boundary, which defines the system of interest in relation to the world around it.
ii. The actors, usually individuals involved with the system defined according to their roles.
iii. The use cases, which the specific roles are played by the actors within and around the system.
iv. The relationships between and among the actors and the use cases.
Purpose:
- The main purpose of the use case diagram is to capture the dynamic aspect of a system.
- Use case diagram shows, what software is suppose to do from user point of view.
- It describes the behavior of system from user’s point.
- It provides functional description of system and its major processes.
- Use case diagram defines the scope of the system you are building.
When to Use: Use Cases Diagrams
- Use cases are used in almost every project.
- They are helpful in exposing requirements and planning the project.
- During the initial stage of a project most use cases should be defined.
4. 140703-OOAD
Prepared By: SWATI SHARMA 4
UML Diagrams
Use Case Notations
No. Name Notation Description
1 System boundary The scope of a system can be represented by a system
boundary. The use cases of the system are placed
inside the system boundary, while the actors who
interact with the system are put outside the system.
The use cases in the system make up the total
requirements of the system.
2 Use case A use case represents a user goal that can be achieved
by accessing the system or software application.
3 Actor Actors are the entities that interact with a system.
Although in most cases, actors are used to represent
the users of system, actors can actually be anything
that needs to exchange information with the system.
So an actor may be people, computer hardware, other
systems, etc. Note that actor represent a role that a
user can play, but not a specific user.
4 Association Actor and use case can be associated to indicate that
the actor participates in that use case. Therefore, an
association corresponds to a sequence of actions
between the actor and use case in achieving the use
case.
5 Generalization A generalization relationship is used to represent
inheritance relationship between model elements of
same type.
6 Include An include relationship specifies how the behavior for
the inclusion use case is inserted into the behavior
defined for the base use case.
5. 140703-OOAD
Prepared By: SWATI SHARMA 5
UML Diagrams
7 Extends An extend relationship specifies how the behavior of
the extension use case can be inserted into the
behavior defined for the base use case.
8 Constraint Show condition exists between actors an activity.
9 Package Package is defined as collection of classes. Classes are
unified together using a package.
10 Interface Interface is used to connect package and use-case.
Head is linked with package and tail linked with use-
case.
11 Note Note is generally used to write comment in use-case
diagram.
12 Anchor Anchor is used to connect a note the use case in use
case diagram
11. 140703-OOAD
Prepared By: SWATI SHARMA 11
UML Diagrams
Class Diagram
-----------------------------------------------------------------------------------------------------------------------------
Introduction
- The class diagram is a static diagram.
- A class model captures the static structure of a system by characterizing the objects in the system, the
relationship between the objects, and the attributes and operations for each class of objects.
- The class diagram can be mapped directly with object oriented languages.
- The class model is the most important amonethe three models.
- Class diagram provide a graphical notation for modeling classes and their relationship.
- They are concise, easy to understand, and work well in practice.
- Class diagrams are the backbone of almost every object-oriented method including UML.
- They describe the static structure of a system.
Purpose
- Analysis and design of the static view of an application.
- Describe responsibilities of a system.
- Base for component and deployment diagrams.
When to use : Class Diagram
- Useful for Forward and Reverse engineering.
- Class diagrams are useful both for abstract modeling and for designing actual programs.
- Developer uses class diagram for implementation decision.
- Business analysts can use class diagrams to model systems from the business perspective.
12. 140703-OOAD
Prepared By: SWATI SHARMA 12
UML Diagrams
Class Diagram Notations
Sr. No. Name Symbol Meaning
1. Class Class is an entity of the
class diagram. It
describes a group of
objects with same
properties & behavior.
2. Object An object is an instance
or occurrence of a class.
3. Link A link is a physical or
conceptual connection
among objects
4. Association An association is a
description of a links with
common structure &
common semantics.
5. Multiplicity Ex. 1 to 1
1 to *
* to *
* to 1
1 to 0….2
Multiplicity specifies the
number of instances of
one class that may relate
to a single instance of an
associated class.
It is a constraint on the
cardinality of a set.
13. 140703-OOAD
Prepared By: SWATI SHARMA 13
UML Diagrams
6. Association
class
It is an association that is
a class which describes
the association with
attributes.
7. cardinality It describes the count of
elements from collection.
8. ordering It is used to indicate an
ordered set of objects
with no duplication
allowed.
9. bag A bag is a collection of
unordered elements with
duplicates allowed.
10. sequence A sequence is an ordered
collection of elements
with duplicates allowed.
11. qualified
association
Qualification increases
the precision of a model.
It is used to avoid many
to many multiplicities and
it converts into one to
one multiplicity.
14. 140703-OOAD
Prepared By: SWATI SHARMA 14
UML Diagrams
12. generalization Generalization organizes
classes by their super-
class and sub-class
relationship.
13. enumeration An enumeration is a data
type that has a finite set
of values.
14. aggregation It is a strong form of
association in which an
aggregate object is made
of constituent parts.
15. composition It is a form of
aggregation. Composition
implies ownership of the
parts by the whole.
16. Abstract class It is a class that has no
direct instances.
17. Concrete class It is a class that is
intangible; it can have
direct instances. Class-2 is
example of concrete class
18. package A package is a group of
elements with common
theme.
20. 140703-OOAD
Prepared By: SWATI SHARMA 20
UML Diagrams
Additional Diagram : Class Diagram
1 Prepare Class diagram showing at least 10 relationships among the following object classes. Include associations
and qualified associations, aggregations, generalizations, and multiplicity. You may add additional objects. Also
show attributes and operations. School, playground, principal, school board, classroom, book, student, teacher,
canteen, restroom, computer, desk, chair.
21. 140703-OOAD
Prepared By: SWATI SHARMA 21
UML Diagrams
2 Prepare a class diagram for each group of classes. Add at least 10 relationships (associations and generalizations)
to each diagram. File system, file, ASCII file, binary file, directory file, disc, drive, track, and sector.
22. 140703-OOAD
Prepared By: SWATI SHARMA 22
UML Diagrams
3 Prepare a class diagram for group of classes. Sink, freezer, refrigerator, table, light, switch, window, smoke alarm,
burglar alarm, cabinet, bread, cheese, ice, door, kitchen
4 Prepare a class diagram for the dining philosopher problem. There are 5 philosophers and 5 forks around a
circular table. Each philosopher has access to 2 forks, one on either side. Each fork is shared by 2 philosophers.
Each fork may be either on the table or in use by one philosopher. A philosopher must have 2 forks to eat.
23. 140703-OOAD
Prepared By: SWATI SHARMA 23
UML Diagrams
5 Categorize the following relationships into generalization, aggregation or association. Justify your answer.
i. A country has a capital city.
Association. A capital city and a country are distinct things so generalization certainly does not apply. You
could argue that a capital city is a part of a country and thus they are related by aggregation.
ii. A file is an ordinary file or a directory file.
Generalization. The word “or” often is an indicator of generalization. File is the super class and Ordinary File
and Directory File are subclasses.
iii. Files contain records.
Aggregation. The word “contain” is a clue that the relationship may be aggregation. A record is a part of a
file. Some attributes and operations on files propagate to their constituent records.
iv. A polygon is composed of an ordered set of points.
Aggregation or Composition. The phrase “is composed of” should immediately make you suspicious that
there is an aggregation. An ordered set of points is a part of a polygon. Some attributes and operations on a
polygon propagate to the corresponding set of points.
v. A drawing object is text, a geometrical object, or a group.
Generalization. Once again, the word “or” should prompt you to think of generalization. DrawingObject is
the super class. Text, Geometrical Object, and Group are subclasses.
vi. A route connects two cities.
Association. Either Route is a class associated with the City class, or Route is the name of the association
from City to City.
vii. A student takes a course from a professor.
Ternary association. Student, Course, and Professor are distinct classes of equal stature.
viii. A person uses a computer language on a project.
Ternary association. Person, Computer Language, and Project are all classes of equal stature. The association
cannot be reduced to binary associations. None of these classes are a-kind-of or a-part-of another class.
Thus generalization and aggregation do not apply.
ix. Modems and keyboards are input / output devices.
Generalization. The keyword “are” is the clue. Modem and Keyboard are the subclasses; InputOutputDevice
is the super class.
x. Classes may have several attributes.
Association or aggregation. It depends on your perspective and the purpose of the model whether
aggregation applies.
24. 140703-OOAD
Prepared By: SWATI SHARMA 24
UML Diagrams
xi. A person plays for a team in a certain year.
Ternary association. Person, Team, and Year are distinct classes of equal stature.
xii. A dining philosopher uses a fork.
Association. Dining philosophers and forks are completely distinct things and are therefore not in a
generalization relationship. Similarly, neither object is a part of the other nor the relationship is not
aggregation.
5 Prepare a class diagram for a graphical document editor that supports grouping. Assume that a document consists
of several sheets. Each sheet contains drawing objects, including text, geometrical objects and groups. A group is
simply a set of drawing objects, possibly including other groups. A group must contain at least two drawing
objects. A drawing object can be a direct member of at most one group. Geometrical objects include circles,
ellipses, rectangles, lines and squares.
6 Prepare a meta-model that supports only the following UML concepts: class, attribute, association, association
end, multiplicity, class name, and attribute name. Use only these constructs to build meta-model.
25. 140703-OOAD
Prepared By: SWATI SHARMA 25
UML Diagrams
State Diagram
-----------------------------------------------------------------------------------------------------------------------------
Introduction
- A state diagram is a graph in which nodes correspond to states and directed arcs correspond to transitions
labeled with event names.
- A state diagram combines states and events in the form of a network to model all possible object states
during its life cycle, helping to visualize how an object responds to different stimuli.
- A state diagram is a graph whose nodes are states and whose directed arcs are transitions between states.
- A state diagram specifies the state sequence caused by event sequence.
- State names must be unique within the scope of a state diagram.
- All objects in a class execute the state diagram for that class, which models their common behavior.
- We can implement state diagrams by direct interpretation or by converting the semantics into equivalent
programming code.
Purpose
- The state model describes those aspects of objects concerned with time and the sequencing of operations
events that mark changes, states that define the context for events, and the organization of events
and states.
- They are used to give an abstract description of the behavior of a system.
- It provides direction and guidance to the individual counties within the states.
- It specifies the possible states, what transitions are allowed between states.
- It describes the common behavior for the objects in a class and each object changes its
behavior from one state to another.
- It is used to describe the dependence of the functionality on the state of the system that
is how the functionality of an object depends on its state and how its state changes as a
result of the events that it receives.
- It describes dynamic behavior of the objects of the system.
When to use: State Diagram
- They are perfectly useful to model behavior in real time system.
- Each state represents a named condition during the life of an object during which it
satisfies some condition or waits for some event.
- It determines how objects of that class react to events.
- For each object state, it determines what actions the object will perform when it receives an event.
26. 140703-OOAD
Prepared By: SWATI SHARMA 26
UML Diagrams
State Diagram Notations
No. Name Notation Description
1 State A state is an abstraction of the values and links of
an object. State models a situation during which
some (usually implicit) invariant condition holds.
2 Transition A transition is a directed relationship between a
source state and a target state. It may be part of a
compound transition, which takes the state
machine from one state configuration to another
3 Event
Event
A transition is an instantaneous change from one
to another state
4 Change Event
When (Condition)
A change in value of a Boolean expression
5 Time Event
at (time condition)
The arrival of an absolute time or the passage of a
relative amount of time
6 Signal Event Receipt of an explicit, named, asynchronous
communication among objects.
7 Guarded
transition
[guard condition]
A guard condition is a Boolean expression that
must be true in order for a transition to occur.
8 Do activity A do activity an activity that continuous for
extended time within state.
State
27. 140703-OOAD
Prepared By: SWATI SHARMA 27
UML Diagrams
9 Entry activity An state is entered by any incoming transition the
entry activity is performed
10 Exit activity When the state is exited by any outgoing
transition the exit activity is performed
11 Nested State
Diagram
Sub machine
Diagram
A submachine state specifies the insertion of the
specification of a submachine. The state machine
that contains the submachine state is called the
containing state machine.
12 Composite
State
A state can be refined hierarchically by composite
states.
13 Activity
effect
An activity is actual behavior that can be invoked
by any number of effects
14 Initial state
point
It shows the starting state of object.
15 Final state
point
It shows the terminating state of object.
42. 140703-OOAD
Prepared By: SWATI SHARMA 42
UML Diagrams
Additional Diagram: State Diagram
1. A simple digital watch has a display and two buttons to set it, the A button and the B button. The watch has two
modes of operation, display time and set time. In the display time mode, the watch displays hours and minutes,
separated by a flashing colon. The set time mode has two sub modes, set hours and set minutes. The A button
selects modes. Each time it is pressed, the mode advances in the sequence: display, set hour, set minutes,
display, etc. Within the sub modes, the B button advances the hours or minutes once each time it is pressed.
Buttons must be released before they can generate another event. Prepare a State diagram of the watch.
43. 140703-OOAD
Prepared By: SWATI SHARMA 43
UML Diagrams
2. Draw state diagram for the control of a telephone answering machine. The machine detects an incoming call on
the first ring and answers the call with a prerecorded announcement. When the announcement is complete, the
machine records the caller’s message. When the caller hands up, the machine hangs up and shuts off. Place the
following in the diagram: call detected, answer call, play announcement, record message, caller hangs up,
announcement complete.
44. 140703-OOAD
Prepared By: SWATI SHARMA 44
UML Diagrams
4. Differentiate state and event. List different types of events. Identify states and events for a Photocopier (Zerox)
machine from the description given below and draw the state diagram for the same. Initially the machine is off.
When the operator switches on the machine, it first warms up during which it performs some internal tests.
Once the tests are over, machine is ready for making copies. When operator loads a page to be photocopied and
press ‘start’ button, machine starts making copies according to the number of copies selected. While machine is
making copies, machine may go out of paper. Once operator loads sufficient pages, it can start making copies
again. During the photocopy process, if paper jam occurs in the machine, operator may need to clean the path
by removing the jammed paper to make the machine ready.
45. 140703-OOAD
Prepared By: SWATI SHARMA 45
UML Diagrams
Sequence Diagram
-----------------------------------------------------------------------------------------------------------------------------
Introduction
- Sequence diagrams model the dynamic aspects of a software system.
- The emphasis is on the “sequence” of messages rather than relationship between objects.
- A sequence diagram maps the flow of logic or flow of control within a usage scenario into a visual diagram
enabling the software architect to both document and validate the logic during the analysis and design
stages.
- Sequence diagrams provide more detail and show the message exchanged among a set of objects over time.
- Sequence diagrams are good for showing the behavior sequences seen by users of a diagram shows only the
sequence of messages not their exact timing.
- Sequence diagrams can show concurrent signals.
Purpose
- The main purpose of this diagram is to represent how different business objects interact.
- A sequence diagram shows object interactions arranged in time sequence.
- It depicts the objects and classes involved in the scenario and the sequence of messages exchanged
between the objects needed to carry out the functionality of the scenario.
When to use : Sequence Diagram
- Sequence diagram can be a helpful modeling tool when the dynamic behavior of objects needs to be
observed in a particular use case or when there is a need for visualizing the “big picture of message flow”.
- A company’s technical staff could utilize sequence diagrams in order to document the behavior of a future
system.
- It is during the design period that developers and architects utilize the diagram to showcase the system’s
object interactions, thereby putting out a more fleshed out overall system design.
46. 140703-OOAD
Prepared By: SWATI SHARMA 46
UML Diagrams
Sequence Diagram Notations
Sr. No. Name Notation Desription
1 Object It represents the existence of an object
of a particular time.
2 Life line Lifeline represents the duration during
which an object is alive and interacting
with other objects in the system. It is
represented by dashed lines.
3 Scope It shows the time period during which
an object or actor is performing an
action.
4 Message
transition
To send message from one object to
another.
5 Message with attribute To send message with some particular
attribute
47. 140703-OOAD
Prepared By: SWATI SHARMA 47
UML Diagrams
6 Message with constraint To send message from one object to
other vy some constraint.
7 Acknowledgement It represent communication between
objects conveys acknowledgement.
8 Self message Self message occurs when an object
sends a message to itself.
9 Recursive message Self message occurs when an object
sends a message to itself within
recursive scope.
48. 140703-OOAD
Prepared By: SWATI SHARMA 48
UML Diagrams
Examples:
Sequence Diagram for library management system:-
Registration
Issue book
50. 140703-OOAD
Prepared By: SWATI SHARMA 50
UML Diagrams
Sequence Diagram For ATM Management System:-
Create account
:customer :Server
Log-in
Display banks detail
Select bank
Display all data of bank
Request for registration
Display form
Fill Form
Submit form
{Verify detail}send message {Successfully registration }
Give PIN no.
Log out
X
51. 140703-OOAD
Prepared By: SWATI SHARMA 51
UML Diagrams
Transaction
:Customer ATM : Machine
Log in
Display web page
Enter PIN no.
Send message { Successfully Login }
Show language menu
Select language
Show account menu
Select account
Open account
Select transection type
Display transection form
Submit form
Give money
Request for recipt
Give recipt
Log out
Enter detail ( Money )
{Verify balance
Modify database}Counting
X
verfy:correct
52. 140703-OOAD
Prepared By: SWATI SHARMA 52
UML Diagrams
Exceptional case
Sequence diagram for Online shopping system:-
Place order
59. 140703-OOAD
Prepared By: SWATI SHARMA 59
UML Diagrams
Activity Diagram
-----------------------------------------------------------------------------------------------------------------------------
Introduction
- An activity diagram is a type of flow chart with additional support for parallel behavior.
- This diagram explains overall flow of control.
- Activity diagram is another important diagram in UML to describe dynamic aspects of the system.
- Activity diagram is basically a flow chart to represent the flow from one activity to another activity
- The activity can be described as an operation of the system.
- The control flow is drawn from one operation to another. This flow can be sequential, branched or
concurrent. This distinction is important for a distributed system.
- Activity diagrams deals with all type of flow control by using different elements like fork, join etc.
Purpose
- Contrary to use case diagrams, in activity diagrams it is obvious whether actors can perform business use
cases together or independently from one another.
- Activity diagrams allow you to think functionally.
When to use : Activity Diagrams
- Activity diagrams are most useful when modeling the parallel behavior of a multithreaded system or when
documenting the logic of a business process.
- Because it is possible to explicitly describe parallel events, the activity diagram is well suited for the
illustration of business processes, since business processes rarely occur in a linear manner and often exhibit
parallelisms.
- This diagram is useful to investigate business requirements at a later stage.
- An activity diagram is drawn from a very high level. So it gives high level view of a system. This high level
view is mainly for business users or any other person who is not a technical person.
- This diagram is used to model the activities which are nothing but business requirements.
- So the diagram has more impact on business understanding rather implementation details.
60. 140703-OOAD
Prepared By: SWATI SHARMA 60
UML Diagrams
Activity Diagram Notations
No. Name Symbol Description
1. Activity Represent individual activity of system.
2. Transition Represents flow of data from one activity to
another.
3. Decision Decision node is a control node that accepts
tokens on one or more incoming edges and
selects outgoing edge from two or more outgoing
flows. The notation for a decision node is a
diamond-shaped symbol.
4. Initial activity Initial node is a control node at which flow starts
when the activity is invoked. Activity may have
more than one initial node. Initial nodes are
shown as a small solid circle.
5. Final activity Final node is a control final node that stops all
flows in an activity. Activity final nodes are shown
as a solid circle with a hollow circle inside. It can
be thought of as a goal notated as "bull’s eye," or
target.
6. Fork A fork in the activity diagram has a single
incoming transition and multiple outgoing
transitions exhibiting parallel behavior.The
incoming transition triggers the parallel outgoing
transitions.
7. Join A join in the activity diagram synchronizes the
parallel behavior started at a fork. Join ascertains
that all the parallel sets of activities (irrespective
of the order) are completed before the next
activity starts. It is a synchronization point in the
diagram. Each fork in an activity diagram has a
corresponding join where the parallel behavior
terminates.
Activity
61. 140703-OOAD
Prepared By: SWATI SHARMA 61
UML Diagrams
Examples
Activity Diagram for Library Management System
Issue and return book
70. 140703-OOAD
Prepared By: SWATI SHARMA 70
UML Diagrams
Additional Diagram: Activity Diagram
1. Prepare an activity diagram for computing a restaurant bill. There should be a charge for each delivered item.
The total amount should be subject to tax and a service charge of 18% for groups of six of more. For smaller
groups, there should be a blank entry for a gratuity according to the customer’s discretion. Any coupons or gift
certificates submitted by the customer should be subtracted.