Altcademy - a Forbes magazine logo Best Coding Bootcamp 2023

What are Classes in TypeScript?

If you're learning programming, you might have come across the term "classes" in your journey. Classes are a fundamental concept in object-oriented programming (OOP) languages, and TypeScript is no exception. In this blog, we'll dive deep into understanding what classes are in TypeScript, how they work, and why they are useful. We'll provide code examples, analogies, and simple explanations that will make it easy for you to grasp the concept of classes.

What are classes?

Before we dive into TypeScript classes, let's understand the concept of classes in general. A class is like a blueprint or a template for creating objects. When you create an object, you're essentially creating an instance of a class. Classes define the structure and behavior of the objects that belong to them, such as properties (data) and methods (functions).

Think of a class as a recipe, and objects as the dishes made using that recipe. The recipe contains the ingredients (data) and steps (functions) to make a dish, while an object is the final dish itself, made using the recipe.

Why do we need classes?

Classes provide a way to organize and structure our code. They allow us to create reusable components, which promotes the DRY (Don't Repeat Yourself) principle. By encapsulating related data and functions within a class, we can keep our code modular and maintainable.

Imagine you're building a game with various characters. Each character has properties like health, speed, and attack power, and methods like move, attack, and heal. Instead of writing code for each character separately, you can create a class called Character that defines the properties and methods common to all characters. Then, you can create objects (instances) of this class for each character in your game.

Classes in TypeScript

Now that we have a basic understanding of what classes are and why we need them, let's dive into TypeScript classes. TypeScript is a superset of JavaScript, which means it extends the features of JavaScript, including the support for classes.

A class in TypeScript is defined using the class keyword, followed by the name of the class. By convention, class names are written in PascalCase, which means the first letter of each word is capitalized.

Here's a simple example of a class in TypeScript:

class Person {
  name: string;
  age: number;

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

  greet() {
    console.log(`Hello, my name is ${}, and I'm ${this.age} years old.`);

In the example above, we've defined a Person class with two properties, name and age, and two methods, constructor and greet. Let's break down each of these elements.


Properties represent the data or state of an object. In the Person class, we have two properties: name of type string and age of type number. The type annotations ensure that only values of the specified type can be assigned to these properties.


The constructor is a special method that's called when we create a new object (instance) of a class. It's used to initialize the object's properties. In our Person class, the constructor takes two parameters, name and age, and assigns them to the respective properties using the this keyword.

The this keyword refers to the current instance of the class. When you create a new object, this refers to that object. In the example above, and this.age refer to the name and age properties of the object being created.


Methods are functions that define the behavior of an object. In the Person class, we have a greet method that logs a greeting message to the console. Like the constructor, methods can access the object's properties using the this keyword.

Creating objects (instances) of a class

To create a new object (instance) of a class, we use the new keyword, followed by the class name and any arguments required by the constructor.

Here's an example of creating two Person objects:

const alice = new Person("Alice", 30);
const bob = new Person("Bob", 25);

alice.greet(); // Output: Hello, my name is Alice, and I'm 30 years old.
bob.greet(); // Output: Hello, my name is Bob, and I'm 25 years old.

In the example above, we've created two Person objects, alice and bob, with different name and age values. We then called the greet method on each object, which logged a personalized greeting message to the console.


Inheritance is another key concept in OOP. It allows us to create a new class that inherits properties and methods from an existing class. This is useful when we want to create a specialized version of a class without duplicating code.

In TypeScript, we use the extends keyword to create a subclass (child class) that inherits from a superclass (parent class).

Here's an example of inheritance in TypeScript:

class Employee extends Person {
  position: string;

  constructor(name: string, age: number, position: string) {
    super(name, age);
    this.position = position;

  greet() {
    console.log(`Hello, my name is ${}, and I'm a ${this.position}.`);

const charlie = new Employee("Charlie", 40, "Software Engineer");
charlie.greet(); // Output: Hello, my name is Charlie, and I'm a Software Engineer.

In the example above, we've created a new Employee class that extends the Person class. The Employee class has an additional position property, and it overrides the greet method to provide a different greeting message.

The super keyword is used to call the constructor of the superclass. In this case, we're calling the Person constructor with the name and age arguments.


In this blog, we've explored the concept of classes in TypeScript. We've learned that classes are like blueprints for creating objects, and they provide a way to organize and structure our code. We've seen how to define properties, constructors, and methods in a class, and how to create objects (instances) of a class. We've also touched on inheritance, which allows us to create specialized classes that reuse existing code.

As you continue your journey in learning programming, you'll find that classes are an essential building block in creating complex applications. Understanding how they work and how to use them effectively will make your code more modular, maintainable, and reusable.