JavaScript Objects

// Syntax
class MyClass {
    constructor(value) {
        this._value = value;
    }

    // Getter
    get value() {
        return this._value;
    }

    // Setter
    set value(newValue) {
        if (newValue >= 0) {
            this._value = newValue;
        } else {
            console.log("Value must be non-negative.");
        }
    }
}

// Example: Getters and Setters

class Rectangle {
    constructor(width, height) {
        this._width = width;
        this._height = height;
    }

    // Getter for area
    get area() {
        return this._width * this._height;
    }

    // Setter for width
    set width(newWidth) {
        if (newWidth > 0) {
            this._width = newWidth;
        }
    }
}

// Create an instance
const rect = new Rectangle(10, 5);

// Use getter
console.log(rect.area); // Output: 50

// Use setter
rect.width = 15;
console.log(rect.area); // Output: 75

/*
Explanation
1. Getter: get area() returns the computed area of the rectangle.
2. Setter: set width(newWidth) validates and updates the width of the rectangle.
*/

// Syntax

class MyClass {
    static staticMethod() {
        // Static method code
    }

    static staticProperty = 'staticValue';
}

// Example: Static Methods and Properties

class MathUtils {
    static add(a, b) {
        return a + b;
    }

    static PI = 3.14159;
}

// Use static method
console.log(MathUtils.add(5, 3)); // Output: 8

// Use static property
console.log(MathUtils.PI); // Output: 3.14159

/*
Explanation:
1. Static Method: static add(a, b) is a static method that can be called directly on the class (MathUtils.add).
2. Static Property: static PI is a static property accessible on the class itself (MathUtils.PI).
*/

// Syntax
class MyClass {
    #privateField;

    constructor(value) {
        this.#privateField = value;
    }

    #privateMethod() {
        console.log('This is a private method');
    }

    publicMethod() {
        this.#privateMethod();
    }
}

// Example: Private Fields and Methods

class Counter {
    #count = 0; // Private field

    increment() {
        this.#count++;
    }

    getCount() {
        return this.#count;
    }
}

// Create an instance
const counter = new Counter();
counter.increment();
console.log(counter.getCount()); // Output: 1

// The following will result in an error
// console.log(counter.#count); // SyntaxError: Private field '#count' must be declared in an enclosing class


/*
Explanation:
1. Private Field: #count is a private field that is not accessible outside the class.
2. Private Method: #privateMethod() is a private method that can only be called within the class.
*/

// Traditional Prototype-Based Inheritance

function Animal(name) {
    this.name = name;
}

Animal.prototype.speak = function() {
    console.log(`${this.name} makes a noise.`);
};

function Dog(name) {
    Animal.call(this, name);
}

Dog.prototype = Object.create(Animal.prototype);
Dog.prototype.constructor = Dog;

Dog.prototype.speak = function() {
    console.log(`${this.name} barks.`);
};

// Using ES6 Classes

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

    speak() {
        console.log(`${this.name} makes a noise.`);
    }
}

class DogClass extends AnimalClass {
    constructor(name) {
        super(name);
    }

    speak() {
        console.log(`${this.name} barks.`);
    }
}

// Create instances
let traditionalDog = new Dog("Rex");
let es6Dog = new DogClass("Max");

traditionalDog.speak(); // Output: Rex barks.
es6Dog.speak(); // Output: Max barks.

// Use PascalCase for class names
class Company {
    constructor(name, location) {
        this.name = name;
        this.location = location;
        this.employees = [];
    }

    // Method to add an employee
    addEmployee(employee) {
        this.employees.push(employee);
    }

    // Method to get names of all employees
    getEmployeeNames() {
        return this.employees.map(emp => emp.name);
    }
}

// Use PascalCase for class names
class Employee {
    constructor(name, position) {
        this.name = name;
        this.position = position;
    }
}

// Use const for object declarations
const company = new Company("Tech Solutions", "New York");

const emp1 = new Employee("Alice", "Developer");
const emp2 = new Employee("Bob", "Designer");

company.addEmployee(emp1);
company.addEmployee(emp2);

console.log(company.getEmployeeNames()); // Output: [ 'Alice', 'Bob' ]