OOP Concepts: Interview Questions and Answers for Junior Web Developers

OOP Concepts Answer Sheet for Junior Web Developers

OOP Concepts: Interview Questions and Answers for Junior Web Developers

1. Encapsulation

Q: What is encapsulation, and why is it important?

A: Encapsulation is a fundamental principle of object-oriented programming that involves bundling data (attributes) and methods (functions) within a single unit or class, while restricting direct access to some of the object’s components. It’s important because:

1. It helps in data hiding, protecting the internal state of an object from unauthorized access.
2. It reduces complexity by separating the internal implementation from the external interface.
3. It improves maintainability by allowing changes to the internal implementation without affecting the external code that uses the class.

Q: How can you achieve encapsulation in JavaScript?

A: In JavaScript, encapsulation can be achieved through several mechanisms:

1. Using closures to create private variables and methods:

   function Counter() {
     let count = 0;
     this.increment = function() {
       count++;
     };
     this.getCount = function() {
       return count;
     };
   }
   

2. Using ES6 classes with private fields (prefixed with #):

   class Counter {
     #count = 0;
     increment() {
       this.#count++;
     }
     getCount() {
       return this.#count;
     }
   }
   

3. Using Symbol to create non-enumerable properties:

   const _count = Symbol('count');
   class Counter {
     constructor() {
       this[_count] = 0;
     }
     increment() {
       this[_count]++;
     }
     getCount() {
       return this[_count];
     }
   }
   

Q: Can you bypass encapsulation? If so, how?

A: While encapsulation aims to protect data, it’s not always foolproof in JavaScript. Here are some ways encapsulation can be bypassed:

1. Using the Object.getOwnPropertySymbols() method to access Symbol-based private properties.
2. Overwriting prototype methods to gain access to closure-based private variables.
3. Using reflection techniques like Reflect.get() or Object.getOwnPropertyDescriptors().

However, it’s important to note that bypassing encapsulation is generally considered bad practice and should be avoided in production code.

2. Inheritance

Q: What is inheritance, and how does it work?

A: Inheritance is a mechanism in object-oriented programming that allows a new class to be based on an existing class. The new class (child or derived class) inherits properties and methods from the existing class (parent or base class). In JavaScript, inheritance works through prototypal inheritance.

Example:

class Animal {
  constructor(name) {
    this.name = name;
  }
  speak() {
    console.log(`${this.name} makes a sound.`);
  }
}

class Dog extends Animal {
  speak() {
    console.log(`${this.name} barks.`);
  }
}

const dog = new Dog('Rex');
dog.speak(); // Output: Rex barks.

Q: What is the difference between single and multiple inheritance in JavaScript (if applicable)?

A: JavaScript only supports single inheritance through its prototype chain. This means a class can only inherit from one parent class. However, JavaScript provides alternatives to achieve similar functionality to multiple inheritance:

1. Composition: Combining objects to create more complex ones.
2. Mixins: Adding properties and methods from multiple source objects to a target object.
3. Interfaces: While not a native feature, can be simulated to define a contract for multiple unrelated classes.

Q: How does super() function work in JavaScript?

A: The super() function in JavaScript is used in class constructors to call the constructor of the parent class. It ensures that the parent class is properly initialized before the child class adds its own properties or overrides methods.

Key points about super():

1. It must be called before using this in the constructor of a derived class.
2. It’s used to pass arguments to the parent class constructor.
3. Outside constructors, super can be used to call methods on the parent class.

Example:

class Animal {
  constructor(name) {
    this.name = name;
  }
}

class Dog extends Animal {
  constructor(name, breed) {
    super(name); // Call the parent constructor
    this.breed = breed;
  }
}

const dog = new Dog('Rex', 'Labrador');
console.log(dog.name, dog.breed); // Output: Rex Labrador

3. Polymorphism

Q: What is polymorphism, and how does it relate to method overriding?

A: Polymorphism is the ability of objects of different classes to be treated as objects of a common base class. It allows methods to behave differently based on the object they are acting upon. Method overriding is a key aspect of polymorphism, where a subclass provides a specific implementation for a method that is already defined in its parent class.

Q: How does JavaScript implement polymorphism?

A: JavaScript implements polymorphism primarily through:

1. Method Overriding: Subclasses can redefine methods inherited from parent classes.
2. Duck Typing: Objects are identified by their behavior (methods and properties) rather than their class.
3. Function Overloading (simulated): While JavaScript doesn’t support true function overloading, it can be simulated by checking the number or types of arguments.

Example of method overriding:

class Shape {
  area() {
    return 0;
  }
}

class Circle extends Shape {
  constructor(radius) {
    super();
    this.radius = radius;
  }
  area() {
    return Math.PI * this.radius ** 2;
  }
}

class Rectangle extends Shape {
  constructor(width, height) {
    super();
    this.width = width;
    this.height = height;
  }
  area() {
    return this.width * this.height;
  }
}

function printArea(shape) {
  console.log(`Area: ${shape.area()}`);
}

printArea(new Circle(5));     // Output: Area: 78.53981633974483
printArea(new Rectangle(4,5)); // Output: Area: 20

Q: What is the difference between compile-time and run-time polymorphism in JavaScript (if applicable)?

A: JavaScript, being an interpreted language, primarily uses run-time polymorphism. The distinction between compile-time and run-time polymorphism is less relevant in JavaScript compared to statically-typed languages.

Run-time polymorphism in JavaScript:

• Method overriding
• Dynamic method dispatch based on the actual object type at runtime

While JavaScript doesn’t have true compile-time polymorphism, TypeScript (a typed superset of JavaScript) introduces concepts like method overloading during the compilation phase.

4. Data Abstraction

Q: What is data abstraction?

A: Data abstraction is the process of hiding complex implementation details and showing only the essential features of an object. It involves creating a simplified view of an object that represents its core functionality without exposing unnecessary details.

Q: How can you achieve abstraction in JavaScript?

A: Abstraction in JavaScript can be achieved through:

1. Classes and Objects: Defining classes that represent abstract concepts.
2. Interfaces: Though not native to JavaScript, can be simulated to define a contract for classes.
3. Abstract Classes: Can be simulated by throwing errors for methods that should be implemented by subclasses.

Example of an abstract class:

class AbstractVehicle {
  constructor() {
    if (new.target === AbstractVehicle) {
      throw new Error("Cannot instantiate abstract class");
    }
  }
  
  start() {
    throw new Error("Method 'start()' must be implemented");
  }
}

class Car extends AbstractVehicle {
  start() {
    console.log("Car started");
  }
}

// const vehicle = new AbstractVehicle(); // Throws error
const car = new Car();
car.start(); // Output: Car started

Q: What is the difference between abstraction and encapsulation?

A: While both abstraction and encapsulation are related to hiding complexity, they serve different purposes:

Abstraction:

• Focuses on hiding complex implementation details and showing only essential features.
• Deals with the design level.
• Helps manage complexity by providing a simplified view of objects.

Encapsulation:

• Focuses on bundling data and methods that operate on that data within a single unit.
• Deals with the implementation level.
• Protects the internal state of an object from unauthorized access.

In essence, abstraction is about “what” an object does, while encapsulation is about “how” it does it.

5. Interface

Q: What is an interface, and how is it different from a class?

A: An interface is a contract that specifies a set of methods that a class must implement. It defines the “what” but not the “how” of a class’s behavior. In JavaScript, interfaces are not a native language feature but can be simulated.

Differences from a class:

1. Interfaces only declare method signatures without implementation.
2. Classes can implement multiple interfaces, but can only inherit from one class.
3. Interfaces cannot be instantiated.

Q: What’s the role of abstract methods in an interface?

A: Abstract methods in an interface define the method signatures that implementing classes must provide. They establish a contract for the behavior of implementing classes without specifying how that behavior should be implemented.

Q: How does JavaScript simulate interfaces?

A: JavaScript can simulate interfaces through various techniques:

1. Using classes with abstract methods:

class DataProcessorInterface {
  process(data) {
    throw new Error("Method 'process(data)' must be implemented");
  }
}

class CSVProcessor extends DataProcessorInterface {
  process(data) {
    console.log("Processing CSV data");
  }
}

2. Using objects to define method signatures:

const DataProcessorInterface = {
  process(data) {}
};

function implementsInterface(obj, interface) {
  return Object.keys(interface).every(method => typeof obj[method] === 'function');
}

const csvProcessor = {
  process(data) {
    console.log("Processing CSV data");
  }
};

console.log(implementsInterface(csvProcessor, DataProcessorInterface)); // true

6. Abstract Base Classes

Q: What is an abstract class, and how is it different from a concrete class?

A: An abstract class is a class that is meant to be inherited from, but not instantiated directly. It may contain both implemented methods and abstract methods (methods without implementation). A concrete class, on the other hand, can be instantiated and typically has all its methods implemented.

Differences:

1. Abstract classes cannot be instantiated; concrete classes can.
2. Abstract classes may contain abstract methods; concrete classes have all methods implemented.
3. Abstract classes are used as base classes for inheritance; concrete classes are typically the end of the inheritance chain.

Q: Can you instantiate an abstract class in JavaScript?

A: JavaScript doesn’t have built-in support for abstract classes, but you can simulate them. When simulating abstract classes, you can prevent instantiation by throwing an error in the constructor if it’s called directly.

Example:

class AbstractClass {
  constructor() {
    if (new.target === AbstractClass) {
      throw new Error("Cannot instantiate abstract class");
    }
  }
  
  abstractMethod() {
    throw new Error("Method 'abstractMethod()' must be implemented");
  }
  
  concreteMethod() {
    console.log("This is a concrete method");
  }
}

class ConcreteClass extends AbstractClass {
  abstractMethod() {
    console.log("Implementation of abstract method");
  }
}

// const abstract = new AbstractClass(); // Throws error
const concrete = new ConcreteClass();
concrete.abstractMethod(); // Output: Implementation of abstract method
concrete.concreteMethod(); // Output: This is a concrete method

Q: Why would you use an abstract class instead of a concrete class?

A: Abstract classes are used for several reasons:

1. To define a common interface for a set of subclasses.
2. To provide some common implementation that subclasses can use or override.
3. To enforce certain methods to be implemented by subclasses.
4. To represent concepts that are abstract in nature and shouldn’t be instantiated directly.

Abstract classes are particularly useful when you want to define a base class that provides a common structure for a family of related classes, while ensuring that certain behaviors are implemented by the subclasses.

Conclusion

Feel confident and prepared as you venture into your first job interview! Your skills in OOP are valuable, and with dedication and practice, you can achieve great success.

Good luck on your journey to becoming a proficient web developer!