Classes

They control member visibility. public, the default, is accessible everywhere. private is accessible only within the declaring class. protected is accessible within the class and its subclasses. These modifiers are enforced only at compile time and are erased from the emitted JavaScript, so for genuine runtime privacy you must use a #private field instead.

A class supports typed instance fields, a constructor, methods, readonly fields settable only in their declaration or the constructor, static members that belong to the class itself rather than instances, and get/set accessors that control how a property is read or written. On top of ES2015 classes, TypeScript adds field types, access modifiers, and abstract.

class B extends A makes B inherit A's members. A subclass constructor must call super(...) before using this. Methods can be overridden, optionally marked override, and super.method() calls the base version. A protected member is reachable in subclasses while a private one is not. TypeScript allows single inheritance only — one base class — so use interfaces for multiple contracts.

Accessors intercept reading and writing a property with method bodies while callers still use plain property syntax. A get name() runs when the property is read and returns the value; a set name(v) runs when it is assigned and receives the new value. They let you add validation, computation, or logging behind obj.name. A property with only a getter is effectively read-only.

readonly marks a property as assignable only once — at declaration or inside the constructor — after which the compiler rejects any reassignment. It is a compile-time check only and is erased from the emitted JavaScript, so it gives no runtime immutability. It pins the binding, not the contents: a readonly array can still be mutated with push.

A static member belongs to the class itself: it exists once and is reached as ClassName.member, never through an instance. An instance member is created per object by new and reached through this. Inside a static method this is the class.

An abstract class is a base blueprint that cannot be instantiated directly. Its abstract methods declare a signature with no body that every subclass must implement, but it can also hold concrete methods, fields, and a constructor shared by subclasses. Use one to share implementation while forcing subclasses to fill in specifics. Unlike an interface, an abstract class can carry implementation and state.

private is TypeScript-only: the checker enforces then erases it, so the property survives in the emitted JavaScript, readable via obj['x']. #x is an ECMAScript field the engine enforces — outside code cannot name it or see it in Object.keys.

A parameter property is a constructor parameter prefixed with an access modifier (public, private, protected) and/or readonly. TypeScript then automatically declares a class field of the same name and assigns the argument to it, so constructor(private name: string) {} replaces a separate field declaration plus this.name = name. It is shorthand that removes boilerplate.

Visibility. The modifiers are orthogonal: readonly governs mutability, private visibility. A plain readonly field is assign-once yet publicly readable; private readonly hides it from outside. Both are compile-time checks, erased at build.

One level. readonly locks the binding — the property cannot be reassigned — but says nothing about the object it points at, so readonly items: string[] still allows items.push(x). Readonly<T> is shallow too; real depth needs a recursive type.

It silences strictPropertyInitialization, the check that a non-optional field is assigned in its declaration or constructor. ! emits no runtime check and no initializer, so the field can still be undefined while its type promises string.