docs: constructors & prototypes

Author: devmahmud

README.md

@@ -14,17 +14,17 @@ This advanced JavaScript course is designed for experienced developers looking t
 ### [Module 1: Advanced JavaScript Concepts](./module-1-advanced-javascript-concepts.md)
 
 - 1.1. [Closures and Scopes](./module-1.1-closures-and-scopes.md)
-- 1.2. [Promises and Async/Await](#promises-and-asyncawait)
-- 1.3. [Functional Programming](#functional-programming)
-- 1.4. [Design Patterns](#design-patterns)
-- 1.5. [Event Loop and Concurrency](#event-loop-and-concurrency)
+- 1.2. [Promises and Async/Await](./module-1.2-promises-and-async-await.md)
+- 1.3. [Functional Programming](./module-1.3-functional-programming.md)
+- 1.4. [Design Patterns](./module-1.4-design-patterns.md)
+- 1.5. [Event Loop and Concurrency](./module-1.5-event-loop-and-concurrency.md)
 
-### [Module 2: Object-Oriented Programming (OOP) in JavaScript](#module-2-object-oriented-programming-oop-in-javascript)
+### [Module 2: Object-Oriented Programming (OOP) in JavaScript](./module-2-object-oriented-programming-oop-in-javascript.md)
 
-2.1. [Constructors and Prototypes](#constructors-and-prototypes)
-2.2. [Classes and Inheritance](#classes-and-inheritance)
-2.3. [Mixins and Composition](#mixins-and-composition)
-2.4. [Private and Static Members](#private-and-static-members)
+- 2.1. [Constructors and Prototypes](./module-2.1-constructors-and-prototypes.md)
+- 2.2. [Classes and Inheritance](#classes-and-inheritance)
+- 2.3. [Mixins and Composition](#mixins-and-composition)
+- 2.4. [Private and Static Members](#private-and-static-members)
 
 ### [Module 3: Advanced DOM Manipulation](#module-3-advanced-dom-manipulation)
 3.1. [Traversing and Selecting DOM Elements](#traversing-and-selecting-dom-elements)

module-2-object-oriented-programming-oop-in-javascript.md

@@ -0,0 +1,102 @@
+### [Module 2: Object-Oriented Programming (OOP) in JavaScript](#module-2-object-oriented-programming-oop-in-javascript)
+
+**Description:**
+
+Module 2 is a comprehensive exploration of Object-Oriented Programming (OOP) in JavaScript. It delves into various OOP techniques, from the foundational concepts of constructors and prototypes to more advanced topics like classes, inheritance, mixins, composition, private members, and static members. By mastering these concepts, you'll gain the ability to structure your JavaScript code in a more organized, efficient, and maintainable way.
+
+**Topics Covered:**
+
+#### 2.1. Constructors and Prototypes
+
+- **Constructors in JavaScript:** Constructors are special functions used to create and initialize objects in JavaScript. They act as blueprints for creating instances with shared properties and methods, promoting code reusability and structure.
+
+  **Example:**
+
+  ```javascript
+  function Person(name, age) {
+    this.name = name;
+    this.age = age;
+  }
+
+  const john = new Person('John', 30);
+  console.log(john.name); // Output: John
+  ```
+
+- **Prototypes and Inheritance:** Prototypes allow objects to inherit properties and methods from other objects. This fundamental concept optimizes memory usage and facilitates the creation of complex object hierarchies.
+
+  **Example:**
+
+  ```javascript
+  Person.prototype.greet = function () {
+    console.log(`Hello, my name is ${this.name} and I'm ${this.age} years old.`);
+  };
+
+  john.greet(); // Output: Hello, my name is John and I'm 30 years old.
+  ```
+
+#### 2.2. Classes and Inheritance
+
+- **Classes in JavaScript:** ES6 introduced class syntax, providing a structured way to create and manage objects. Classes encapsulate data and behavior, promoting code organization and readability.
+
+  **Example:**
+
+  ```javascript
+  class Animal {
+    constructor(name) {
+      this.name = name;
+    }
+
+    speak() {
+      console.log(`${this.name} makes a sound.`);
+    }
+  }
+
+  const dog = new Animal('Buddy');
+  dog.speak(); // Output: Buddy makes a sound.
+  ```
+
+- **Inheritance in ES6:** Inheritance is a key component of OOP, allowing classes to inherit properties and methods from other classes. ES6's `extends` keyword simplifies the inheritance process.
+
+  **Example:**
+
+  ```javascript
+  class Dog extends Animal {
+    constructor(name, breed) {
+      super(name);
+      this.breed = breed;
+    }
+
+    speak() {
+      console.log(`${this.name} barks.`);
+    }
+  }
+
+  const goldenRetriever = new Dog('Max', 'Golden Retriever');
+  goldenRetriever.speak(); // Output: Max barks.
+  ```
+
+#### 2.3. Mixins and Composition
+
+- **Mixins for Reusability:** Mixins are a way to share and reuse code among different objects or classes. They promote code modularity and flexibility.
+
+- **Composing Objects:** Composition involves building complex objects by combining simpler ones. It's a versatile technique for creating reusable and structured code.
+
+#### 2.4. Private and Static Members
+
+- **Private Members:** Private members are properties or methods that are inaccessible from outside the class. Encapsulation of data and behavior is essential for creating robust and secure code.
+
+- **Static Members:** Static members are associated with the class itself, not instances. They provide a way to create utility methods or properties that are shared among all instances of a class.
+
+**Practical Application:**
+
+The principles and techniques covered in this module are applied in various scenarios, including creating reusable libraries, structuring complex applications, and designing well-organized codebases. Private members and static members enhance code security and efficiency.
+
+**Examples:**
+
+The module includes practical examples and hands-on exercises for each topic. These examples provide opportunities to gain practical experience and deepen your understanding of OOP concepts in JavaScript.
+
+**Key Takeaways:**
+
+By mastering constructors, prototypes, classes, inheritance, mixins, composition, private members, and static members, you'll become proficient in structuring your JavaScript code in a way that promotes reusability, organization, and efficiency. These OOP techniques empower you to create maintainable and robust applications.
+
+

module-2.1-constructors-and-prototypes.md

@@ -0,0 +1,55 @@
+#### 2.1. Constructors and Prototypes
+
+Object-Oriented Programming (OOP) in JavaScript often begins with understanding Constructors and Prototypes. These concepts are fundamental to creating and managing objects.
+
+##### Constructors in JavaScript
+
+In JavaScript, constructors are functions used to create and initialize objects. They serve as templates for creating objects with shared properties and methods. Here's an example of a simple constructor for creating `Person` objects:
+
+```javascript
+function Person(name, age) {
+  this.name = name;
+  this.age = age;
+}
+
+const john = new Person('John', 30);
+console.log(john.name); // Output: John
+```
+
+In this example, we define a `Person` constructor that takes `name` and `age` as parameters. When we create a new `Person` object using `new`, it initializes the object's properties based on the constructor.
+
+##### Prototypes and Inheritance
+
+Prototypes allow objects to inherit properties and methods from other objects. Understanding prototypes is crucial for creating efficient and maintainable code in JavaScript.
+
+```javascript
+// Creating a prototype method
+Person.prototype.greet = function () {
+  console.log(`Hello, my name is ${this.name} and I'm ${this.age} years old.`);
+};
+
+john.greet(); // Output: Hello, my name is John and I'm 30 years old.
+```
+
+In this example, we add a `greet` method to the `Person` prototype, which all `Person` objects can access. This method is shared among all instances of `Person`, making it more memory-efficient.
+
+#### Constructor Functions and `new`
+
+- Constructor functions, like `Person` in the example, are named with capital letters by convention.
+- The `new` keyword is used to create instances of objects based on the constructor.
+- Inside the constructor, `this` refers to the new instance being created.
+- Properties and methods specific to an object are set using `this.propertyName` inside the constructor.
+
+#### Prototype Chain and Inheritance
+
+- When you add methods or properties to a constructor's prototype, they are shared among all objects created from that constructor.
+- Objects can access properties and methods defined in their constructor's prototype, creating an inheritance mechanism.
+- This promotes code reusability and efficient memory usage.
+
+#### Best Practices
+
+- Use constructor functions for creating multiple instances of objects with shared properties and methods.
+- Place methods shared among instances in the constructor's prototype to optimize memory usage.
+- Follow naming conventions, such as capitalizing the first letter of constructor functions, for clarity.
+
+Understanding Constructors and Prototypes is foundational to mastering Object-Oriented Programming in JavaScript. They enable you to create organized, efficient, and maintainable code.