Generics and Type Safety

Java Programming (4343203)

Lecture 18

Unit 4: Advanced Java - Type Safety
GTU Computer Engineering Semester 4

Learning Objectives

• Understand the need for generics in Java programming
• Create and use generic classes and interfaces
• Implement generic methods and constructors
• Master bounded type parameters and wildcards
• Apply type erasure concepts and limitations
• Utilize generic collections for type-safe programming

Why Do We Need Generics?

// Pre-Java 5 code (without generics)
import java.util.*;

public class PreGenericsExample {
    public static void main(String[] args) {
        // Raw type ArrayList
        ArrayList list = new ArrayList();
        
        list.add("Hello");
        list.add("World");
        list.add(42); // Oops! Integer in String list
        
        // No compile-time type checking
        for (Object obj : list) {
            String str = (String) obj; // ClassCastException!
            System.out.println(str.toUpperCase());
        }
    }
}
                        

// Java 5+ code (with generics)
import java.util.*;

public class WithGenericsExample {
    public static void main(String[] args) {
        // Generic ArrayList
        ArrayList list = new ArrayList();
        
        list.add("Hello");
        list.add("World");
        // list.add(42); // Compile-time error!
        
        // No explicit casting needed
        for (String str : list) {
            System.out.println(str.toUpperCase());
        }
        
        // Type-safe retrieval
        String first = list.get(0); // No casting
    }
}
                        

Generic Classes

Creating a Generic Class

// Generic Box class
public class Box {
    private T content;
    
    // Constructor
    public Box(T content) {
        this.content = content;
    }
    
    // Generic methods
    public T getContent() {
        return content;
    }
    
    public void setContent(T content) {
        this.content = content;
    }
    
    // Method with generic parameter
    public boolean isSameType(Box other) {
        return this.content.getClass().equals(other.content.getClass());
    }
    
    @Override
    public String toString() {
        return "Box{content=" + content + ", type=" + content.getClass().getSimpleName() + "}";
    }
}

// Usage examples
public class GenericClassDemo {
    public static void main(String[] args) {
        // Creating generic instances
        Box stringBox = new Box<>("Hello Generics!");
        Box integerBox = new Box<>(42);
        Box doubleBox = new Box<>(3.14);
        
        System.out.println("String box: " + stringBox);
        System.out.println("Integer box: " + integerBox);
        System.out.println("Double box: " + doubleBox);
        
        // Type-safe operations
        String str = stringBox.getContent(); // No casting needed
        Integer num = integerBox.getContent();
        
        // stringBox.setContent(123); // Compile-time error!
        stringBox.setContent("Updated content"); // OK
        
        // Comparing types
        Box anotherStringBox = new Box<>("Another string");
        System.out.println("Same type? " + stringBox.isSameType(anotherStringBox));
        
        // Diamond operator (Java 7+)
        Box diamondBox = new Box<>("Diamond operator");
        System.out.println("Diamond box: " + diamondBox);
    }
}
                

Multiple Type Parameters

// Generic class with multiple type parameters
public class Pair {
    private T first;
    private U second;
    
    public Pair(T first, U second) {
        this.first = first;
        this.second = second;
    }
    
    // Getters and setters
    public T getFirst() { return first; }
    public void setFirst(T first) { this.first = first; }
    
    public U getSecond() { return second; }
    public void setSecond(U second) { this.second = second; }
    
    // Utility method
    public void swap() {
        // This won't work because T and U might be different types
        // We need bounded types or careful design
    }
    
    @Override
    public String toString() {
        return "Pair{first=" + first + ", second=" + second + "}";
    }
    
    // Static generic method
    public static  Pair of(T first, U second) {
        return new Pair<>(first, second);
    }
}

// Generic Triple class
public class Triple {
    private T first;
    private U second;
    private V third;
    
    public Triple(T first, U second, V third) {
        this.first = first;
        this.second = second;
        this.third = third;
    }
    
    // Getters
    public T getFirst() { return first; }
    public U getSecond() { return second; }
    public V getThird() { return third; }
    
