Abstract Classes
A TypeScript abstract class is a base class that you cannot instantiate directly. It exists to be extended by subclasses, which must fill in the missing pieces. Abstract classes let you share real code while forcing each subclass to provide its own version of key methods. In real projects, they model templates: common steps in one place, specific steps in each child.
This tutorial explains what an abstract class is, how abstract methods and properties work, how concrete methods are shared, how to extend an abstract class, and how to choose between an abstract class and an interface. You will also see the exact compiler error when you try to create an instance of an abstract class.
What Is a TypeScript Abstract Class?
A TypeScript abstract class is a class marked with the abstract keyword that cannot be instantiated with new. It may contain abstract members, which have no body and must be implemented by any subclass, and concrete members, which have full implementations and are inherited.
Here is a simple example:
abstract class Shape {
abstract area(): number;
}
class Square extends Shape {
constructor(private side: number) {
super();
}
area(): number {
return this.side ** 2;
}
}
const s = new Square(4);
console.log(s.area());
// Output: 16
Shape cannot be created directly. Square extends it and provides area. The compiler guarantees that any concrete subclass has an area method.
Why Can an Abstract Class Not Be Instantiated?
An abstract class is incomplete by design. It declares methods without bodies because it does not know how they should work. Creating an instance would produce an object with missing behavior, so TypeScript blocks it. The error is clear and points to the new call.
abstract class Payment {
abstract process(): string;
}
// const p = new Payment();
// Error: Cannot create an instance of an abstract class.
class CardPayment extends Payment {
process(): string {
return "Charging card";
}
}
const c = new CardPayment();
console.log(c.process());
// Output: Charging card
How it works: The Payment class has an abstract process method with no body, so it cannot be instantiated. CardPayment provides the body, so it is concrete and can be created. This is the core rule: abstract classes exist for extension, not for direct use.
How Do Abstract Methods and Abstract Properties Work?
An abstract method is declared with the abstract keyword and has no body. An abstract property is declared with abstract and no initial value. Both must be implemented in every concrete subclass. The compiler checks that each concrete class provides them.
abstract class Employee {
abstract role: string;
abstract salary(): number;
}
class Manager extends Employee {
role = "manager";
salary(): number {
return 90000;
}
}
const m = new Manager();
console.log(m.role, m.salary());
// Output: manager 90000
How it works: Employee declares role and salary as abstract, meaning it does not provide values or bodies. Manager supplies both. If you forgot salary, the compiler would report that Manager does not implement the abstract member. Abstract properties are useful when every subclass must define a key field, such as a role or a type identifier.
How Do Concrete Methods Get Shared?
A concrete method has a full body and is inherited by subclasses. This is where abstract classes shine: you write shared logic once in the base class, and each subclass can override it or use it directly. The base class often calls its own abstract methods, which is the template method pattern.
abstract class Report {
abstract rows(): string[];
print(): void {
const lines = this.rows();
console.log(`Report with ${lines.length} rows`);
for (const line of lines) {
console.log(`- ${line}`);
}
}
}
class SalesReport extends Report {
rows(): string[] {
return ["North: 100", "South: 250"];
}
}
new SalesReport().print();
// Output:
// Report with 2 rows
// - North: 100
// - South: 250
How it works: Report provides a concrete print method that formats and prints rows. It calls this.rows(), which is abstract. Each subclass supplies its own rows. The template method pattern means the base class controls the flow, and subclasses fill in the data. This is one of the most useful patterns in real code, from report generators to HTTP handlers.
How Do You Extend an Abstract Class?
You extend an abstract class with extends, just like a normal class. If the abstract class has a constructor, the subclass must call super(...) before using this. The subclass must also implement every abstract member, or it must itself be declared abstract.
abstract class Vehicle {
constructor(public wheels: number) {}
abstract fuel(): string;
describe(): string {
return `${this.wheels} wheels, fuel: ${this.fuel()}`;
}
}
class Car extends Vehicle {
constructor() {
super(4);
}
fuel(): string {
return "petrol";
}
}
class Bike extends Vehicle {
constructor() {
super(2);
}
fuel(): string {
return "petrol";
}
}
console.log(new Car().describe());
console.log(new Bike().describe());
// Output: 4 wheels, fuel: petrol
// Output: 2 wheels, fuel: petrol
How it works: Vehicle has a constructor that sets wheels, an abstract fuel method, and a concrete describe that uses both. Car and Bike call super with different wheel counts and provide their own fuel. The shared describe works for both because it relies on the abstract fuel being implemented.
Abstract Class vs Interface: How Do You Choose?
An abstract class and an interface both define contracts, but they differ in what they can contain and how they are used. The table below compares them.
| Feature | Abstract Class | Interface |
|---|---|---|
| Can contain implementation | Yes | No |
| Can be instantiated | No | No |
| Can have constructors | Yes | No |
| Can have abstract members | Yes | Yes (as signatures) |
| Multiple inheritance | No, single parent | Yes, a class can implement many |
| Runtime presence | Yes | No |
| Best for | Shared code plus a contract | Pure shape contracts |
A practical guideline: use an abstract class when subclasses should share real code and state, such as a template method or common validation. Use an interface when you only need to describe a shape and want maximum flexibility, including letting a class implement several contracts. You can learn more in the TypeScript Interfaces tutorial.
What Error Appears When You Instantiate an Abstract Class?
The compiler error is short and clear. It appears at the new expression, so you know exactly where the problem is.
abstract class Logger {
abstract log(message: string): void;
}
// const l = new Logger();
// Error: Cannot create an instance of an abstract class.
How it works: The compiler sees the abstract modifier on Logger and rejects any new Logger() call. It does not matter whether the abstract class has zero, one, or many abstract members; the rule is the same. You must create a concrete subclass and use that instead.
Common Mistakes and Best Practices
- Trying to instantiate the abstract class. The compiler blocks it because the class is incomplete. Create a concrete subclass that implements every abstract member, then instantiate that.
- Forgetting to implement an abstract member. A concrete subclass must implement all abstract methods and properties. If it does not, the compiler reports a missing implementation error. Make the subclass abstract if it is not ready.
- Putting too much logic in the base class. A large base class becomes hard to change without breaking every subclass. Keep the base focused on shared steps and let subclasses own the details.
- Using an abstract class when an interface would do. If you only need a contract with no shared code, an interface is simpler and allows multiple implementations. Reach for an abstract class when you genuinely want to share behavior.
- Forgetting
super()when the base has a constructor. A subclass with a constructor must callsuper(...)before usingthis. Missing it produces a compile error and a broken runtime.
Real-World Example: Abstract Shape with Area and Describe
This example uses an abstract Shape class with an abstract area and a concrete describe, plus Circle and Rectangle subclasses.
abstract class Shape {
constructor(public readonly name: string) {}
abstract area(): number;
describe(): string {
return `${this.name} has area ${this.area().toFixed(2)}`;
}
}
class Circle extends Shape {
constructor(public radius: number) {
super("Circle");
}
area(): number {
return Math.PI * this.radius ** 2;
}
}
class Rectangle extends Shape {
constructor(public width: number, public height: number) {
super("Rectangle");
}
area(): number {
return this.width * this.height;
}
}
const shapes: Shape[] = [new Circle(2), new Rectangle(3, 4)];
for (const shape of shapes) {
console.log(shape.describe());
}
// Output:
// Circle has area 12.57
// Rectangle has area 12.00
How it works, line by line. Shape is abstract, so it cannot be created. It has a readonly name set in the constructor, an abstract area method, and a concrete describe that calls this.area(). Circle calls super("Circle") and implements area with the circle formula. Rectangle calls super("Rectangle") and implements area as width times height. The shapes array is typed as Shape[], so it accepts both subclasses. The loop calls describe, which is inherited from Shape, and each subclass's area runs. This is the template method pattern in action: the flow lives in the base, the math lives in the children. If you tried new Shape("x"), the compiler would report the abstract instantiation error.
Summary
- A TypeScript abstract class is a base class that cannot be instantiated and exists to be extended.
- Abstract methods and properties have no implementation and must be provided by concrete subclasses.
- Concrete methods in an abstract class are shared, and they often call abstract methods to form a template.
- Subclasses use
extends, callsuper()when needed, and must implement all abstract members. - Choose an abstract class for shared code plus a contract; choose an interface for a pure shape.
- Instantiation errors are clear: "Cannot create an instance of an abstract class."
Now that you can build templates with abstract classes, continue to the TypeScript Generics tutorial to learn how to write reusable code that works with many types while staying type-safe.
Frequently Asked Questions
Can an abstract class have a constructor?
Yes. An abstract class can have a constructor, and it runs when a subclass creates an instance. The subclass must call super(...) before using this. The constructor is useful for setting shared fields like a name or an ID that every subclass needs.
Can an abstract class have no abstract methods?
Yes. A class can be marked abstract even if it has no abstract members. This still blocks direct instantiation and signals that the class is a base for extension. It is a way to say "do not create this directly" without forcing subclasses to implement anything.
What happens if a subclass does not implement an abstract method?
The compiler reports an error saying the subclass does not implement the inherited abstract member. To fix it, either add the missing method or mark the subclass as abstract too, which pushes the requirement down to its own subclasses.
Can an abstract class implement an interface?
Yes. An abstract class can implement an interface, which means it promises the shape. It can implement some members and leave others abstract for subclasses. This combines a contract with shared code, which is a common pattern in larger systems.
Are abstract classes available at runtime?
Yes. Abstract classes compile to regular JavaScript classes. The abstract keyword is removed, but the class and its methods remain. Instantiation is blocked only by the TypeScript compiler, not by JavaScript. In plain JavaScript, you could technically call new on the compiled class, which is why using TypeScript is important for this guarantee.
Practice Exercises
Exercise 1 (Easy): Create an Abstract Class
Create an abstract class Animal with an abstract speak(): string method. Create a subclass Cat that implements it and prints the result.
Show solution
abstract class Animal {
abstract speak(): string;
}
class Cat extends Animal {
speak(): string {
return "Meow";
}
}
console.log(new Cat().speak());
// Output: Meow
The abstract method has no body, so Cat must provide one before it can be instantiated.
Exercise 2 (Easy): Add a Concrete Shared Method
Extend Animal with a concrete describe() that returns This animal says ${this.speak()}. Call it from Cat.
Show solution
abstract class Animal {
abstract speak(): string;
describe(): string {
return `This animal says ${this.speak()}`;
}
}
class Cat extends Animal {
speak(): string {
return "Meow";
}
}
console.log(new Cat().describe());
// Output: This animal says Meow
The base class owns the formatting, and the subclass supplies the specific sound through the abstract method.
Exercise 3 (Medium): Abstract Property
Create an abstract class Payment with an abstract provider: string property and an abstract process(): string method. Create UpiPayment that sets provider and implements process.
Show solution
abstract class Payment {
abstract provider: string;
abstract process(): string;
}
class UpiPayment extends Payment {
provider = "UPI";
process(): string {
return `${this.provider} payment started`;
}
}
console.log(new UpiPayment().process());
// Output: UPI payment started
The abstract property forces every subclass to declare a provider, and the method uses it in the shared logic.
Exercise 4 (Challenge): Template Method with Abstract Steps
Create an abstract class Exporter with an abstract data(): string[] and a concrete run() that prints each row with a prefix. Create CsvExporter and JsonExporter subclasses and run both.
Show solution
abstract class Exporter {
abstract data(): string[];
run(): void {
for (const row of this.data()) {
console.log(`[export] ${row}`);
}
}
}
class CsvExporter extends Exporter {
data(): string[] {
return ["a,b", "1,2"];
}
}
class JsonExporter extends Exporter {
data(): string[] {
return ['{"a":1}', '{"b":2}'];
}
}
new CsvExporter().run();
new JsonExporter().run();
// Output:
// [export] a,b
// [export] 1,2
// [export] {"a":1}
// [export] {"b":2}
run is the template method: it controls the loop and prefix, while each subclass supplies its own rows.
Written by Shaikh Abdul Shahid
A Full-Stack Developer with experience in PHP, Laravel, JavaScript, and React.
Founder of Online Learner, sharing practical knowledge and programming tutorials.
Building and maintaining real-world web applications since 2017.
Your Feedback
Help us improve by sharing your thoughts.
Online Learner helps developers master programming, database concepts, interview preparation, and real-world implementation through structured learning paths.
Quick Links
© 2023 - 2026 OnlineLearner.in | All Rights Reserved.
