Master Object-Oriented Programming in JavaScript: 4 Principles of OOPS

Master Object-Oriented Programming in JavaScript: 4 Principles of OOPS


Understanding the Essence of Object-Oriented Programming in JavaScript

When it comes to programming in JavaScript, one concept that stands out is Object-Oriented Programming (OOP). In this article, we will delve into the world of OOP in JavaScript and explore its significance in building robust and scalable applications. So, let’s embark on this exciting journey of understanding the core principles and techniques of object-oriented programming in the JavaScript ecosystem.

The Basics of Object-Oriented Programming

Objects: The Building Blocks of JavaScript Programs

At the heart of object-oriented programming in JavaScript lies the concept of objects. Objects can be seen as self-contained entities that encapsulate both data and behavior. They serve as the building blocks for constructing complex programs. Let’s take a look at a simple example to illustrate this idea:

// Creating a person object
let person = {
  name: "John Doe",
  age: 25,
  profession: "Software Engineer",
  introduce: function() {
    console.log("Hi, I'm " + + ", a " + this.profession + ".");

// Accessing properties and invoking methods
console.log(;         // Output: "John Doe"
console.log(person.age);          // Output: 25
person.introduce();               // Output: "Hi, I'm John Doe, a Software Engineer."

In the above example, we define a person object with properties like name, age, and profession, as well as a method called introduce. By utilizing objects, we can organize and manipulate related data and behaviors in a structured manner.

4 Principles of Object-Oriented Programming in Javascript

Encapsulation: Bundling Data and Methods Together

Encapsulation is a fundamental principle of OOP that promotes the idea of bundling data and methods together within an object. It allows us to control access to the object’s internal state and expose only the necessary interfaces. Let’s see how this works in practice:

// Creating a Car class using a constructor function
function Car(make, model, year) {
  // Private properties
  let _make = make;
  let _model = model;
  let _year = year;

  // Public method
  this.getMake = function() {
    return _make;

  // Public method
  this.getModel = function() {
    return _model;

  // Public method
  this.getYear = function() {
    return _year;

// Creating a new instance of the Car class
let myCar = new Car("Tesla", "Model S", 2022);

// Accessing properties through public methods
console.log(myCar.getMake());     // Output: "Tesla"
console.log(myCar.getModel());    // Output: "Model S"
console.log(myCar.getYear());     // Output: 2022

In this example, we define a Car class using a constructor function. The private properties _make, _model, and _year are only accessible through the public methods getMake(), getModel(), and getYear(). This way, we ensure that the internal state of the car object remains encapsulated and can only be accessed via defined interfaces.

Inheritance: Building Hierarchies of Objects

Inheritance is another crucial aspect of OOP that allows objects to inherit properties and methods from other objects. It enables the creation of hierarchies and promotes code reuse. Let’s explore this concept with an example:

// Creating a Vehicle class
class Vehicle {
  constructor(make, model, year) {
    this.make = make;
    this.model = model;
    this.year = year;

  startEngine() {
    console.log("The engine of the " + this.make + " " + this.model + " has started.");

  stopEngine() {
    console.log("The engine of the " + this.make + " " + this.model + " has stopped.");

// Creating a Car class that inherits from the Vehicle class
class Car extends Vehicle {
  constructor(make, model, year) {
    super(make, model, year);
    this.numWheels = 4;

  honk() {
    console.log("Beep beep!");

// Creating a new instance of the Car class
let myCar = new Car("Tesla", "Model S", 2022);

// Accessing inherited methods and properties
myCar.startEngine();    // Output: "The engine of the Tesla Model S has started."
myCar.honk();           // Output: "Beep beep!"

In this example, we define a Vehicle class with properties like make, model, and year, as well as methods to start and stop the engine. Then, we create a Car class that extends the Vehicle class using the extends keyword. The Car class inherits the properties and methods from the Vehicle class and adds a honk() method specific to cars. This way, we can create specialized objects while leveraging the common functionalities provided by the parent class.

Data Encapsulation in Javascript

Data encapsulation is a fundamental concept in object-oriented programming that involves bundling data and related behaviors together within an object. In JavaScript, data encapsulation can be achieved through the use of objects and closures.

Encapsulating Data with Objects

In JavaScript, objects serve as containers for properties and methods. By encapsulating data within an object, we can control access to the data and provide methods to manipulate it. This ensures that the data remains protected and can only be modified through defined interfaces.

// Example of encapsulating data within an object
let person = {
  name: "John",
  age: 25,

  getName: function() {

  getAge: function() {
    return this.age;

  setName: function(newName) { = newName;

  setAge: function(newAge) {
    if (newAge >= 0) {
      this.age = newAge;

// Accessing and modifying encapsulated data through methods
console.log(person.getName());    // Output: "John"
console.log(person.getName());    // Output: "Alice"

In the above example, we encapsulate the name and age data within the person object. The object provides getter methods (getName() and getAge()) to access the data and setter methods (setName() and setAge()) to modify it. By using these methods, we can enforce any necessary validations or logic before updating the encapsulated data.

Encapsulating Data with Closures

In JavaScript, closures provide another way to achieve data encapsulation. A closure is created when an inner function references variables from its outer function, even after the outer function has finished executing. By leveraging closures, we can create private variables that are inaccessible from the outside world.

// Example of encapsulating data with closures
function createCounter() {
  let count = 0;

  return {
    increment: function() {

    decrement: function() {
      if (count > 0) {

    getCount: function() {
      return count;

// Creating a counter object using the createCounter function
let counter = createCounter();

// Accessing and modifying encapsulated data through methods
console.log(counter.getCount());   // Output: 0
console.log(counter.getCount());   // Output: 1

In this example, the createCounter() function creates a closure by returning an object that contains methods to manipulate the count variable. The count variable is encapsulated within the closure and cannot be accessed directly from outside the createCounter() function. The methods (increment(), decrement(), and getCount()) can access and modify the encapsulated count variable, providing controlled access to the data.

Data Abstraction in JavaScript

Data abstraction is a concept in object-oriented programming in javascript that allows us to represent complex systems or entities by focusing on their essential characteristics and hiding unnecessary details. It involves defining abstract classes or interfaces that specify the behavior of objects without providing implementation details.

In JavaScript, abstraction can be achieved through the use of classes and interfaces.

Abstraction with Classes

With the introduction of class syntax in ECMAScript 2015 (ES6), JavaScript supports the creation of classes to implement data abstraction. A class defines the properties and methods that objects should have, providing a blueprint for creating instances.

// Example of abstraction with classes
class Animal {
  constructor(name) { = name;

  // Abstract method
  makeSound() {
    throw new Error("Method 'makeSound()' must be implemented.");

// Subclass of Animal
class Dog extends Animal {
  makeSound() {

// Creating instances of Dog
let dog1 = new Dog("Buddy");
let dog2 = new Dog("Max");

dog1.makeSound();   // Output: "Woof!"
dog2.makeSound();   // Output: "Woof!"

In this example, the Animal class serves as an abstract class that defines the makeSound() method. Since JavaScript does not provide explicit support for abstract classes, we throw an error in the abstract method to enforce its implementation in subclasses. The Dog class extends the Animal class and provides an implementation for the makeSound() method. By creating instances of the Dog class, we can utilize the abstracted behavior of making a sound without concerning ourselves with the internal details of the implementation.

Abstraction with Interfaces

While JavaScript does not have built-in support for interfaces, we can simulate interfaces by defining an object with method signatures. This allows us to specify a contract that classes must adhere to without providing any implementation details.

// Example of abstraction with interfaces
let ShapeInterface = {
  calculateArea() {
    throw new Error("Method 'calculateArea()' must be implemented.");

  calculatePerimeter() {
    throw new Error("Method 'calculatePerimeter()' must be implemented.");

// Class implementing the ShapeInterface
class Circle {
  constructor(radius) {
    this.radius = radius;

  calculateArea() {
    return Math.PI * this.radius * this.radius;

  calculatePerimeter() {
    return 2 * Math.PI * this.radius;

// Creating instances of Circle
let circle = new Circle(5);
console.log(circle.calculateArea());        // Output: 78.53981633974483
console.log(circle.calculatePerimeter());   // Output: 31.41592653589793

In this example, the ShapeInterface object defines method signatures for calculateArea() and calculatePerimeter(). The Circle class implements the ShapeInterface by providing the necessary implementations for those methods. By creating instances of the Circle class, we can use the abstracted behavior of calculating the area and perimeter of a shape without being concerned about the specific implementation details.

Frequently Asked Questions (FAQs)

What is object-oriented programming in JavaScript?

Object-oriented programming in JavaScript is a programming paradigm that allows the creation of objects with properties and behaviors. It organizes code into reusable and modular components, making it easier to manage and maintain complex applications.

What are the 4 concepts of OOP in JavaScript?

The four main concepts of Object-oriented programming in JavaScript are:

  1. Encapsulation: Encapsulation refers to bundling data and related methods together within an object, hiding the internal implementation details and providing a clear interface for interacting with the object.
  2. Abstraction: Abstraction involves simplifying complex entities by representing them with more manageable and understandable models. It focuses on the essential properties and behaviors while hiding unnecessary details.
  3. Inheritance: Inheritance allows objects to inherit properties and behaviors from parent objects. It enables code reuse, reduces redundancy, and establishes hierarchical relationships between objects.
  4. Polymorphism: Polymorphism enables objects to have multiple forms or behaviors. It allows objects of different types to be treated as interchangeable entities, providing flexibility and extensibility to the codebase.

What are the key concepts of OOP?

The key concepts of OOP include:

  1. Objects: Objects are the fundamental building blocks of OOP. They encapsulate data and behaviors into a single entity.
  2. Classes: Classes serve as blueprints for creating objects. They define the structure, properties, and behaviors that objects of the same type will possess.
  3. Encapsulation: Encapsulation combines data and methods into objects, allowing for information hiding and providing a clear interface for interacting with the objects.
  4. Inheritance: Inheritance establishes relationships between classes, enabling the creation of hierarchies and facilitating code reuse by inheriting properties and behaviors from parent classes.
  5. Polymorphism: Polymorphism allows objects of different types to be treated as interchangeable entities, enabling flexibility and extensibility in the code.

What are the advantages of OOP?

The advantages of Object-oriented programming in javascript include:

  1. Modularity: OOP promotes modular design, allowing code to be divided into smaller, reusable components. This enhances code organization, maintainability, and reusability.
  2. Code Reusability: OOP enables the reuse of code through inheritance and composition. Existing classes can be extended or combined to create new classes, reducing redundancy and improving productivity.
  3. Encapsulation: Encapsulation protects data and methods within objects, preventing direct access and manipulation. This enhances data security, reduces potential errors, and promotes code maintainability.
  4. Flexibility and Extensibility: OOP provides flexibility in modifying and extending existing code. New functionalities can be added by creating new classes or modifying existing ones without affecting the entire codebase.
  5. Simplicity and Readability: OOP emphasizes a clear and intuitive organization of code, making it easier to understand and maintain. Objects and their interactions mirror real-world entities, enhancing code readability.

What is polymorphism in JavaScript?

Polymorphism in JavaScript refers to the ability of objects to have multiple forms or behaviors. It allows objects of different types to be treated as interchangeable entities based on their shared interfaces or inheritance relationships. Polymorphism enables writing flexible code that can work with objects of different classes, promoting code reuse and extensibility.

What is inheritance in JavaScript?

Inheritance in JavaScript allows objects to inherit properties and behaviors from parent objects. It establishes a hierarchical relationship between classes, where child classes inherit characteristics from their parent class. Inheritance enables code reuse, as child classes can access and extend the properties and methods defined in their parent class. It provides a powerful mechanism for creating and managing related objects in JavaScript.

Which language is 100% object-oriented?

Java is considered to be a 100% object-oriented programming language. It enforces object-oriented principles by mandating that everything in Java is an object, with the exception of the eight primitive data types.


Object-oriented programming is a powerful paradigm that brings structure and modularity to JavaScript applications. By utilizing objects, encapsulation, and inheritance, we can build scalable and maintainable codebases. In this article, we explored the basics of object-oriented programming in JavaScript and learned about the essential principles that underpin this approach. Armed with this knowledge, you are now well-equipped to embark on your own OOP journey and create elegant and robust JavaScript applications. Happy coding!

Leave a Reply

Your email address will not be published. Required fields are marked *