The Unified Modeling Language (UML) is used to specify, visualize, modify, construct and document the artifacts of an object-oriented software intensive system under development.[1] UML offers a standard way to visualize a system's architectural blueprints, including elements such as:

                    • 3.4 Meta modeling

                          Multiplicity values and their indicators

                          Potential Multiplicity Values
                          Indicator Meaning
                          0..1 Zero or one
                          1 One only
                          0..* Zero or more
                          * Zero or more
                          1..* One or more
                          3 Three only
                          0..5 Zero to Five
                          5..15 Five to Fifteen

                          Marks for UML-supported visibility types

                          Mark Visibility type
                          + Public
                          # Protected
                          - Private
                          ~ Package
                           UML Notations
                          Association is a (*a*) relationship between two classes, where one class use another. But aggregation describes a special type of an association. Aggregation is the (*the*) relationship between two classes. When object of one class has an (*has*) object of another, if second is a part of first (containment relationship) then we called that there is an aggregation between two classes. Unlike association, aggregation always insists a direction.

                          So in summary, we can say that aggregation is a special kind of an association and composition is a special kind of an aggregation. (Association->Aggregation->Composition)



                          Structure diagrams (static)

                          Structure diagrams emphasize what things must be in the system being modeled:

                          • Class diagram: describes the structure of a system by showing the system's classes, their attributes, and the relationships among the classes.
                          • Component diagram: depicts how a software system is split up into components and shows the dependencies among these components.
                          • Composite structure diagram: describes the internal structure of a class and the collaborations that this structure makes possible.
                          • Deployment diagram: serves to model the hardware used in system implementations, and the execution environments and artifacts deployed on the hardware.
                          • Object diagram: shows a complete or partial view of the structure of a modeled system at a specific time.
                          • Package diagram: depicts how a system is split up into logical groupings by showing the dependencies among these groupings.
                          • Profile diagram: operates at the metamodel level to show stereotypes as classes with the <<stereotype>> stereotype, and profiles as packages with the <<profile>> stereotype. The extension relation (solid line with closed, filled arrowhead) indicates what metamodel element a given stereotype is extending.
                          all in one :

                          Class diagram:

                          • a class
                          • an interface
                          • a data type
                          • a component.

                          Class diagram for the class Flight / The Flight class's attribute names with their associated types/Flight class's operations mapped

                           Figure 1: Class diagram for the class Flight    Class

                          Bank Account class diagram showing the balance attribute's value defaulted to zero dollars

                          A Bank Account class diagram.

                           Inheritance is indicated by a solid line with a closed, unfilled arrowhead pointing at the super class
                           Figure 4, see caption
                          An example of inheritance using tree notation
                          Fig 5 example of inheritance using tree notation
                           An example of a bi-directional association between a Flight class and a Plane class
                          example of a bi-directional association
                          An example of a uni-directional association: The OverdrawnAccountsReport class knows about the BankAccount class, but the BankAccount class does not know about the association.
                          An example of a uni-directional association.
                          An example package element that shows its members inside the package's rectangle boundaries
                          Figure 8 caption describes image
                          An example package element showing its membership via connected lines
                          Figure 9 caption describes image
                          An example package element showing its membership via connected lines
                          Figure 10 caption describes image  Interface
                          Adding the association class MileageCredit
                          Figure 11 caption describes image
                          Example of an aggregation association
                          Figure 12 caption describes image   Aggregation
                          Composition aggregation
                          Example of a composition relationship
                          Figure 13 caption describes image 
                          Reflexive associations
                          Example of a reflexive association relationship
                          Figure 14 caption describes image
                          UML Class Diagram
                          ****************************************************************END of Class Diagrams *******************

                          Component diagram




                          Deployment diagram


                          Object diagram








                          Package diagram

                          Behavior diagrams

                          Behavior diagrams emphasize what must happen in the system being modeled:

                          • Activity diagram: represents the business and operational step-by-step workflows of components in a system. An activity diagram shows the overall flow of control.
                          • State machine diagram: standardized notation to describe many systems, from computer programs to business processes.
                          • Use case diagram: shows the functionality provided by a system in terms of actors, their goals represented as use cases, and any dependencies among those use cases.
                          UML Activity Diagram
                          State machine diagram:
                          UML Statechart Diagram
                          UML Use Case Diagram
                          Interaction diagrams

                          Interaction diagrams, a subset of behavior diagrams, emphasize the flow of control and data among the things in the system being modeled:

                          • Communication diagram: shows the interactions between objects or parts in terms of sequenced messages. They represent a combination of information taken from Class, Sequence, and Use Case Diagrams describing both the static structure and dynamic behavior of a system.
                          • Sequence diagram: shows how objects communicate with each other in terms of a sequence of messages. Also indicates the lifespans of objects relative to those messages.
                          UML Sequence Diagram
                          • Timing diagrams: are a specific type of interaction diagram, where the focus is on timing constraints.
                          Meta modeling