Access modifiers public private protected in Typescript

Introduction

Access modifiers control who can see or change parts of your code. They help keep your data safe and organized.

When you want everyone to use or change a value or function, use <strong>public</strong>.

When you want to hide data or functions inside a class so only that class can use them, use <strong>private</strong>.

When you want to share data or functions with a class and its children (subclasses), but not with others, use <strong>protected</strong>.

Syntax

Typescript

class ClassName {
  public propertyName: type;
  private propertyName: type;
  protected propertyName: type;

  public methodName() {}
  private methodName() {}
  protected methodName() {}
}

public is the default if you don't write any modifier.

Access modifiers apply only inside classes.

Examples

This class shows all three modifiers on properties and methods.

Typescript

class Person {
  public name: string;
  private age: number;
  protected city: string;

  constructor(name: string, age: number, city: string) {
    this.name = name;
    this.age = age;
    this.city = city;
  }

  public greet() {
    console.log(`Hello, my name is ${this.name}`);
  }

  private getAge() {
    return this.age;
  }

  protected getCity() {
    return this.city;
  }
}

Outside the class, you can only access public members.

Typescript

const p = new Person('Alice', 30, 'Paris');
console.log(p.name); // works because name is public
// console.log(p.age); // error: age is private
// console.log(p.city); // error: city is protected

Child classes can access protected members but not private.

Typescript

class Employee extends Person {
  showCity() {
    console.log(this.getCity()); // works because getCity is protected
  }
}

Sample Program

This program shows how public, private, and protected work in classes and subclasses.

Typescript

class Animal {
  public name: string;
  private sound: string;
  protected habitat: string;

  constructor(name: string, sound: string, habitat: string) {
    this.name = name;
    this.sound = sound;
    this.habitat = habitat;
  }

  public makeSound() {
    console.log(`${this.name} says ${this.sound}`);
  }

  private secretSound() {
    console.log('This is a secret sound');
  }

  protected getHabitat() {
    return this.habitat;
  }
}

class Bird extends Animal {
  showHabitat() {
    console.log(`${this.name} lives in ${this.getHabitat()}`);
  }
}

const parrot = new Bird('Parrot', 'Squawk', 'tropical forests');
parrot.makeSound();
parrot.showHabitat();
// parrot.secretSound(); // Error: private method
// console.log(parrot.sound); // Error: private property
// console.log(parrot.habitat); // Error: protected property

Important Notes

Trying to access private or protected members outside allowed places causes errors.

protected is like a secret shared only with child classes.

Use these modifiers to keep your code safe and clear.

Summary

public means anyone can use it.

private means only the class itself can use it.

protected means the class and its children can use it.

Practice

1. Which access modifier in TypeScript allows a class member to be accessed from anywhere, including outside the class?

easy

A. private

B. public

C. protected

D. readonly

Solution

1. Step 1: Understand access modifiers

   public means anyone can access the member, private restricts access to the class only, and protected allows access to the class and its subclasses.

2. Step 2: Identify the modifier allowing access from anywhere

   Only public allows access from outside the class, including other classes and code.

3. Final Answer:

   public -> Option B

4. Quick Check:

   public = accessible everywhere [OK]

Hint: Public means open to all, private is class-only [OK]

Common Mistakes:

• Confusing private with public access
• Thinking protected is accessible outside class
• Assuming readonly controls access

2. Which of the following is the correct syntax to declare a private property named age in a TypeScript class?

easy

A. private age: number;

B. public age: number;

C. protected age: number;

D. age: private number;

Solution

1. Step 1: Recall TypeScript property declaration syntax

   Access modifiers come before the property name and type, e.g., private age: number;.

2. Step 2: Identify correct modifier placement

   private age: number; correctly places private before the property name and type. age: private number; has incorrect order.

3. Final Answer:

   private age: number; -> Option A

4. Quick Check:

   Modifier before name and type [OK]

Hint: Modifier comes before property name and type [OK]

Common Mistakes:

• Placing modifier after property name
• Using invalid syntax like 'age: private number;'
• Confusing protected and private keywords

3. What will be the output of the following TypeScript code?

class Animal {
  protected sound = 'Roar';
}

class Lion extends Animal {
  public makeSound() {
    return this.sound;
  }
}

const lion = new Lion();
console.log(lion.makeSound());

medium

A. Error: Cannot access protected property

B. undefined

C. "Roar"

D. Error: Property 'sound' is private

Solution

1. Step 1: Understand protected access

   The property sound is protected, so it can be accessed inside the class and its subclasses like Lion.

2. Step 2: Trace method call and output

   The makeSound method returns this.sound, which is "Roar". So, console.log prints "Roar".

3. Final Answer:

   "Roar" -> Option C

4. Quick Check:

   Protected allows subclass access [OK]

Hint: Protected allows subclass access, so value is returned [OK]

Common Mistakes:

• Thinking protected is inaccessible outside class
• Confusing private with protected
• Expecting runtime error for protected access

4. Identify the error in the following TypeScript code:

class Person {
  private name: string = 'Alice';
}

const p = new Person();
console.log(p.name);

medium

A. Error: Property 'name' is protected, not accessible

B. No error, prints 'Alice'

C. Syntax error: missing constructor

D. Error: Cannot access private property 'name' outside class

Solution

1. Step 1: Check access modifier usage

   The property name is declared private, so it cannot be accessed outside the class Person.

2. Step 2: Analyze the console.log statement

   Trying to access p.name outside the class causes a compile-time error about private access.

3. Final Answer:

   Error: Cannot access private property 'name' outside class -> Option D

4. Quick Check:

   Private blocks outside access [OK]

Hint: Private blocks outside class access, causing error [OK]

Common Mistakes:

• Assuming private properties are accessible outside
• Confusing private with protected
• Expecting code to print property value

5. Given the following TypeScript classes, which line will cause a compilation error?

class Vehicle {
  protected speed: number = 0;
  private engineOn: boolean = false;

  public start() {
    this.engineOn = true;
  }
}

class Car extends Vehicle {
  public accelerate() {
    this.speed += 10;  // Line 1
    this.engineOn = true; // Line 2
  }
}

const car = new Car();
car.accelerate();

hard

A. Line 2: Accessing private property 'engineOn' in subclass

B. No error, both lines are valid

C. Line 1: Accessing protected property 'speed' in subclass

D. Error at car.accelerate() call

Solution

1. Step 1: Understand access levels of properties

   speed is protected, so accessible in subclass Car. engineOn is private, accessible only inside Vehicle.

2. Step 2: Analyze lines in subclass method

   Line 1 accesses speed and is valid. Line 2 tries to access engineOn directly, which causes a compilation error.

3. Final Answer:

   Line 2: Accessing private property 'engineOn' in subclass -> Option A

4. Quick Check:

   Private blocks subclass access [OK]

Hint: Private blocks subclass access; protected allows it [OK]

Common Mistakes:

• Assuming private is accessible in subclasses
• Thinking protected is private
• Ignoring error on private property access