Summary  
This chapter explains how to declare class properties with default values or leave them uninitialized and then initialize them in the constructor so that each instance gets its own property values.

General domain of usage  
Object-oriented modeling of data entities in application code.

class Person {
  name: string = "John"; // Property with a default value
  age: number;           // Property without a default value
  isEmployed: boolean;   // Property without a default value

  constructor(age: number, isEmployed: boolean) {
    this.age = age;             // Initialize property in constructor
    this.isEmployed = isEmployed;
  }
}

const person1 = new Person(30, true);
console.log(person1.name);        // Output: John
console.log(person1.age);         // Output: 30
console.log(person1.isEmployed);  // Output: true

When working with **TypeScript classes**, you can declare properties directly inside the class body. Properties can be given **default values**, or you can leave them uninitialized and assign values later, usually in the `constructor`. Declaring a property with a default value means every instance of the class starts with that value unless it is overwritten. If you do not provide a default value, you must assign one—typically in the `constructor`—so that each instance can have its own value.

Using the `constructor` to initialize properties is especially useful for properties that should be set differently for each instance. This ensures that every object created from the class has its own unique set of property values, rather than sharing a single value across all instances.

What is the main advantage of initializing class properties in the constructor?

Deepen your understanding of object-oriented programming with TypeScript by working with classes, encapsulation, interfaces, generics, and inheritance. Learn how to structure reusable components, enforce contracts, and design scalable class hierarchies.

Build a strong foundation in TypeScript classes by defining properties, methods, constructors, and static members. Learn how class structure improves clarity, reusability, and code organization.

Control visibility and encapsulation using public, private, and protected members. Apply these modifiers to create safer, more predictable class designs that hide implementation details and expose only what is needed.

Use abstract classes and interfaces to enforce structure and define contracts between components. Explore how these tools support scalable architecture and help manage complex object relationships.

Write flexible, type-safe classes by applying generics to class definitions and methods. Create reusable patterns that adapt to multiple data types while maintaining strong typing.

Build class hierarchies with inheritance and leverage polymorphism to create extendable systems. Learn how method overriding, super calls, and shared behavior support clean and maintainable object-oriented design.

Class Properties and Initialization

Awesome!

Class Properties and Initialization