Introduction
TypeScript offers powerful object-oriented programming capabilities through classes and object interfaces. For developers familiar with object-oriented languages like Java or C#, TypeScript will feel very natural with the added benefits of JavaScript flexibility.
In this in-depth guide, we’ll explore how to define classes and Objects in TypeScript. We’ll look at access modifiers, constructors, inheritance, static members, and more. Practical examples will illustrate key concepts like encapsulation and polymorphism applied in TypeScript.
Whether you’re new to TypeScript or want a deeper understanding of OOP principles, this guide has you covered. Let’s dive in!
Defining Classes and Objects in TypeScript
A class in TypeScript represents a blueprint for creating objects. You can define properties, methods, constructors, and more:
class Person {
name: string;
constructor(name: string) {
this.name = name;
}
greet() {
console.log(`Hello, my name is ${this.name}!`);
}
}
let person = new Person("John");
person.greet(); // Hello, my name is John!This defines a Person class with a name property and greet method. The constructor assigns the name parameter to the object instance.
We create a new Person, call greet(), and log a message using the name value.
Some key properties of TypeScript classes:
- Instance properties and methods accessed via
this - Constructor defined to initialize object state
- Classes can extend other classes (inheritance)
- Access modifiers like
public,privateto encapsulate state staticmethods work on the class directly
Let’s explore some of these in more detail.
Constructors and Initialization
The constructor in a TypeScript class handles initializing the state of a new object instance:
class Point {
x: number;
y: number;
constructor(x: number, y: number) {
this.x = x;
this.y = y;
}
}
let p = new Point(5, 3);Here the constructor takes x and y parameters and assigns them to the instance’s x and y properties. This ensures each new Point is properly initialized.
You can also use shortcut syntax for declaring and assigning properties:
constructor(public x: number, public y: number) { }This implicitly declares x and y properties and assigns the parameters.
Access Modifiers and Encapsulation
TypeScript supports public, private, and protected access modifiers for properties and methods:
Public members are accessible from anywhere:
class Person {
public name: string;
// ...
}Private members are only accessible within the class:
class Person {
private ssn: string;
// ...
}This encapsulates state for data hiding.
Protected acts like private but allows subclass access.
Encapsulation with access modifiers is a key OOP principle. It helps manage complexity and reduce external dependencies.
Inheritance and Polymorphism
TypeScript classes support inheritance using the extends keyword:
class Employee extends Person {
salary: number;
// ...
}This creates an Employee class that inherits from Person. It gains all the properties and methods of Person.
We can override methods to achieve polymorphism:
class Employee extends Person {
// Override greet()
greet() {
console.log("Hello from employee!");
}
}Even though Employee inherits greet() from Person, we override it with custom logic. The reference type determines which greet() is called.
This allows varying functionality for the same method call.
Static Members
Static class members belong to the class itself rather than instances:
class Helper {
static name = "Helper";
static display() {
console.log("I'm a helper!")
}
}We access these directly off the class:
Helper.name; // "Helper"
Helper.display(); // "I'm a helper!"This is useful for utility methods and singleton-like behavior.
Interfaces
An interface defines a “contract” that classes must satisfy. For example:
interface Vehicle {
speed: number;
start(): void;
stop(): void;
}Any class implementing Vehicle must have matching properties and methods:
class Car implements Vehicle {
// Required by Vehicle interface
speed: number = 0;
start() {
// ...
}
stop() {
// ...
}
}Interfaces are a powerful way to define requirements and abstract behavior in TypeScript.
In Summary
TypeScript offers all the major OOP constructs like classes, inheritance, polymorphism and encapsulation. Mastering TypeScript classes allows elegant object-oriented design.
The key concepts include:
- Defining classes with properties, methods, and constructors
- Using access modifiers for encapsulation
- Inheriting behavior through the
extendskeyword - Overriding methods for polymorphism
- Adding static members to classes
- Enforcing contracts through interfaces
With a strong grasp of TypeScript OOP, you can write reusable, maintainable code leveraging proven techniques. The benefits become clear as applications scale in size and complexity.
Frequently Asked Questions
Here are some common questions about classes and objects in TypeScript:
Q: What is the difference between classes and interfaces in TypeScript?
A: Classes are blueprints that generate objects. Interfaces define contracts for what classes must implement. A class can implement multiple interfaces.
Q: How do you make a class property private in TypeScript?
A: Use the private access modifier on a property to make it private to the containing class. This encapsulates state.
Q: Can you create static members in a TypeScript class?
A: Yes, use the static keyword on properties and methods to make them static. Static members are accessed directly from the class.
Q: Is TypeScript classes just syntactical sugar over prototype-based inheritance?
A: Yes, TypeScript compiles classes down to JavaScript prototypes. But classes provide a cleaner OOP syntax on top.
Q: What is the benefit of inheritance in TypeScript classes?
A: Inheritance allows classes to reuse logic from parent classes. It reduces code duplication and enables polymorphic behavior.
