When diving into the world of Object-Oriented Programming (OOP), it's crucial to grasp the key concepts that form the foundation of this paradigm. By focusing on these core principles, you'll acquire a solid understanding of OOP and its applications. Here are the fundamental learnings that will empower you with approximately 80% of the knowledge needed

Objects

In OOP, objects represent real-world entities and encapsulate both data (attributes) and behaviors (methods). They allow us to model and interact with the world programmatically.

Classes

Classes serve as blueprints for creating objects. They define the structure and behavior that objects of a particular type possess, enabling the creation of multiple instances with shared characteristics.

Encapsulation

Encapsulation emphasizes bundling data and methods together within a class, shielding internal workings from external access. This promotes information hiding, data integrity, and organized code.

Inheritance

Inheritance enables the creation of new classes based on existing ones. It fosters code reuse and establishes hierarchical relationships, allowing subclasses to inherit and extend the attributes and behaviors of their parent classes.

Polymorphism

Polymorphism empowers objects of different classes to be treated as objects of a common superclass. It enables dynamic behavior and flexibility, allowing different objects to respond uniquely to the same method invocation.

Abstraction

Abstraction involves focusing on essential features while hiding unnecessary details. It allows us to model complex systems by breaking them down into manageable components, enabling efficient problem-solving.

Modularity

Modularity emphasizes breaking down a program into smaller, self-contained modules. This enhances code organization, reusability, and maintainability, making it easier to manage and collaborate on larger projects.

Methods and Functions

Methods are actions performed by objects, while functions are standalone blocks of reusable code. They encapsulate logic, enable code reuse, and promote modular design.

Constructors

Constructors are special methods used to initialize objects when they are created. They allow us to set initial values for object attributes, ensuring proper initialization.

Access Modifiers

Access modifiers (e.g., public, private, protected) control the visibility and accessibility of class members. They regulate how objects interact with each other and safeguard data integrity.

Composition

Composition involves building complex objects by combining simpler objects or components. It promotes flexibility, modularity, and the creation of more sophisticated systems.

Overloading

Overloading allows the definition of multiple methods with the same name but different parameters. It provides convenience and flexibility, allowing methods to handle different scenarios.

Overriding

Overriding enables a subclass to provide its implementation of a method inherited from a superclass. It facilitates customization and specialization of behavior for specific classes.

Polymorphic Variables

Polymorphic variables are references that can hold objects of different types. They enable the writing of flexible and reusable code, enhancing code adaptability and versatility.

Static Members

Static members belong to the class itself, rather than specific instances. They are shared among all objects of that class and accessed using the class name, providing common behavior or shared data.

Association

The association represents relationships between objects or classes, such as one-to-one, one-to-many, or many-to-many relationships. It allows us to model connections and interactions between entities.

Dependency

Dependency occurs when one class relies on another to perform its functionality. It establishes relationships between classes, allowing them to collaborate and fulfill specific roles.

Inheritance vs. Composition

Inheritance and composition are different approaches to establishing relationships between classes. Understanding their distinctions helps in designing optimal class hierarchies and object relationships.

Design Patterns

Design patterns are reusable solutions to commonly occurring programming problems. Learning and applying design patterns enhance code quality, and maintainability, and promote best practices.

OOP Application

Understanding how to apply OOP concepts to real-world scenarios and problem-solving is vital. By employing OOP principles effectively, you can design modular, extensible, and maintainable software systems.

---

Example Code

With a thorough understanding of the core principles of Object-Oriented Programming under our belt, we are now ready to dive into the practical implementation phase. It's time to roll up our sleeves and start applying these concepts in real code to bring our software projects to life.

Abstraction

class Coffee {
  constructor(name, origin) {
    this.name = name;
    this.origin = origin;
  }

  brew() {
    console.log(`Brewing ${this.name} coffee from ${this.origin}...`);
    // brewing logic here
  }
}

class Espresso extends Coffee {
  constructor(origin) {
    super("Espresso", origin);
  }

  brew() {
    console.log(`Brewing a shot of ${this.name} from ${this.origin}...`);
    // espresso brewing logic here
  }
}

class Cappuccino extends Coffee {
  constructor(origin) {
    super("Cappuccino", origin);
  }

  brew() {
    console.log(`Brewing a delicious ${this.name} from ${this.origin}...`);
    // cappuccino brewing logic here
  }
}

const espresso = new Espresso("Aceh");
espresso.brew(); // Output: Brewing a shot of Espresso from Aceh...

const cappuccino = new Cappuccino("Aceh");
cappuccino.brew(); // Output: Brewing a delicious Cappuccino from Aceh...

Encapsulation

class CoffeeMachine {
  #waterTemperature = 90; // private property

  grindBeans() {
    console.log("Grinding coffee beans...");
    // grinding logic here
  }

  pourWater() {
    console.log(`Pouring water at ${this.#waterTemperature}°C...`);
    // water pouring logic here
  }

  brewCoffee() {
    this.grindBeans();
    this.pourWater();
    console.log("Brewing coffee...");
    // brewing logic here
  }
}

const coffeeMachine = new CoffeeMachine();
coffeeMachine.brewCoffee(); // Output: Grinding coffee beans...
                            //         Pouring water at 90°C...
                            //         Brewing coffee...

Inheritance

class CoffeeBlend {
  constructor(name, origin) {
    this.name = name;
    this.origin = origin;
  }
}

class HouseBlend extends CoffeeBlend {
  constructor(origin) {
    super("House Blend", origin);
  }
}

class FrenchRoast extends CoffeeBlend {
  constructor(origin) {
    super("French Roast", origin);
  }
}

const houseBlend = new HouseBlend("Aceh");
console.log(houseBlend.name); // Output: House Blend
console.log(houseBlend.origin); // Output: Aceh

const frenchRoast = new FrenchRoast("Aceh");
console.log(frenchRoast.name); // Output: French Roast
console.log(frenchRoast.origin); // Output: Aceh

Polymorphism

class CoffeeShop {
  serveCoffee(coffee) {
    console.log(`Serving a cup of ${coffee.name} coffee from ${coffee.origin}...`);
    coffee.brew();
  }
}

const coffeeShop = new CoffeeShop();

const espresso = new Espresso("Aceh");
coffeeShop.serveCoffee(espresso); // Output: Serving a cup of Espresso coffee from Aceh...
                                  //         Brewing a shot of Espresso from Aceh...

const cappuccino = new Cappuccino("Aceh");
coffeeShop.serveCoffee(cappuccino); // Output: Serving a cup of Cappuccino coffee from Aceh...
                                    //         Brewing a delicious Cappuccino from Aceh...