Object Oriented Programming(OOP) Interview Questions and Answers

OOPs stand for Object Oriented Programming system. It is the programming language technique to write programs based on the real world object each object is nothing but an instance of a class. Object means a real-world entity such as a pen, chair, table, computer, watch, etc.

Some concepts of Oops are

• Object
• Class
• Abstraction
• Encapsulation
• Inheritance
• Polymorphism
• Association
• Composition
• Aggregation
• Object cloning and more

Object concept is termed as a specific instance of a class where the object can be combined of data structures, functions and variables. Its own state, behavior and identity.

A class is simply a representation of a type of object or collections of object are called Class. It is the blueprint form or plan or template that describes the details of an object.

It is the concept of hiding the internal details and describing things in simple terms.

 In class:

Absrtract class A {}

In method:

Abstract void printstatus ();//no method body and abstract//

Encapsulation is concept of hiding of data implementation by restricting access to public methods. In other words, an attribute of an object and it contains all data which is hidden. That hidden data can be restricted to the members of that class. Levels are Public, Private, Protected Internal and Protected Internal.

In java,Variable name “Job” is kept private or encapsulated.

// save as job.java

Public class job {

Private string name;

Public string getName()

{

return name;

}

Public void setName (string name) {

this.name=name

   }

}

// save as test.java

Class test {

Public static void main (string[]  args []) {

Job s= new job ();

s.setNname(“InterviewGIG”)

system .out.Println (s.getName ());

}

}

Output: InterviewGIG

Simply, polymorphism means one name many different forms. It is nothing but assigning behaviour or value in a subclass to something that was already declared in the main class. There are two types in polymorphism

Static polymorphism: It is achieved using method Overloading

Dynamic polymorphism: It is using method Overriding

In java, we have two classes: person and employee. The employee class inherits from the person class by using the keyword extends. Here child class overrides the parent class.

Class person {

Void walk () {

    System.out.println (“can run…”);

}

}

Class employee extends person {

Void walk () {

system.out.println (“running fast…”);

}

}

Public static void main (string arg [ ]) {

Person p =new employee ();

p.walk ();

}

}

Inheritance is a concept where one class shares the structure and behaviour defined in another class. If inheritance applied on one class is called Single Inheritance, and if it depends on multiple classes, then it is called multiple Inheritances.

In java, inheritance can be used the extends keyword

Class interview {

}

Class GIG extends interview {

}

Object oriented programming is to implement all concepts like Object, abstraction, inheritance, classes, polymorphism etc. object based programming language follows all the concepts of OOPs except inheritance such as JavaScript, VBscript.

It is relationship between two objects with multiplicity.

Composition is about expressing relationships between objects. A chair example: A chair has a Seat. A chair has a back. And a chair has a set of legs. The phrase “has a” implies a relationship where the chair owns, or at minimum, uses, another object. It is this “has a” relationship which is the basis for composition.

Aggregation is also known as “HAS-A” relationship. Aggregation is a special type of association. In aggregation, objects have their own life cycle but there is an ownership. Whenever we have “HAS-A” relationship between objects and ownership then it’s a case of aggregation.

The object is away to create exact copy of an object. The clone() method of object class is used to clone an object.

Manipulators are the functions which can be used in conjunction with the insertion (<<) and extraction (>>) operators on an object. Examples are endl and setw.

It is a method used to initialize the state of an object, and it gets invoked at the time of object creation. Rules for constructor are: Constructor Name should be same as class name and Constructor must have no return type

It is a method which is automatically called when the object is made of scope or destroyed. Destructor name is also same as class name but with the tilde symbol before the name.

Inline function is a technique used by the compilers and instructs to insert complete body of the function wherever that function is used in the program source code.

Virtual function is a member function of class and its functionality can be overridden in its derived class. This function can be implemented by using a keyword called virtual, and it can be given during function declaration.

Virtual function can be achieved in C++, and it can be achieved in C Language by using function pointers or pointers to function.