    @Override
    public String toString() {
        return String.format("Triple{%s, %s, %s}", first, second, third);
    }
}

// Usage demonstration
public class MultipleTypeParametersDemo {
    public static void main(String[] args) {
        // Different type combinations
        Pair nameAge = new Pair<>("Alice", 25);
        Pair idName = new Pair<>(101, "Bob");
        Pair scorePass = new Pair<>(85.5, true);
        
        System.out.println("Name-Age: " + nameAge);
        System.out.println("ID-Name: " + idName);
        System.out.println("Score-Pass: " + scorePass);
        
        // Using static factory method
        Pair coordinates = Pair.of("X", "Y");
        System.out.println("Coordinates: " + coordinates);
        
        // Triple example
        Triple studentRecord = 
            new Triple<>("Charlie", 22, 3.8);
        System.out.println("Student: " + studentRecord);
        
        // Nested generics
        Pair> complexPair = 
            new Pair<>("Student", new Pair<>(20, 3.5));
        System.out.println("Complex pair: " + complexPair);
    }
}
                

Generic Methods

public class GenericMethods {
    
    // Generic static method
    public static  void swap(T[] array, int i, int j) {
        if (i >= 0 && j >= 0 && i < array.length && j < array.length) {
            T temp = array[i];
            array[i] = array[j];
            array[j] = temp;
        }
    }
    
    // Generic method with return type
    public static  T getMiddleElement(T[] array) {
        if (array == null || array.length == 0) {
            return null;
        }
        return array[array.length / 2];
    }
    
    // Generic method with multiple type parameters
    public static  boolean areEqual(T obj1, U obj2) {
        return obj1 != null && obj1.equals(obj2);
    }
    
    // Generic method in non-generic class
    public  Box createBox(T content) {
        return new Box<>(content);
    }
    
    // Generic method with bounded type parameter
    public static  double getAverage(T[] numbers) {
        double sum = 0.0;
        for (T num : numbers) {
            sum += num.doubleValue();
        }
        return sum / numbers.length;
    }
    
    // Generic method with multiple bounds
    public static > T findMax(T[] array) {
        if (array == null || array.length == 0) {
            return null;
        }
        
        T max = array[0];
        for (int i = 1; i < array.length; i++) {
            if (array[i].compareTo(max) > 0) {
                max = array[i];
            }
        }
        return max;
    }
    
    // Generic method for printing arrays
    public static  void printArray(String name, T[] array) {
        System.out.print(name + ": [");
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]);
            if (i < array.length - 1) System.out.print(", ");
        }
        System.out.println("]");
    }
    
    public static void main(String[] args) {
        // Test generic methods
        
        // String array operations
        String[] names = {"Alice", "Bob", "Charlie", "Diana"};
        printArray("Original names", names);
        
        swap(names, 0, 2);
        printArray("After swapping 0 and 2", names);
        
        String middleName = getMiddleElement(names);
        System.out.println("Middle name: " + middleName);
        
        // Integer array operations
        Integer[] numbers = {10, 20, 30, 40, 50};
        printArray("Numbers", numbers);
        
        Integer middleNumber = getMiddleElement(numbers);
        System.out.println("Middle number: " + middleNumber);
        
        double average = getAverage(numbers);
        System.out.println("Average: " + average);
        
        Integer maxNumber = findMax(numbers);
        System.out.println("Max number: " + maxNumber);
        
        // Double array
        Double[] decimals = {3.14, 2.71, 1.41, 1.73};
        Double maxDecimal = findMax(decimals);
        System.out.println("Max decimal: " + maxDecimal);
        
        // Equality testing
        System.out.println("Are 'Hello' and 'Hello' equal? " + areEqual("Hello", "Hello"));
        System.out.println("Are 42 and 42.0 equal? " + areEqual(42, 42.0));
        
        // Creating boxes using generic method
        GenericMethods gm = new GenericMethods();
        Box stringBox = gm.createBox("Generic Method Created");
        Box intBox = gm.createBox(100);
        
        System.out.println("Created boxes:");
        System.out.println("  " + stringBox);
        System.out.println("  " + intBox);
    }
}
                

