Object Oriented Programming

Object Oriented Programming (OOP) is a programming paradigm where the complete software operates as a bunch of objects talking to each other. An object is a collection of data and methods that operate on its data. OOPS is abbreviated as Object Oriented Programming system in which programs are considered as a collection of objects.

A class is simply a representation of a type of object. It is the blueprint/ plan/ template that describes the details of an object.

An object is an instance of a class. It has its own state, behavior, and identity.

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

A class can have sub-classes, and an object doesn't have sub-objects.

Encapsulation, Inheritance, Polymorphism and Abstraction.

Encapsulation is 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, Protected, Private, Internal and Protected Internal. Encapsulation is referred to one of the following two notions:

• Data hiding: a language feature to restrict access to members of an object.
• Bundling of data and methods together: data and methods that operate on that data are bundled together.

Inheritance is a concept where one class shares the structure and behavior 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 Inheritance.

Abstraction is a good feature of OOPS, and it shows only the necessary details to the client of an object. Means, it shows only required details for an object, not the inner constructors, of an object. Example – When you want to switch On television, it not necessary to show all the functions of TV. Whatever is required to switch on TV will be showed by using abstract class.

Polymorphism is nothing but assigning behavior or value in a subclass to something that was already declared in the main class. Simply, polymorphism takes more than one form

An abstract class is a class which cannot be instantiated. Creation of an object is not possible with an abstract class, but it can be inherited. An abstract class can contain only Abstract method. Java allows only abstract method in abstract class while for other languages allow non-abstract method as well.

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

A constructor is a method used to invoke the object creation process by initializing the state of the object. The name of the constructor should be the name of the class ideally and may vary depends on the type of programming language. A constructor must not have any return type. There are three various types of constructors:

• Default Constructor – With no parameters
• Parametric Constructor – with Parameters. Create a new instance of a class and also passing arguments simultaneously
• Copy Constructor – Which creates a new object as a copy of an existing object

A destructor is a method which is automatically called when the object is made of scope or destroyed. A constructor must not have any return type.

An 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

A virtual function is a member function of a 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

A 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 an as a normal function, but it can perform different tasks. It allows the creation of several methods with the same name which differ from each other by the type of input and output of the function.

Method overriding is a feature that allows a subclass to provide the implementation of a method that overrides in the main class. This will overrides the implementation in the superclass by providing the same method name, same parameter and same return type

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

Access modifiers determine the scope of the method or variables that can be accessed from other various objects or classes

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.

A parameter is a variable used during the declaration of the function or subroutine and arguments are passed to the an, 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

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

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 associated with the class and its child class.

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 a derived class.

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

Multiple inheritances are the process of extending the behaviors of multiple classes by a single class. It creates an ambiguous situation at the time of runtime to decide about which class’ behavior has to be executed. C++ supports multiple inheritances whereas Java doesn't support. The ambiguity and complex issues create a diamond problem which is defined as to extend which parent class upon extending multiple classes.

Static binding is also called as early binding which happens at compile time whereas Dynamic binding is called late binding which happens at the time of run time.
Example of static binding is method overloading and dynamic binding is method overriding. The process of binding for static, final and private methods will always be done at compile time whereas the overriding is done at runtime. The process of binding overloaded methods is called static whereas the binding of overridden methods is called dynamic.

Operator overloading is sometimes called as ad-hoc polymorphism which is defined as different operators will have different mechanism based on the placement of operators and the arguments.
In operator overloading, the semantics of the programming language is redefined which is not usually recommended. In case of Java programming language, it was decided by the creators not to use this feature as Java is a production language mostly.

Exception handling is the feature available in most of the object-oriented programming languages which are defined as the process of handling the exceptions during the execution of program flow. The flow of execution should be altered based on the outcome of the exception of aroused. The general blocks of exception handling include try, catch and throw for the most of programming languages like C++, Java etc. In try block the code needs to be executed will be placed and catch block will handle the exception and throw block will return the type of exception and error if it can’t be handled. This is the safest way of handling applications to safeguard the flow of the working application.

he main benefits of the OOPS concepts are modularity, extensibility, simplicity, reusability, maintainability, modifiability etc. The complexity of the programming can be reduced and the coding structure can be made clear. The different complex functionalities can be decoupled using different classes and implementation methods around the application. The reusability feature provides minor changes in the code whenever needed, which provides the adaptability for the code changes or functionality changes.

The objects of the different classes can be reused in different implementation classes to use its features completely. The maintenance process becomes easier if the code is maintained in an organised way.