An abstract class is a class which cannot be instantiated. Creation of an object is not possible with abstract class, but it can be inherited. An abstract class can contain only Abstract method.

An interface is a collection of abstract method. If the class implements an inheritance, and then thereby inherits all the abstract methods of an interface.

Friend function is a friend of a class that is allowed to access to Public, private or protected data in that same class. If the function is defined outside the class cannot access such information.

Friend can be declared anywhere in the class declaration, and it cannot be affected by access control keywords like private, public or protected.

Function overloading is defined as a normal function, but it has the ability to perform different tasks. It allows creation of several methods with the same name which differ from each other by type of input and output of the function.

Example

void add(int& a, int& b);

void add(double& a, double& b);

void add(struct bob& a, struct bob& b);

Ternary operator is said to be an operator which takes three arguments. Arguments and results are of different data types, and it is depending on the function. Ternary operator is also called as conditional operator.

Operator overloading is a function where different operators are applied and depends on the arguments. Operator,-,* can be used to pass through the function , and it has their own precedence to execute.

Example:

class complex {

double real,

imag; public: complex(double r, double i) : real(r),

imag(i) {} complex operator+(complex a, complex b);

complex operator*(complex a, complex b);

complex& operator=(complex a, complex b);

}

a=1.2, b=6

Finalize method helps to perform clean-up operations on the resources which are not currently used. Finalize method is protected, and it is accessible only through this class or by a derived class.

A parameter is a variable used during the declaration of the function or subroutine and arguments are passed to the function, and it should match with the parameter defined. There are two types of Arguments.

• Call by Value – Value passed will get modified only inside the function, and it returns the same value whatever it is passed it into the function.
• Call by Reference – Value passed will get modified in both inside and outside the functions and it returns the same or different value.

Super keyword is used to invoke overridden method which overrides one of its super class methods. This keyword allows to access overridden methods and also to access hidden members of the super class.

It also forwards a call from a constructor to a constructor in the super class.

Method overriding is a feature that allows sub class to provide implementation of a method that is already defined in the main class. This will override the implementation in the super class by providing the same method name, same parameter and same return type.

Exception is an event that occurs during the execution of a program. Exceptions can be of any type – Run time exception, Error exceptions. Those exceptions are handled properly through exception handling mechanism like try, catch and throw keywords.

Token is recognized by a compiler and it cannot be broken down into component elements. Keywords, identifiers, constants, string literals and operators are examples of tokens.

Even punctuation characters are also considered as tokens – Brackets, Commas, Braces and Parentheses.

Overloading is static binding whereas Overriding is dynamic binding. Overloading is nothing but the same method with different arguments, and it may or may not return the same value in the same class itself.

Overriding is the same method names with same arguments and return types associates with the class and its child class.

An object is an instance of a class. Objects hold any information, but classes don’t have any information. Definition of properties and functions can be done at class and can be used by the object.

Class can have sub-classes, and an object doesn’t have sub-objects.

Structure default access type is public, but class access type is private. A structure is used for grouping data whereas class can be used for grouping data and methods. Structures are exclusively used for data and it doesn’t require strict validation, but classes are used to encapsulates and inherit data which requires strict validation.

Abstraction is a good feature of OOPS, and it shows only the necessary details to the client of an object. Means, it shows only necessary details for an object, not the inner details of an object.

Access modifiers determine the scope of the method or variables that can be accessed from other various objects or classes. There are 5 types of access modifiers, and they are as follows:

1. Private
2. Protected
3. Public
4. Friend
5. Protected Friend

Sealed modifiers are the access modifiers where it cannot be inherited by the methods. Sealed modifiers can also be applied to properties, events and methods. This modifier cannot be applied to static members.

Yes, it is possible to call the base method without creating an instance. And that method should be Static method.

Doing inheritance from that class. -Use Base Keyword from derived class.

The new modifier instructs the compiler to use the new implementation instead of the base class function. Otherwise, override modifier helps to override the base class function.

There are three various types of constructors, and they are as follows:

Default Constructor: With no parameters.

Parametric Constructor: With Parameters. Create a new instance of a class and also passing arguments simultaneously.

