TypeScript Academy · Lesson

public, private, and protected Modifiers

Control access to class members with modifiers.

Lesson 2 of 413 steps

public, private, and protected Modifiers is a free TypeScript Academy lesson on CoddyKit. This is lesson 2 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the TypeScript Academy learning path, and your progress syncs across the web and the CoddyKit app. The TypeScript Academy course includes 4 lessons in total.

Welcome

TypeScript access modifiers control the visibility of class members. They help enforce encapsulation and prevent unintended usage.

public: Accessible Everywhere

public is the default. Public members are accessible from anywhere — inside the class, subclasses, and external code.

class Car {
  public brand: string;
  constructor(brand: string) { this.brand = brand; }
}
const c = new Car('Toyota');
console.log(c.brand); // OK

private: Class-Only Access

Private members are accessible only within the declaring class. Subclasses and external code cannot access them.

class BankAccount {
  private balance: number = 0;
  deposit(n: number) { this.balance += n; }
}
const a = new BankAccount();
// a.balance; // Error!

protected: Class and Subclass Access

Protected members are accessible within the declaring class and any subclass, but not from external code.

class Animal {
  protected name: string;
  constructor(name: string) { this.name = name; }
}
class Dog extends Animal {
  bark() { console.log(this.name + ' says woof!'); } // OK
}

Compile-Time Only Enforcement

TypeScript access modifiers are compile-time checks only. The JavaScript output still has public properties — there is no runtime enforcement.

JavaScript Private with #

JavaScript has native private fields with `#` that are enforced at runtime. TypeScript supports this syntax alongside its own `private` keyword.

class Counter {
  #count = 0; // runtime private (JavaScript)
  increment() { this.#count++; }
  get value() { return this.#count; }
}

readonly Modifier

readonly properties can only be set during construction. They cannot be changed after initialization.

class User {
  readonly id: number;
  constructor(id: number) { this.id = id; }
}
const u = new User(1);
// u.id = 2; // Error!

Combining Modifiers

You can combine access modifiers with readonly on the same property.

class Config {
  constructor(
    public readonly host: string,
    private readonly port: number
  ) {}
}

private on Constructor

Making a constructor private prevents external instantiation. Use static factory methods instead.

class Singleton {
  private static instance: Singleton;
  private constructor() {}
  static getInstance(): Singleton {
    return this.instance ??= new Singleton();
  }
}

protected Constructor

A protected constructor prevents direct instantiation but allows subclasses to call it via super().

class Base {
  protected constructor(public id: number) {}
}
class Derived extends Base {
  constructor(id: number) { super(id); }
}

Access Modifiers Don't Add Runtime Overhead

Because TypeScript erases all type information, access modifiers have zero impact on the compiled JavaScript output size or performance.

Quick Check

Which access modifier makes a class member accessible in the class AND its subclasses, but NOT from external code?

Answer it in the interactive lesson

Recap

Use public (default) for accessible members, private for encapsulated internals, and protected for members meant for subclasses. Add readonly to prevent mutation after construction.

Free to start

Learn TypeScript with an AI tutor — free

Write and run real code in your browser, get instant help from a 24/7 AI tutor, and pick up where you left off on the web or in the app.

Courses: 101
Lessons: 352

Start learning free View the full course

Frequently Asked Questions

Is the “public, private, and protected Modifiers” lesson free?

Yes — the full text of “public, private, and protected Modifiers” is free to read here on the web. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the TypeScript Academy course, upgrade to CoddyKit PRO. The TypeScript Academy course includes 4 lessons in total.

What will I learn in “public, private, and protected Modifiers”?

Control access to class members with modifiers. You practise TypeScript Academy with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start TypeScript Academy?

No prior experience is required. TypeScript Academy on CoddyKit is structured for beginners through advanced learners, so you can start here or from the beginning and move at your own pace. This is lesson 2 of 4.

How long does the “public, private, and protected Modifiers” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this TypeScript Academy lesson?

Yes. Every TypeScript Academy lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

TypeScript Classes and Constructors
public, private, and protected Modifiers
readonly Properties and Parameter Properties
Implementing Interfaces with Classes

← Back to TypeScript Academy