Differences between Public, Private, Protected, and Abstract Modifiers in TypeScript

In TypeScript, access modifiers control the visibility of class members, such as properties and methods. They define which parts of the code can access these members.

Public:

The default modifier in TypeScript.
Allows members to be accessed by any class, inside or outside the class in which they were declared.
Example:

class Person {
  public name: string;

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

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

const person = new Person('John Doe');
person.greet(); // Output: Hello, my name is John Doe

Private:

Restricts access to members to the class in which they are declared.
Example:

class Person {
  private name: string;

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

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

const person = new Person('John Doe');
// person.name is inaccessible outside the Person class

Protected:

Allows access to members within the class in which they are declared and its subclasses.
Example:

class Person {
protected name: string;

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

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

class Student extends Person {
  public studentId: number;

  constructor(name: string, studentId: number) {
    super(name);
    this.studentId = studentId;
  }

  public override greet() {
    super.greet();
    console.log(`I am also a student with ID ${this.studentId}`);
  }
}

const student = new Student('John Doe', 12345);
student.greet(); // Output: Hello, my name is John Doe. I am also a student with ID 12345

Abstract:

Indicates that a method or property must be implemented in derived classes.
Abstract members cannot have a direct implementation in the base class.
Example:

abstract class Shape {
  abstract getArea(): number;

  public abstract toString(): string;
}

class Circle extends Shape {
  private radius: number;

  constructor(radius: number) {
    super();
    this.radius = radius;
  }

  public getArea(): number {
    return Math.PI * this.radius * this.radius;
  }

  public toString(): string {
    return `Circle with radius ${this.radius}`;
  }
}

const circle = new Circle(5);
console.log(circle.getArea()); // Output: 78.53975
console.log(circle.toString()); // Output: Circle with radius 5

In summary, access modifiers control the accessibility of class members, while the abstract modifier defines incomplete methods or properties that must be implemented in subclasses.

Public: The default modifier, allowing members to be accessed anywhere.
Private: Restricts access to the class where the member is declared.
Protected: Allows access within the class and its subclasses.
Abstract: Requires derived classes to implement incomplete methods or properties.

Modified	Visibility	Details
public	Accessible anywhere	Pattern for class members
private	Only within the class	Greater encapsulation
protected	inside the class and derived classes	Promotes reuse in inheritance
abstract	No implementation	Defines a contract for derived classes

Tip:

Remember to choose the appropriate access modifier for each class member, considering the desired level of encapsulation and reuse.

Sources :

github.com/Mcps4/ifpi-ads-eng3-2022

https://pt.stackoverflow.com/questions/559723/quais-as-diferen%C3%A7as-entre-modificadores-public-private-protected-e-abstract-no