TypeScript Classes Fundamentals
📌 Basic class definition requires a Constructor to initialize properties that lack a default value, otherwise TypeScript throws an error ("property has no initializer").
📌 Class members include properties (like `name: string`) and methods. Redundancy exists initially: properties must be defined, and then assigned within the constructor (`this.name = name`).

Visibility Modifiers (Access Modifiers)
📌 TypeScript offers modifiers to control property and method access: `public` (default, accessible everywhere), `private` (accessible only within the defining class), and `protected` (accessible within the class and derived subclasses).
📌 Using visibility modifiers (e.g., `public name: string`) directly in the constructor parameters simplifies syntax by automatically declaring the property and assigning the value, avoiding the redundant declaration outside the constructor.
📌 The `readonly` modifier can be combined with other visibility modifiers (e.g., `public readonly name: string`), preventing mutation after initialization.

Class Inheritance and Super Call
📌 Classes can extend existing classes using the `extends` keyword (e.g., `class WebDev extends Coder`).
📌 When extending a class, the subclass must call `super(...)` in its constructor *before* using `this` to initialize properties inherited from the parent class.
📌 Properties defined with default values in the base class (e.g., `Lang` defaulting to "typescript") do not require being passed to `super()`.

Implementing Interfaces in Classes
📌 A class uses the `implements` keyword to adhere to an Interface contract (e.g., `class Guitarist implements Musician`).
📌 The implementing class must include all properties and methods defined in the interface, ensuring type matching (e.g., if the interface specifies `name` as a string, the class property must also be a string).

Static Members and Instance Counting
📌 The `static` keyword is used for members (properties or methods) that belong to the class itself, rather than to any specific instance created from that class.
📌 Static members (like `static count: number = 0;`) are useful for tracking class-level data, such as counting the total number of objects instantiated from that class.
Static methods must reference static properties using the class name (e.g., `Peeps.count`) instead of `this`.

Getters and Setters
📌 Getters (prefixed with the `get` keyword) allow reading a private property (like state data) in a read-only manner (e.g., `myBands.data`).
📌 Setters (prefixed with the `set` keyword) allow controlled mutation of private properties, enabling validation logic before assignment (e.g., ensuring an input array only contains strings). Setters cannot return a value.

Key Points & Insights
➡️ TypeScript enforces type safety strictly; for example, attempting to access a `private` property or a `protected` property outside its class or subclass scope results in compiler errors.
➡️ Optional constructor parameters or parameters with default values (like `lang: string = "typescript"`) allow for flexible instantiation of classes.
➡️ The pre-increment operator (`++count`) ensures the counter increments *before* assigning the value to the instance ID, resulting in IDs starting at 1 for the first instance.
➡️ TypeScript allows code that violates strict settings to compile into valid JavaScript, illustrating its role as a tool for gradual refactoring and catching errors during development.

📸 Video summarized with SummaryTube.com on Dec 27, 2025, 16:23 UTC