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

Chapter 6: Error Handling and TypeScript’s Structural Typing — Java vs. TypeScript

🔹 1. Introduction

Error handling and type safety are core to developing reliable software. Java is known for its strict exception model and nominal typing, while TypeScript offers a more flexible approach with structural typing and JavaScript-style error handling. This chapter breaks down how both languages manage errors and how TypeScript’s typing system contrasts with Java’s.

🔹 2. Exception Handling Basics

✅ Java Exception Handling:

Java uses checked and unchecked exceptions with the try-catch-finally structure.

try {

    int result = 10 / 0;

} catch (ArithmeticException e) {

    System.out.println("Error: " + e.getMessage());

} finally {

    System.out.println("Cleanup code");

}

✅ TypeScript Error Handling:

TypeScript also uses try-catch-finally, but all exceptions are unchecked.

try {

    let result = 10 / 0;

} catch (e) {

    console.error("Error:", e);

} finally {

    console.log("Cleanup code");

}

🔹 3. Checked vs. Unchecked Exceptions (Java-only)

✅ TypeScript has no concept of checked exceptions.

🔹 4. Custom Error Types

✅ Java Custom Exception:

class CustomException extends Exception {

    public CustomException(String message) {

        super(message);

    }

}

✅ TypeScript Custom Error:

class CustomError extends Error {

    constructor(message: string) {

        super(message);

        this.name = "CustomError";

    }

}

✅ Java requires throws declaration for checked exceptions; TypeScript does not.

🔹 5. The finally Block

In both languages, finally is always executed, regardless of success or failure:

finally {

    System.out.println("Closing resources");

}

ts

CopyEdit

finally {

    console.log("Closing resources");

}

🔹 6. Structural vs. Nominal Typing

✅ Java: Nominal Typing

Types must be declared and match by name or hierarchy.

interface Animal {

    void speak();

}

class Dog implements Animal {

    public void speak() { System.out.println("Bark"); }

}

✅ TypeScript: Structural Typing

Any object with a matching structure satisfies the type.

interface Animal {

    speak(): void;

}

const dog = {

    speak: () => console.log("Bark"),

};

function makeAnimalTalk(a: Animal) {

    a.speak();

}

makeAnimalTalk(dog); // ✅ No explicit `implements` needed

🔹 7. Duck Typing in TypeScript

This behavior is sometimes called duck typing:

“If it walks like a duck and quacks like a duck, it’s a duck.”

✅ Only the shape matters — not the name.

🔹 8. Type Compatibility Example

interface Point {

    x: number;

    y: number;

}

let p = { x: 1, y: 2, z: 3 }; // Extra properties allowed

let q: Point = p; // ✅ Allowed due to structural match

✅ Java would throw an error unless p explicitly implemented an interface.

🔹 9. Benefits & Pitfalls

🔹 10. Summary Table