Java Labs Page 6 - Generics, Enums & Regex

Lab 16: Generics

Advanced

Coding Challenge

Your Task: Create type-safe generic classes and methods to understand how Java generics provide compile-time type checking.

Detailed Requirements:
1. Create a generic class Box<T>:
   • class Box<T> { private T value; }
   • Constructor that accepts T
   • Getter method: T getValue()
   • Setter method: void setValue(T value)

2. Create a generic method:
   • public static <T> void printArray(T[] array)
   • Prints all elements of any type array

3. Use bounded type parameters:
   • <T extends Number> - accepts Number or subclasses
   • Create method to sum numeric values

4. Demonstrate usage with String, Integer, Double types.

Key Concepts:
• Generics provide compile-time type safety
• <T> is a type parameter (placeholder)
• Bounded types restrict what types can be used
• Generic methods can have their own type parameters

Expected Output:

String Box: Hello Generics!
Integer Box: 42
Double Box: 3.14
Array: 1 2 3 4 5 
Array: A B C D 
Sum of numbers: 15.5

Requirements Checklist

Create generic class with <T>

Implement getValue() and setValue()

Create generic method with <T>

Use bounded type <T extends Number>

Instantiate Box with different types

Call generic methods with arrays

// TODO: Create a generic class Box<T>
// class Box<T> {
//     private T value;
//     
//     public Box(T value) {
//         this.value = value;
//     }
//     
//     public T getValue() {
//         return value;
//     }
//     
//     public void setValue(T value) {
//         this.value = value;
//     }
// }

public class GenericsDemo {
    
    // TODO: Create a generic method to print array elements
    // public static <T> void printArray(T[] array) {
    //     System.out.print("Array: ");
    //     for (T element : array) {
    //         System.out.print(element + " ");
    //     }
    //     System.out.println();
    // }
    
    // TODO: Create bounded generic method for numbers
    // public static <T extends Number> double sumNumbers(T[] numbers) {
    //     double sum = 0;
    //     for (T num : numbers) {
    //         sum += num.doubleValue();
    //     }
    //     return sum;
    // }
    
    public static void main(String[] args) {
        // TODO: Create Box instances with different types
        // Box<String> stringBox = new Box<>("Hello Generics!");
        // System.out.println("String Box: " + stringBox.getValue());
        
        // Box<Integer> intBox = new Box<>(42);
        // System.out.println("Integer Box: " + intBox.getValue());
        
        // Box<Double> doubleBox = new Box<>(3.14);
        // System.out.println("Double Box: " + doubleBox.getValue());
        
        // TODO: Use generic method with arrays
        // Integer[] intArray = {1, 2, 3, 4, 5};
        // printArray(intArray);
        
        // String[] strArray = {"A", "B", "C", "D"};
        // printArray(strArray);
        
        // TODO: Use bounded generic method
        // Double[] nums = {1.5, 2.0, 3.5, 4.0, 4.5};
        // System.out.println("Sum of numbers: " + sumNumbers(nums));
        
    }
}

Output

// Click "Run Code" to compile and execute

Hints & Tips

• Generic class: class Box<T> { T value; }

• Generic method: public static <T> void method(T param)

• Bounded: <T extends Number> limits to Number subclasses

• Instantiate: Box<String> box = new Box<>("text");

Progress: 0/6

Score: 0/100

0%

Lab Results

Review feedback below

Lab 17: Enums (Enumerated Types)

Intermediate

Coding Challenge

Your Task: Create and use enum types to represent fixed sets of constants with type safety and additional functionality.

Detailed Requirements:
1. Create a simple enum:
   enum Day { MONDAY, TUESDAY, WEDNESDAY, ... }

2. Create an enum with fields and constructor:
   enum Planet { MERCURY(3.303e+23, 2.4397e6), ... }
   • Add private fields (mass, radius)
   • Add constructor
   • Add getter methods
   • Add a method to calculate surface gravity

3. Use enum methods:
   • values() - returns array of all enum constants
   • valueOf("NAME") - converts string to enum
   • ordinal() - returns position (0-based)
   • name() - returns name as string

4. Use enum in switch statement.

Expected Output:

Today is: WEDNESDAY
Day number: 3
Is weekend? false
All days: MONDAY TUESDAY WEDNESDAY THURSDAY FRIDAY SATURDAY SUNDAY 
Planet: EARTH
Mass: 5.976E24 kg
Radius: 6.378E6 m
Surface Gravity: 9.80 m/s²

Requirements Checklist

Create simple enum with constants

Create enum with fields and constructor

Add getter methods to enum

Use values() to iterate all constants

Use ordinal() or name() method

Use enum in switch statement

// TODO: Create a simple Day enum
// enum Day {
//     MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
// }

// TODO: Create Planet enum with fields and methods
// enum Planet {
//     MERCURY(3.303e+23, 2.4397e6),
//     VENUS(4.869e+24, 6.0518e6),
//     EARTH(5.976e+24, 6.37814e6),
//     MARS(6.421e+23, 3.3972e6);
//     
//     private final double mass;   // in kg
//     private final double radius; // in meters
//     
//     Planet(double mass, double radius) {
//         this.mass = mass;
//         this.radius = radius;
//     }
//     
//     public double getMass() { return mass; }
//     public double getRadius() { return radius; }
//     
//     // Calculate surface gravity
//     public double surfaceGravity() {
//         final double G = 6.67300E-11;
//         return G * mass / (radius * radius);
//     }
// }

