JavaScript OOP

// Object Oriented Programming

// We have a vehicle system, a class basically creates and manages all objects.
// An object is something you can get information on, and do actions with it, for this example, it's just like it.
class Vehicle {
    static vehicleCount = 0; // A static variable/function is something that belongs to the class itself, this doesn't belong to the objects created.

    constructor (name, price) { // Create an object, with the following arguments that we pass in to it.
        this.name = name; // Make sure it's 'this' so we can reference that specific object, it's creating variables for that specific object that is passed into the constructor.
        this.price = price;
        Vehicle.vehicleCount++;
    }

    getVehicleStats() { // This can only be used by the object, it will return the following.
        return [this.name, this.price]; // Returning for functions is basically a feedback system, you give it information, it will give back more information.
    }

    logStats() {
        const statistics = this.getVehicleStats(); // Now we are using that ^

        const vehicleName = statistics[0]; // It returns an array.
        const vehiclePrice = statistics[1];

        console.log("| VEHICLE STATISTICS | ")
        console.log("Name: " + vehicleName);
        console.log("Price: $" + vehiclePrice);
    }
}

// INHERITANCE

class Car extends Vehicle { // Inheritance in OOP (Object Oriented Programming) means creating object that inherits properties and methods from the parent, in this case, it's the 'Vehicle' class.
    static carCount = 0;

    constructor (name, price, model) {
        super(name, price); // It will take the name and price and pass it to the object's parent, so we can then use the 'Vehicle' class to do something to that objects so it knows it's not unknown.
        this.model = model; // We have new properties.
        Car.carCount++;
    }

    // Overriding a function, it already exists on the vehicle class but we're replacing it for this one.

    getVehicleStats() {
        return [this.name, this.price, this.model];
    }

    logStats() {
        const statistics = this.getVehicleStats();

        const carName = statistics[0];
        const carPrice = statistics[1];
        const carModel = statistics[2];

        console.log("| CAR STATISTICS | ")
        console.log("Name: " + carName);
        console.log("Price: $" + carPrice);
        console.log("Model: " + carModel);
    }
}

// This is basically the same as the car class, except with new properties.

class Boat extends Vehicle {
    static boatCount = 0;

    constructor (name, price, model, speed) {
        super(name, price);
        this.model = model;
        this.speed = speed;
        Boat.boatCount++;
    }

    getVehicleStats() {
        return [this.name, this.price, this.model, this.speed];
    }

    logStats() {
        const statistics = this.getVehicleStats();

        const boatName = statistics[0];
        const boatPrice = statistics[1];
        const boatModel = statistics[2];
        const boatSpeed = statistics[3];

        console.log("| BOAT STATISTICS | ")
        console.log("Name: " + boatName);
        console.log("Price: $" + boatPrice);
        console.log("Model: " + boatModel);
        console.log(`Speed: ${boatSpeed}MPH`);
    }
}

// Now this is how to create a new object.

const Chevrolet = new Car("Chevrolet", 50000, "A1"); // Remember that 'super' keyword from earlier? Well the vehicle class automatically takes care of it for us, and it will asign this.name and this.price.
const Toyota = new Car("Toyota", 25000, "MN20"); // So if we want to create an object, just type 'new {CLASS_NAME}({PROPERTIES})'.
const Airplane = new Vehicle("Plane", 250000); // This would still work.
const Ship = new Boat("Ship", 10000, "X", 200) // Pass the arguments in order by the way, these will be handled by the constructor, which then handles the 'super' stuff that I mentioned earlier.

Chevrolet.logStats(); // We are using the object's methods/functions.
Toyota.logStats();
Airplane.logStats();
Ship.logStats();

console.log("-------------------");
console.log(`There are ${Vehicle.vehicleCount} vehicles.`); // That's how the static keyword works, you don't use the object, you use the class, because it's unnecessary.
console.log(`There are ${Car.carCount} cars.`);

// I like OOP