OOAD MATERIALS FOR BCA

OOAD  MATERIALS FOR BCA

Object-Oriented Analysis and Design is referred to as OOAD. It is an approach of software engineering that emphasises on leveraging objects and their interactions to model systems. Object-oriented programming (OOP), which emphasises the organisation of software systems around reusable and modular objects, is the foundation upon which OOAD is built.

There are multiple steps to the OOAD process, including analysis, design, and implementation. Here is a quick summary of each stage:

Analysis: To comprehend the problem domain, the software requirements are gathered and examined at this step. The main emphasis is on identifying the system's key objects, together with their characteristics and connections to other items. To model the behaviour of the system, use cases, scenarios, and diagrams like class diagrams, activity diagrams, and sequence diagrams are frequently utilised.

Design: The design step starts when the analysis is finished. The objective is to translate the requirements into a thorough, implementable design. To depict the system's structure and behaviour, class diagrams, object diagrams, and other design artefacts must be created. To provide a modular and extensible design, design principles like polymorphism, inheritance, and encapsulation are used.

Implementation: A programming language is used to implement the system at this level. The code is written using the design artefacts from the previous step as a guide. Due to their support for the OOAD concepts and principles, object-oriented programming languages like Java, C++, or Python are frequently utilised for implementation.

The following fundamental ideas are highlighted by OOAD:

The basic building elements of an object-oriented system are objects. They communicate with one other through messages and encapsulate data and behaviour.

Classes: When developing objects, classes serve as models or templates. They specify the properties and operations that class objects will have.

The ability to derive new classes from existing classes and inherit their characteristics is known as inheritance. It promotes the development of hierarchical relationships between classes and permits code reuse.

Polymorphism: Polymorphism enables the treatment of objects from many classes as instances of a single superclass. It makes the system design extensible and flexible.

In the software business, OOAD is frequently used to create complicated systems. It encourages the modularization and reuse of code, which enhances scalability, flexibility, and maintainability. OOAD assists in developing software that accurately reflects the issue domain seen in real-world problems and is simpler to comprehend and update over time. It does this by modelling systems using objects and their interactions.

UNIT - I

Syllabus: The Object Model-The Evolution of the Object Model: The generations of programming languages, the topology of Programming languages. Foundations of the Object Model: Object Oriented Analysis, Object Oriented design, Object Oriented Programming. Elements of the Object Model: Programming Paradigm(programming style), The Major and Minor Elements of the Object Models, Abstraction, Encapsulation, Modularity, Hierarchy(single inheritance, multiple inheritance, Aggregation), Static and Dynamic Typing, Concurrency, Persistence.

The object model:

Object-oriented technology is built on a sound engineering foundation, whose elements we collectively call the object model of development or simply the object model. The object model encompasses the principles of abstraction, encapsulation, modularity, hierarchy, typing, concurrency, and persistence.

The evaluation of the Object Model:

In this section we will examine the evolution of the tools of our profession to help us understand the foundation and emergence of objectoriented technology.

The Generations of Programming Languages

Wegner has classified some of the more popular high-order programming languages in generations arranged according to the language features they first introduced.

■ First-generation languages (1954–1958):

 FORTRAN I                  Mathematical expressions

ALGOL 58                     Mathematical expressions

Flowmatic                     Mathematical expressions

IPL V                            Mathematical expressions 

■ Second-generation languages (1959–1961)

 FORTRAN II                          Subroutines, separate compilation

ALGOL 60                              Block structure, data types

COBOL                                   Data description, file handling

Lisp                                       List processing, pointers, garbage collection

■ Third-generation languages (1962–1970)

PL/1                                      FORTRAN + ALGOL + COBOL

ALGOL 68                              Rigorous successor to ALGOL 60

Pascal                                    Simple successor to ALGOL 60

Simula                                   Classes, data abstraction

■ The generation gap (1970–1980)

C                                           Efficient; small executables

FORTRAN 77                          ANSI standardizatio

■ Object-orientation boom (1980–1990)

 Smalltalk 80                         Pure object-oriented language

C++                                      Derived from C and Simula

Ada83                                    Strong typing; heavy Pascal influence

Eiffel                                      Derived from Ada and Simula

■ Emergence of frameworks (1990–today)

Visual Basic                           Eased development of the graphical user interface (GUI) for Windows applications

Java                                      Successor to Oak; designed for portability Python                                    Object-oriented scripting language

J2EE                                      Java-based framework for enterprise computing

.NET                                      Microsoft’s object-based framework

Visual C#                              Java competitor for the Microsoft .NET Framework

Visual Basic .NET                   Visual Basic for the Microsoft .NET Framework

 

Topologies of Programming languages:

The Topology of First- and Early SecondGeneration Programming Languages

       Let’s consider the structure of each generation of programming languages. In below Figure, we see the topology of most first- and early second-generation programming languages. By topology, we mean the basic physical building blocks of the language and how those parts can be connected. In this figure, we see that for languages such as FORTRAN and COBOL, the basic physical building block of all applications is the subprogram (or the paragraph, for those who speak COBOL).

·       Applications written in these languages exhibit a relatively flat physical structure, consisting only of global data and subprograms.

·       The arrows in this figure indicate dependencies of the subprograms on various data.

During design, one can logically separate different kinds of data from one another, but there is little in these languages that can enforce these design decisions. 

CLICK THE FOLLOWING URL FOR UNIT WISE NOTES:

TEXT BOOK WISE MATERIALS

  OOAD UNIT-1 NOTES

OOAD UNIT - 2

OOAD UNIT - 3

OOAD UNIT - 4

🆕 OOAD LAB PROGRAMS