Bounded Type Parameters

// Upper bounded with extends
class NumberBox {
    private T value;
    
    public NumberBox(T value) {
        this.value = value;
    }
    
    public T getValue() {
        return value;
    }
    
    // Can call Number methods
    public double getDoubleValue() {
        return value.doubleValue();
    }
    
    // Can call Number methods
    public int getIntValue() {
        return value.intValue();
    }
    
    // Comparison method
    public boolean isGreaterThan(NumberBox other) {
        return this.value.doubleValue() > 
               other.value.doubleValue();
    }
}

// Usage
public class BoundedDemo {
    public static void main(String[] args) {
        NumberBox intBox = 
            new NumberBox<>(42);
        NumberBox doubleBox = 
            new NumberBox<>(3.14);
        
        System.out.println("Int value: " + 
                          intBox.getDoubleValue());
        System.out.println("Double value: " + 
                          doubleBox.getIntValue());
        
        // NumberBox stringBox = 
        //     new NumberBox<>("Hello"); // Error!
    }
}
                        

// Interface for comparison
interface Printable {
    void print();
}

// Class implementing the interface
class PrintableNumber extends Number 
        implements Printable, Comparable {
    private double value;
    
    public PrintableNumber(double value) {
        this.value = value;
    }
    
    @Override
    public void print() {
        System.out.println("Value: " + value);
    }
    
    @Override
    public int compareTo(PrintableNumber other) {
        return Double.compare(this.value, other.value);
    }
    
    @Override
    public int intValue() { return (int) value; }
    
    @Override
    public long longValue() { return (long) value; }
    
    @Override
    public float floatValue() { return (float) value; }
    
    @Override
    public double doubleValue() { return value; }
    
    @Override
    public String toString() { 
        return String.valueOf(value); 
    }
}

// Generic class with multiple bounds
class AdvancedBox> {
    private T content;
    
    public AdvancedBox(T content) {
        this.content = content;
    }
    
    public T getContent() {
        return content;
    }
    
    public void printContent() {
        content.print(); // From Printable
    }
    
    public double getNumericValue() {
        return content.doubleValue(); // From Number
    }
    
    public boolean isGreaterThan(AdvancedBox other) {
        return content.compareTo(other.content) > 0; // From Comparable
    }
}
                        

Wildcards in Generics

Unbounded Wildcards

import java.util.*;

public class WildcardsDemo {
    
    // Unbounded wildcard - can accept any type
    public static void printList(List list) {
        for (Object item : list) {
            System.out.print(item + " ");
        }
        System.out.println();
    }
    
    // Upper bounded wildcard - accepts Number and its subtypes
    public static double sumNumbers(List numbers) {
        double sum = 0.0;
        for (Number num : numbers) {
            sum += num.doubleValue();
        }
        return sum;
    }
    
    // Lower bounded wildcard - accepts Number and its supertypes
    public static void addNumbers(List numbers) {
        numbers.add(42);
        numbers.add(3.14);
        numbers.add(100L);
        // numbers.add("Hello"); // Compile error - String is not Number or supertype
    }
    
    // Method demonstrating PECS principle
    // Producer Extends, Consumer Super
    public static  void copy(List source, List destination) {
        for (T item : source) {
            destination.add(item);
        }
    }
    
    public static void main(String[] args) {
        System.out.println("=== Wildcards Demonstration ===");
        
        // Different types of lists
        List stringList = Arrays.asList("Hello", "World", "Generics");
        List intList = Arrays.asList(1, 2, 3, 4, 5);
        List doubleList = Arrays.asList(1.1, 2.2, 3.3);
        
        // Unbounded wildcard usage
        System.out.println("Printing different types of lists:");
        printList(stringList);
        printList(intList);
        printList(doubleList);
        
        // Upper bounded wildcard
        System.out.println("Sum of integers: " + sumNumbers(intList));
        System.out.println("Sum of doubles: " + sumNumbers(doubleList));
        // System.out.println("Sum of strings: " + sumNumbers(stringList)); // Error!
        
        // Lower bounded wildcard
        List numberList = new ArrayList<>();
        List