Course contentsShow
← Java
Lesson 886 of 2,87021. Generics FundamentalsFree lesson

Interoperating with Pre-Generics Code

How raw types enable compatibility with legacy Java code written before generics were introduced in Java 5.

Interoperating with Pre-Generics Code

What You'll Learn

You'll understand how raw types serve as a bridge between modern generic code and legacy Java code written before Java 5.

Why Raw Types Exist

When generics were introduced in Java 5 (2004), millions of lines of Java code already existed without type parameters. To prevent breaking all that existing code, Java needed a compatibility mechanism—that's where raw types come in.

Raw types allow old, pre-generics code to work alongside new generic code without requiring massive rewrites of legacy systems.

How Interoperation Works

Imagine you're maintaining a modern application but need to use an old library that returns ArrayList (raw type) instead of ArrayList<String>:

// Legacy library method (pre-Java 5 style)
public ArrayList getLegacyData() {
    ArrayList list = new ArrayList();  // Raw type
    list.add("Hello");
    list.add("World");
    return list;  // Returns raw ArrayList
}

// Your modern code
ArrayList<String> data = getLegacyData();  // Unchecked conversion warning
String text = data.get(0);  // Works, but relies on runtime type

The assignment compiles but produces an "unchecked" warning because the compiler can't verify that the raw ArrayList actually contains String objects—it trusts you're doing the right thing.

The Trade-off

This interoperability is a compromise: you lose compile-time type safety when crossing the boundary between generic and raw code, but your program doesn't break. You get warnings instead of errors, allowing gradual migration of legacy code.

Think of it like an adapter plug for different electrical outlets—it works, but you need to be careful about what you're connecting.

Key Takeaway

Raw types enable backward compatibility by allowing pre-generics and modern generic code to coexist, trading compile-time type safety for the ability to integrate with legacy Java libraries and systems.