Object oriented programming in typescript

Level : Advanced
Mentor: Shailendra Chauhan
Duration : 00:03:00

Object-Oriented Programming (OOP):

OOP is a programming paradigm that uses objects and classes to organize and structure code. It encourages the use of objects as self-contained units with properties and methods.

Example:

class Person {
  constructor(private name: string) {}
  sayHello() {
    console.log(`Hello, my name is ${this.name}.`);
  }
}
const user = new Person('Alice');
user.sayHello(); // Output: Hello, my name is Alice.

Working With Classes:

Classes in TypeScript provide a blueprint for creating objects. They encapsulate properties and methods related to a particular entity.

Example:

class Rectangle {
  constructor(private width: number, private height: number) {}
  calculateArea() {
    return this.width * this.height;
  }
}
const rect = new Rectangle(5, 10);
console.log(`Area: ${rect.calculateArea()}`); // Output: Area: 50

Constructors:

Constructors are special methods within classes that are called when an object of the class is created. They initialize object properties.

Example:

class Dog {
  constructor(private name: string) {}
  bark() {
    console.log(`${this.name} says woof!`);
  }
}
const myDog = new Dog('Buddy');
myDog.bark(); // Output: Buddy says woof!

Access Modifiers:

Access modifiers like public, private, and protected control the visibility of class members. They determine whether a member can be accessed outside the class.

Example:

class BankAccount {
  private balance: number = 0;
  constructor(private accountNumber: string) {}
  deposit(amount: number) {
    this.balance += amount;
  }
  getBalance() {
    return this.balance;
  }
}

Readonly Modifiers:

The readonly modifier allows you to create properties that can only be assigned a value once, typically in the constructor.

Example:

class Circle {
  constructor(readonly radius: number) {}
}
const myCircle = new Circle(5);
console.log(`Radius: ${myCircle.radius}`); // Output: Radius: 5

Members and Accessors:

Members are properties and methods of a class. Accessors, like getters and setters, control access to class properties.

Example:

class Temperature {
  private _celsius: number = 0;
  get celsius() {
    return this._celsius;
  }
  set celsius(value: number) {
    this._celsius = value;
  }
}

Instance Members:

Instance members belong to individual objects created from a class.

Example:

class Counter {
  private count: number = 0;
  increment() {
    this.count++;
  }
  getCount() {
    return this.count;
  }
}
const counter1 = new Counter();
const counter2 = new Counter();
counter1.increment();
console.log(`Counter 1: ${counter1.getCount()}`); // Output: Counter 1: 1
console.log(`Counter 2: ${counter2.getCount()}`); // Output: Counter 2: 0

Static Members:

Static members belong to the class itself, not to instances of the class.

Example:

class MathHelper {
  static PI: number = 3.14159;
  static calculateCircleArea(radius: number) {
    return MathHelper.PI * radius * radius;
  }
}
console.log(`Area of a circle with radius 2: ${MathHelper.calculateCircleArea(2)}`); // Output: Area of a circle with radius 2: 12.56636

Accessors:

Accessors, like getters and setters, allow controlled access to class properties.

Example:

class Person {
  private _age: number = 0;
  get age() {
    return this._age;
  }
  set age(value: number) {
    if (value >= 0 && value <= 120) {
      this._age = value;
    } else {
      console.error('Invalid age');
    }
  }
}

Inheritance:

Inheritance allows a class to inherit properties and methods from another class. It promotes code reuse and hierarchy.

Example:

class Animal {
  constructor(private name: string) {}
  makeSound() {
    console.log(`${this.name} makes a sound.`);
  }
}
class Dog extends Animal {
  constructor(name: string, private breed: string) {
    super(name);
  }
  makeSound() {
    console.log(`${this.name} barks.`);
  }
}
const myDog = new Dog('Buddy', 'Golden Retriever');
myDog.makeSound(); // Output: Buddy barks.

Polymorphism:

Polymorphism allows objects of different classes to be treated as instances of a common superclass. It enables flexibility and extensibility in code.

Example:

class Shape {
  area() {
    return 0;
  }
}
class Circle extends Shape {
  constructor(private radius: number) {
    super();
  }
  area() {
    return Math.PI * this.radius * this.radius;
  }
}
class Square extends Shape {
  constructor(private sideLength: number) {
    super();
  }
  area() {
    return this.sideLength * this.sideLength;
  }
}
const shapes: Shape[] = [new Circle(5), new Square(4)];
shapes.forEach((shape) => console.log(`Area: ${shape.area()}`));

Method Overloading:

Method overloading allows a class to have multiple methods with the same name but different parameter types or numbers of parameters.

Example:

class Calculator {
  add(a: number, b: number): number;
  add(a: string, b: string): string;
  add(a: any, b: any): any {
    if (typeof a === 'number' && typeof b === 'number') {
      return a + b;
    } else if (typeof a === 'string' && typeof b === 'string') {
      return a + b;
    }
    return null;
  }
}
const calc = new Calculator();
console.log(calc.add(2, 3)); // Output: 5
console.log(calc.add('Hello', ' TypeScript')); // Output: Hello TypeScript

Abstract Class and Interface:

Abstract classes and interfaces define contracts for classes to follow. Abstract classes can have both concrete and abstract methods, while interfaces only define method signatures.

Example:

abstract class Shape {
  abstract calculateArea(): number;
}
class Circle extends Shape {
  constructor(private radius: number) {
    super();
  }
  calculateArea() {
    return Math.PI * this.radius * this.radius;
  }
}
interface Printable {
  printDetails(): void;
}
class Square implements Printable {
  constructor(private sideLength: number) {}
  printDetails() {
    console.log(`Square with side length ${this.sideLength}`);
  }
}

Interface Usage and Inheritance:

Interfaces can be used to define contracts that classes must implement. They can also be extended by other interfaces to build more specific contracts.

Example:

interface Vehicle {
  start(): void;
  stop(): void;
}
interface ElectricVehicle extends Vehicle {
  charge(): void;
}
class Car implements ElectricVehicle {
  start() {
    console.log('Car started');
  }
  stop() {
    console.log('Car stopped');
  }
  charge() {
    console.log('Charging car');
  }
}

Interface Extending Class:

Interfaces can extend classes to capture the shape of class instances, including their properties and methods.

Example:

class Person {
  constructor(public name: string) {}
  sayHello() {
    console.log(`Hello, my name is ${this.name}.`);
  }
}
interface Greetable extends Person {
  greet(): void;
}
const user: Greetable = new Person('Alice');
user.sayHello(); // Output: Hello, my name is Alice.
user.greet(); // This is allowed due to the interface extending the class.
Self-paced Membership
  • 22+ Video Courses
  • 800+ Hands-On Labs
  • 400+ Quick Notes
  • 55+ Skill Tests
  • 45+ Interview Q&A Courses
  • 10+ Real-world Projects
  • Career Coaching Sessions
  • Email Support
Upto 60% OFF
Know More
Still have some questions? Let's discuss.
CONTACT US
Accept cookies & close this