public class EnumDemo {
    
    // TODO: Method using switch with enum
    // public static boolean isWeekend(Day day) {
    //     switch (day) {
    //         case SATURDAY:
    //         case SUNDAY:
    //             return true;
    //         default:
    //             return false;
    //     }
    // }
    
    public static void main(String[] args) {
        // TODO: Use the Day enum
        // Day today = Day.WEDNESDAY;
        // System.out.println("Today is: " + today);
        // System.out.println("Day number: " + (today.ordinal() + 1));
        // System.out.println("Is weekend? " + isWeekend(today));
        
        // TODO: Iterate through all days
        // System.out.print("All days: ");
        // for (Day d : Day.values()) {
        //     System.out.print(d + " ");
        // }
        // System.out.println();
        
        // TODO: Use Planet enum
        // Planet earth = Planet.EARTH;
        // System.out.println("Planet: " + earth.name());
        // System.out.printf("Mass: %.3E kg%n", earth.getMass());
        // System.out.printf("Radius: %.3E m%n", earth.getRadius());
        // System.out.printf("Surface Gravity: %.2f m/s²%n", earth.surfaceGravity());
        
    }
}

Output

// Click "Run Code" to compile and execute

Hints & Tips

• Simple enum: enum Color { RED, GREEN, BLUE }

• Enum with data: enum Size { SMALL(1), MEDIUM(2); int val; Size(int v){val=v;} }

• Get all values: MyEnum.values()

• Position: myEnum.ordinal() (0-based index)

Progress: 0/6

Score: 0/100

0%

Lab Results

Review feedback below

Lab 18: Regular Expressions (Regex)

Expert

Coding Challenge

Your Task: Master regular expressions in Java for powerful pattern matching, validation, and text manipulation.

Detailed Requirements:
1. Import regex classes:
   import java.util.regex.*;

2. Use Pattern and Matcher:
   • Pattern pattern = Pattern.compile("regex");
   • Matcher matcher = pattern.matcher(input);
   • matcher.find() - find next match
   • matcher.matches() - match entire string
   • matcher.group() - get matched text

3. Common regex patterns:
   • Email: [a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}
   • Phone: \\d{3}-\\d{3}-\\d{4}
   • Digits: \\d+

4. String methods with regex:
   • str.matches(regex)
   • str.replaceAll(regex, replacement)
   • str.split(regex)

Expected Output:

Email Validation:
test@example.com: valid
invalid.email: invalid
user.name@domain.org: valid

Phone numbers found: 555-123-4567 555-987-6543 
Numbers extracted: 42 100 7 
Censored: Hello *****, how are you *****?

Requirements Checklist

Import java.util.regex.*

Create Pattern with compile()

Use Matcher with find() or matches()

Extract matches with group()

Use String.matches() for validation

Use replaceAll() with regex

// TODO: Import regex classes
// import java.util.regex.*;

public class RegexDemo {
    
    // TODO: Email validation method
    // public static boolean isValidEmail(String email) {
    //     String regex = "[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}";
    //     return email.matches(regex);
    // }
    
    public static void main(String[] args) {
        // TODO: Validate emails
        // System.out.println("Email Validation:");
        // String[] emails = {"test@example.com", "invalid.email", "user.name@domain.org"};
        // for (String email : emails) {
        //     System.out.println(email + ": " + (isValidEmail(email) ? "valid" : "invalid"));
        // }
        // System.out.println();
        
        // TODO: Find phone numbers using Pattern and Matcher
        // String text = "Call 555-123-4567 or 555-987-6543 for info";
        // Pattern phonePattern = Pattern.compile("\\d{3}-\\d{3}-\\d{4}");
        // Matcher matcher = phonePattern.matcher(text);
        // System.out.print("Phone numbers found: ");
        // while (matcher.find()) {
        //     System.out.print(matcher.group() + " ");
        // }
        // System.out.println();
        
        // TODO: Extract all numbers from text
        // String data = "There are 42 apples, 100 oranges, and 7 bananas";
        // Pattern numPattern = Pattern.compile("\\d+");
        // Matcher numMatcher = numPattern.matcher(data);
        // System.out.print("Numbers extracted: ");
        // while (numMatcher.find()) {
        //     System.out.print(numMatcher.group() + " ");
        // }
        // System.out.println();
        
        // TODO: Replace with regex
        // String message = "Hello World, how are you World?";
        // String censored = message.replaceAll("World", "*****");
        // System.out.println("Censored: " + censored);
        
    }
}

Output

// Click "Run Code" to compile and execute

Hints & Tips

• Pattern: Pattern p = Pattern.compile("\\\\d+");

• Matcher: Matcher m = p.matcher(text);

• Find all: while (m.find()) { m.group(); }

• Validate: str.matches("regex") - checks entire string

• Escape backslash: use \\\\d in Java strings for \\d

Progress: 0/6

Score: 0/100

0%

Lab Results

Review feedback below

Java Programming Labs

Generics, Enums & Regular Expressions - Module 6

Requirements Checklist

Lab Results

Requirements Checklist

Lab Results

Requirements Checklist

Lab Results