Knowledge in OOPS
Object Oriented Programming Methodology(OOPM/OOPS) Interview Question
Interview Questions on OOPS/OOPM
Kratika Agrawal
Object oriented programming with C#
This document gives exposure to basic concepts of object oriented programming when combined with the c#. gives understanding of OOPs functionality in a c# program.
Aditya Sethi
OBJECT ORIENTED PROGRAMMING WITH C++
1.1 Programming Paradigms 1.2 Basic concepts Of Object Oriented Programming 1.3 Benefits Of OOP 1.3.1 Structure of C++ 1.3.2 Application of C++ 1.4 Tokens, Keywords, Constants 1.4.1 Data Types 1.4.2 Operators And Expressions 1.4.3 Control Flow 1.4.4 Arrays 1.4.5 Strings 1.4.6 Pointers 1.5 Classes and Objects 1.5.1 Specifying a Class 1.5.2 Creating objects 1.5.3 Accessing class Members 1.6 Functions in C++ 1.7 Constructors and Destructor
Shantha Kumar . V
OBJECT ORIENTED ANALYSIS AND 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 foster better stakeholder communication and product quality. 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. Contents 1 History 2 Overview 3 Object-oriented analysis 4 Object-oriented modeling 5 See also 6 References 7 Further reading 8 External links History 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 This section may require cleanup to meet Wikipedia's quality standards. The specific problem is: remove duplications, shorten the waterfall descriptions, and make the statements more concise Please help improve this section if you can. (January 2014) (Learn how and when to remove this template message) 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". The Waterfall Model. OOAD is conducted in an iterative and incremental manner, as formulated by the Unified Process. 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.
OBJECT ORIENTED PROGRAMMING WITH C
C programmers have been using something like object oriented programming for years. They called it good modularity. The classic example of "object-oriented C" is the standard FILE structure and its family of functions fopen, fclose, fread, fwrite, fprintf, etc. Only the "methods" of the file object, fopen etc., access the members of FILE. The FILE functions are examples of good, modular, manageable code. A more accurate term for this type of programming is "structure driven". Structure-driven programs consist of data structures and functions that support them. The difference may only be semantic, but FILE objects don't have any allowance for inheritance or polymorphism. Structure members and functions that operate on them are not encapsulated into a single object. Adding More OOPness This article describes a technique which adds inheritance, polymorphism, and encapsulation to the familiar structure-driven style. The steps of this technique (listed in Table 1) are chosen to work with a particular implementation of inheritance. Consider the structures: struct s1 { int x; int y; }; struct s2 { int x; int y; int z; }; Suppose there is a structure of type s2 and a pointer to type s1. struct s1 *s1p; struct s2 s2s; s1p = &s2s; In almost all C compilers, s1p->x would be the same as s2s.x, and s1p->y would be the same as s2s.y. You could say that structure s2 inherited x and y from structure s1. Any function that expected a pointer to s1 could instead take a pointer to s2 and could correctly address x and y and safely ignore z. Listing 1 illustrates how to utilize this technique in an easy, self-documenting way. By using #define to define a class, S1, and using this definition to describe a subclass, S2, we assure that any changes to the S1_CLASS definition are automatically reflected in its subclass S2_CLASS at compile time. An object is an instance of a class. In Listing 1, C's typedef permits objects to be declared. Coding Conventions I observe certain conventions when writing methods for this OOP technique. The first argument to a method is always a pointer to the object calling the method. Many C++ translators do the same thing. The first argument to a method is always named this, clarifying references to the calling object. All program code for a particular class is always in the same .c file. Methods are given exactly the same function name as the pointers to those methods. These functions are static, so they don't interfere with other functions of the same name in other files. When writing an abstract base class's methods, write functions for methods that are defined to be subclass implemented. You may simply print a message to the effect that the method is not available. All constructors are named in the form new_CLASS(). The only arguments in constructors are for initialization. The template in Listing 2 is the basis for all constructors. If the constructor is a base class, remove all SUPER_CLASS references from this template. Destructors have a format that reverses the inheritance process. Destructor names have the form destroy_CLASS(). The first, and usually only, argument is a pointer to the object being destroyed. The second template in Listing 2 is the general form of a destructor. Prior Art Eric White described another technique for writing "truly" object-oriented programs in the February issue of The C Users Journal. There are some differences between the technique I am suggesting and his. This technique does not require any data structures other than those required by the objects. There is no specific CLASS structure and no specific OBJECT structure like in White's technique. This technique does not require the use of any additional functions such as White's message function. Classes and subclasses are defined using C's #deine directive. Methods are inherited from superclasses in a subclass's constructor, like White's, but no function is required to register new methods. There are no separate constructors and destructors for CLASS and OBJECT. Constructors and destructors have more responsibility for inheritance and polymorphism. Scope is used to supply a rudimentary form of polymorphism, an issue not directly addressed by White. The resulting syntax of this technique is closer to C+ + than White's. Compare the following three object-oriented methods of having a circle draw itself. The first example is C++, the second uses White's technique, and the third uses the technique described here. 1. circle.draw(radius); 2. message(&circle,DRAW,radius); 3. circle->draw(circle,radius); This similarity to C++ was important to me. Most of the OOP code I have seen in articles has been in C++, and I did not want to have to make a large mental jump to get from C+ + to code I could use. An Example Application Many applications need to deal with lists. Sometimes these lists are arrays, sometimes they are linked lists, some- times they are views of database records. This example will develop a LIST_CLASS. The goal is to create a class that will allow an application to have uniform access to all types of lists, without the programmer having to concern himself with how the list is stored. I developed this object when I needed a selector window. The selector window is used as a menu and chooses a record from a data table. The SELECTOR object had a LIST pointer as a member. Concrete sub-classes of ARRAY_LIST_CLASS and PINNACLE_LIST_CLASS were both used by the SELECTOR, fulfilling the 00 requirement that a subclass can be used in place of a superclass. I chose the Pinnacle library for two reasons. First, it is a good, modular, "structure-driven" library. I was able to add an OO layer to it by encapsulation. The second reason is availability. Pinnacle is a commercial product, but a free trial disk is available from Vermont Database Corporation. The trial diskette will suffice if you want to try these programs yourself.
CONCEPT OF FRIEND CLASS
A friend function of a class is defined outside that class' scope but it has the right to access all private and protected members of the class. Even though the prototypes for friend functions appear in the class definition, friends are not member functions. A friend can be a function, function template, or member function, or a class or class template, in which case the entire class and all of its members are friends. To declare a function as a friend of a class, precede the function prototype in the class definition with keyword friend as follows − class Box { double width; public: double length; friend void printWidth( Box box ); void setWidth( double wid ); }; To declare all member functions of class ClassTwo as friends of class ClassOne, place a following declaration in the definition of class ClassOne − friend class ClassTwo; Consider the following program − Live Demo #include using namespace std; class Box { double width; public: friend void printWidth( Box box ); void setWidth( double wid ); }; // Member function definition void Box::setWidth( double wid ) { width = wid; } // Note: printWidth() is not a member function of any class. void printWidth( Box box ) { /* Because printWidth() is a friend of Box, it can directly access any member of this class */ cout
OOPS concept in java
This file contains basic oops concepts of java which every student must know before advanced concepts.
kaushal shah
How OOPS concept in java works?
This file describes the most crucial oops concept that you should know if you want to become a java developer. This would also explain working of those modules.
Object Oriented Programming:C++
Contents covered in this pdf regarding whole c++.In this pdf there is detailed information with concepts and programs.
Kilari Harshitha Naidu
Object Oriented Programming: Inheritance
Contents covered in this ppt regarding Inheritance.In this ppt there is detailed explanation with programs related to the topic.
Object Oriented Programming: Operator Overloading
Contents covered in this ppt regarding object Oriented Programming.In this ppt there is detailed concepts with example programs.
OOPS B-Tech(CSE) 4th Semester IP University
This is the Akash book for the subject: OOPS for the sessionals exam (2017-18). These contain the questions that are asked in the sessionals exams. Study the questions well and verify your answers. Questions are repeated in exams so study them well. This will help you score well in exams. Also, study these for the sessionals as the questions are repeated.
Saahil