Copy Constructor: This creates a new object as a copy of an existing object.

Early binding refers to assignment of values to variables during design time whereas late binding refers to assignment of values to variables during run time.

THIS pointer refers to the current object of a class. THIS keyword is used as a pointer which differentiates between the current object with the global object. Basically, it refers to the current object.

The default access modifier of a class is Private by default.

A pure virtual function is a function which can be overridden in the derived classbut cannot be defined. A virtual function can be declared as Pure by using the operator =0.

Example:

Virtual void function1() // Virtual, Not pure

Virtual void function2() = 0 //Pure virtual

Following are the operators that cannot be overloaded -.

• Scope Resolution (:: )
• Member Selection (.)
• Member selection through a pointer to function (.*)

Java is a simple programming language and multiple introduce complexities such as diamond problem. Inheriting stages from two different type of classes is a case which is in reality very rare and it can be achieved easily through an object association.

• It is simplicity
• It is modularity
• It is modifiability
• It is extensibility
• It is maintainability
• It is Reusability
• Effective problem solving 

There are five types of Inheritance:

• Single Inheritance
• Multiple Inheritance
• Multi-level Inheritance
• Hybrid Inheritance
• Hierarchical Inheritance

There are five types of constructors:

• Default Constructor
• Private Constructor
• Copy Constructor
• Static Constructor
• Parameterized Constructor

def __init__(self):

    # body of the constructor

_operator keyword is used.

When we declare a constructor

In this case, python does not create a constructor in our program.

Example:

class DemoClass:

    num = 101

    # non-parameterized constructor

    def __init__(self):

        self.num = 420

    # a method

    def read_number(self):

        print(self.num)

# creating object of the class

obj = DemoClass()

# calling the instance method using the object obj

obj.read_number()

Output:

420

To create empty class using pass statement:

Class test;

Pass

 Inheritance concept is used as a reuse mechanism.

In OPPs, finalize method is called just before the object is about to be garbage collected. This method overrides to minimize memory leaks, undertake cleanup activities by removing system resources.

Example:

class Student:

    # instance attributes

    def __init__(self, name, age): // self is an instant of Class

        self.name = name

        self.age = age 

# creating objects of class student

Mohan = student("mohan",25)

Ram = student("Ram",26)

# accessing object information

print("age of {} is {}".format(mohan.name, mohan.age))

print("age of {} is {}".format(ram.name, ram.age))

 {or print( mohan. __init__) //prints dictionary}

Output:

age of Mohan is 25

age of Ram is 26

Example of Encapusulation:

class student(object):

def __init__(self):  

self.name = Mohan

self._age = 25

object1 = student()

print(object1.name)

print(object1._age)

output:

mohan

25

Data abstraction can be achieved through:

• Abstract method
• Abstract class

Here are some common examples of tokens:

• Keywords
• Operators
• Strings
• Constants
• Identifiers
• Commas
• Brackets

from abc import ABC,abstractmethod

class Student (ABC):

def stu_id(self,name,age):    //Abstraction

pass

class childstudent1(student):

def stu_id(self,age):

print("stu_age is 25")

stu1 = childstu1()

stu1.stu_age(age)


Output: 
stu_age is 25

# overloading the less than operator

class Point:

    def __init__(self, x=0, y=0):

        self.x = x

        self.y = y

    def __str__(self):

        return "({0},{1})".format(self.x, self.y)

    def __lt__(self, other):

        self_mag = (self.x ** 2) + (self.y ** 2)

        other_mag = (other.x ** 2) + (other.y ** 2)

        return self_mag < other_mag

p1 = Point(2,3)

p2 = Point(-4,-5)

p3 = Point(1,-1)

# use less than

print(p1<p2)

print(p2<p3)

print(p1<p3)

output:

true

false

false

Simula is known as the first OOP Language.

• C# Language
• C++ Language
• Java Language
• Python Language
• JavaScript Language
• PHP Language
• Ruby Language
• Scala Language
• Visualbasic.NET Language