Understanding TypeScript Concepts Through Java: A Cross-Paradigm Learning Guide

Chapter 5: Generics in TypeScript and Java

🔹 1. Introduction

Generics are one of the most powerful features of both Java and TypeScript, allowing developers to write flexible and type-safe code. Generics enable functions, classes, and interfaces to work with multiple data types without sacrificing type safety.

While their syntax and usage are quite similar across Java and TypeScript, there are important differences in type constraints, inference, and runtime behavior that developers should understand. This chapter explores the generics system of both languages in depth.

🔹 2. Basic Syntax of Generics

✅ Java Generic Method:

public class GenericExample {

    public static <T> void printArray(T[] array) {

        for (T item : array) {

            System.out.println(item);

        }

    }

}

✅ TypeScript Generic Function:

function printArray<T>(arr: T[]): void {

    arr.forEach(item => console.log(item));

}

✅ Both use the angle bracket syntax <T>, which is a placeholder for a type.

🔹 3. Generic Classes

✅ Java:

class Box<T> {

    private T value;

    public void set(T value) { this.value = value; }

    public T get() { return value; }

}

✅ TypeScript:

class Box<T> {

    private value: T;

    constructor(value: T) {

        this.value = value;

    }

    getValue(): T {

        return this.value;

    }

}

✅ You can create an object with a specific type:

Box<String> stringBox = new Box<>();

const stringBox = new Box<string>("Hello");

🔹 4. Multiple Generic Types

✅ Java:

class Pair<K, V> {

    K key;

    V value;

}

✅ TypeScript:

class Pair<K, V> {

    key: K;

    value: V;

    constructor(key: K, value: V) {

        this.key = key;

        this.value = value;

    }

}

✅ Both allow defining multiple types generically.

🔹 5. Type Constraints

✅ Java (Bounded Types):

class NumberBox<T extends Number> {

    T value;

}

✅ TypeScript (Type Constraint):

function getLength<T extends { length: number }>(item: T): number {

    return item.length;

}

✅ Both languages support restricting generic types to those that satisfy specific criteria.

🔹 6. Wildcards vs. any vs. Unknown

✅ Java Wildcard Example:

List<?> list = new ArrayList<String>();

✅ TypeScript any / unknown:

let data: any;

let safeData: unknown;

🔸 Use unknown for safety; avoid any when possible.

🔹 7. Type Inference

Both Java and TypeScript can infer generic types:

✅ Java:

List<String> list = Arrays.asList("a", "b", "c");

✅ TypeScript:

let items = ["a", "b", "c"]; // inferred as string[]

✅ You can also explicitly pass types when inference fails:

let ids = identity<number>(123);

🔹 8. Type Erasure

✅ Java:

Java erases generic type information at runtime.

List<String> list = new ArrayList<>();

List<Integer> list2 = new ArrayList<>();

System.out.println(list.getClass() == list2.getClass()); // true

✅ TypeScript:

TypeScript strips types entirely at compile time because JavaScript doesn’t support them.

function identity<T>(value: T): T {

    return value;

}

✅ Type checking is only at compile time — no generics at runtime.

🔹 9. Generic Interfaces

✅ Java:

interface Printer<T> {

    void print(T value);

}

✅ TypeScript:

interface Printer<T> {

    print(value: T): void;

}

✅ Both allow defining contracts over a type.

🔹 10. Summary Table