1. What is Object-Oriented Programming?

Object-Oriented Programming is a programming paradigm defined using objects instead of only functions and methods. The objects contain data, called attributes, and methods that provide the logic or supporting code for a given logic unit. Some of its main principles include inheritance, polymorphism, encapsulation, and abstraction.

2. What are some advantages of Object-Oriented Programming

• Problems of any level of complexity can be supported
• Highly complex problems can be handled
• It provides an efficient mechanism for code reuse using inheritance which reduces redundancy
• It provides a mechanism for hiding data
• It is based on a bottom-up approach
• It offers flexibility through polymorphism
• It improves the maintainability of the code

3. What are the main principles of OOPs?

Object-Oriented Programming has four main principles, and they are the following:

• Inheritance
• Encapsulation
• Polymorphism
• Data Abstraction

4. What is a class?

A class defines the definition of an object, and thus, it can be used to create objects at runtime. It provides the data structure, initial values for the attributes, and methods that provide the logic for the intended behavior of the object.

1class Test {
2       // member variables
3       // methods
4}

The class does not consume memory at runtime. A class refers to a logical entity- for example, a vehicle may be defined as a class.

5. What is an object?

An object refers to the runtime instance created from the class during program execution. Objects can refer to real-world entities that have attributes and methods (logic) to support the behavior. Objects consume memory space only after they are initialized.

1// Declaring and initializing an object
2let t = new Test();

6. What is a constructor?

A constructor is a method that is used for initializing the objects, from their classes. They are special types of methods that have the same name as the class, and they can be parameterless or initialize values for the attributes of the object.

There are three types of constructors:

– Default Constructor – Without parameters

– Parametric Constructor – Includes parameters to create a new instance of a class and also pass arguments simultaneously to provide different values to the distinct objects at the time of their creation

– Copy Constructor – Creates a new object as a copy of an existing object

xxxxxxxxxx

class Test {

​

    constructor(id, name) {

        this.id = id;

        this.name = name;

    }

​

    // The 'constructor' acts as a default constructor when not sending parameter value

}

​

let ob1 = new Test();

let ob2 = new Test(123, "TestPerson");

​

console.log(ob1.id);

console.log(ob1.name);

​

console.log(ob2.id);

console.log(ob2.name);

7. What are access modifiers?

Access modifiers specify the scope of accessibility of a data member, method, constructor or class. Depending on the language there can be various modifiers, but there are three main and shared betweem all of the OOP languages, that are fundamental.

8. Explain the concept of inheritance

Inheritance is one of the main features of object-oriented programming which allows classes to inherit properties and methods from other classes. This helps improve code reuse.

For example, we can have a base class called animal, that may define the common properties shared by all animals. Then, we can define child classes such as: mammals, reptiles, etc. that will inherit the common attributes of all animals but will be able to define their own specific attributes and methods.

However, there are some limitations of the process of inheritance, for example, it requires more processing time for the programs as it has to navigate various classes during execution. Also, due to inheritance, the parent and child class are tightly coupled. When any changes are needed in the logic, it may require changes in both parent and child classes.

If the inheritance is not correctly implemented, it can lead to undesired results.

9. What are the various types of inheritance?

The various types of inheritance include:

• Single inheritance - A class inherits the properties of a single parent class.

1class A {
2  //parent class code
3}
4
5class B extends A {
6  //child class code
7}

• Multiple inheritances - An object or class can inherit features from more than one parent object or parent class. Not supported in all programming languages.
• Multi-level inheritance - One class has more than one parent class but at different levels of inheritance

1class A {
2    // parent class code
3}
4class B extends A {
5    // your code
6}
7class C extends B {
8    // your code
9}

• Hierarchical inheritance - One parent can have one or more child/sub/derived classes

1class A{
2  //parent class code
3}
4class B extends A {
5   //child class code
6}
7class C extends A {
8    //child class code
9}

• Hybrid inheritance - Combination of more than one type of inheritance in a single program

1	     A
2       / 
3      B     C
4    /         
5  D           E

10. What is polymorphism?

Polymorphism is a significant feature of object-oriented programming that represents the ability for existence in multiple forms. A single interface can be implemented in multiple ways by providing various definitions and implementations.

In Object-Oriented Programming languages, there are two types of polymorphism: 1. Static Binding (or Compile time) Polymorphism, e.g., Method Overloading

1function add(a, b){
2  return a+b;
3}

2. Dynamic Binding (or Runtime) Polymorphism, e.g., Method overriding

xxxxxxxxxx

class Phone{

    message(){

        console.log("Message");

    }

}

​

//Extending the Phone class

class iPhone extends Phone{

    //Overriding message() of Phone class

    sms(){

        console.log("iPhone Message");

    }  

}

​

let mess = new iPhone();

mess.sms();

11. What is method or operator overloading?

The method overloading is a feature of object-oriented programming in which multiple methods can have the same method name with different arguments. The call to the method is resolved based on the arguments.

Operator overloading means that depending on the arguments passed, the operators’ behavior can be changed. However, it works only for user-defined types.

12. What do you know about encapsulation?

Encapsulation is an important feature of object-oriented programming which allows the binding of the data and the logic together in a single entity. It also allows the hiding of data, so it is also known as a combination of data-hiding and abstraction.

• Declaring the variables of a class as private
• Providing public setter and getter methods to modify and view the variables' values

13. What is an abstraction?

Abstraction shows only the necessary details to the client of an object. This means that it shows only required details for an object, not the inner constructors of an object.

For example, if you turn on the TV, you do not need to know the inner mechanism needed to do that, so whatever is needed to turn it on will be shown using an abstract class.

You can achieve abstraction in two ways:

1. Using Abstract Class Abstract Class is a class which is declared with an abstract keyword and cannot be instantiated. Few pointers to create an abstract class:

• It can contain abstract and non-abstract methods
• It can contain constructors and static methods as well
• It can contain final methods which force the subclass not to change the body of the method

You cannot create an instance of an abstract class since it lacks implementation logic in its methods. You first need to create a subclass that implements all the methods before an object can be initialized.

1class MyAbstractClass {
2  abstractMethod() {
3    throw new Error("This method is abstract and must be overridden");
4  }
5  
6  display() {
7    console.log("method");
8  }
9}

2. Using Interface An interface is a blueprint of a class that contains static constants and abstract methods. It represents the IS-A relation. You need to implement an interface to use its methods or constants.

xxxxxxxxxx

class Main {

  constructor() {

    const c1 = new Ford();

    c1.start();

    const c2 = new Toyota();

    c2.start();

  }

}

​

// Creating Car class

class Car {

  start() {}

}

​

// creating classes that extends Car class

class Ford extends Car {

  start() {

    console.log("Ford Car");

  }

}

​

class Toyota extends Car {

  start() {

    console.log("Toyota Car");

  }

}

​

new Main();