Miscellaneous Topics in Java

What are some best practices for using enums in Java?

How does Enum help?
- Fixed Set of Constants – Define all allowed values in one place
- Type Safe – Only valid enum values can be used
- Readable Code – Improves clarity over magic strings or numbers
- Prevents Errors – No typos or invalid assignments
- Switch Friendly – Works great in switch statements
JDK Examples
- java.time.DayOfWeek (enum representing the 7 days of the week)
- java.util.concurrent.TimeUnit (Represents time durations - NANOSECONDS, MICROSECONDS, MILLISECONDS, SECONDS, MINUTES, HOURS, DAYS)
- java.lang.Thread.State
```
public enum State {
    NEW,
    RUNNABLE,
    BLOCKED,
    WAITING,
    TIMED_WAITING,
    TERMINATED;
}
```

Simple Example:

enum Status {
    PENDING, APPROVED, REJECTED;
}

Status status = Status.APPROVED;

Using switch with Enums

enum Season {
    WINTER, SPRING, SUMMER, FALL
}

class Weather {
    public int getMaxTemperature(
                        Season season) {
        return switch (season) {
            case WINTER -> 5;
            case SPRING, FALL -> 15;
            case SUMMER -> 30;
        };
    }
}

Enum with Fields, Constructor, and Methods

enum Direction {
    NORTH("Up"), 
    SOUTH("Down"), 
    EAST("Right"), 
    WEST("Left");

    private final String movement;

    Direction(String movement) {
        this.movement = movement;
    }

    public String getMovement() {
        return movement;
    }
}

public class EnumExample {
    public static void main(String[] args) {
        System.out.println(
            Direction.NORTH.getMovement());
    }
}

Enum Best Practices
- Uppercase Names – Use all caps for enum constants (MONDAY, HIGH, STARTED)
- Add Fields & Methods – Enums can have constructors, fields, and behavior
- Avoid ordinal() for Logic – Enum order can change, leading to bugs
- Use switch or switch expressions – Clean and readable for branching logic
- Use Enums Instead of Strings – Prevents typos and invalid values
- Don’t Subclass Enums – Enums are implicitly final
- Override toString() if Needed – For user-friendly display values
- Use EnumSet / EnumMap – Optimized for enum keys

In what scenarios should you use an EnumSet?

What? – EnumSet is a specialized Set for enum types
Why? – Much faster than HashSet when working with enums
How? – Internally uses a bit vector for storage
Null Allowed? – ❌ No null values allowed
All Constants? – Use EnumSet.allOf(EnumType.class)
Empty Set? – Use EnumSet.noneOf(EnumType.class)
Range of Values? – Use EnumSet.range(A, C)

Example: Using EnumSet

import java.util.EnumSet;

enum Day {
    MONDAY, TUESDAY, WEDNESDAY, 
    THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

public class EnumSetExample {
    public static void main(String[] args) {
        
        // Use Case 1: Weekend Days
        EnumSet<Day> weekend = 
            EnumSet.of(Day.SATURDAY, Day.SUNDAY);
        System.out.println("Weekend: " + weekend);

        // Use Case 2: Working Days
        EnumSet<Day> weekdays = 
            EnumSet.range(Day.MONDAY, Day.FRIDAY);
        System.out.println("Weekdays: " + weekdays);

        // Use Case 3: All Days
        EnumSet<Day> allDays = 
            EnumSet.allOf(Day.class);
        System.out.println("All Days: " + allDays);

        // Use Case 4: Empty Set (will add later)
        EnumSet<Day> holidays = 
            EnumSet.noneOf(Day.class);
        holidays.add(Day.FRIDAY); // dynamically add
        System.out.println("Holidays: " + holidays);

        // Use Case 5: Removing from a set
        weekdays.remove(Day.WEDNESDAY);
        System.out.println(
            "Working Days (No Wednesday): " + weekdays);
    }
}

Best Practices for EnumSet
- Use EnumSet for Enums – Better than HashSet in speed and memory
- Faster Operations – add(), remove(), contains() are constant-time
- No Nulls Allowed – Inserting null throws NullPointerException
- Cleaner Code – Methods like of(), allOf(), range() make code more readable

What is the purpose of using assertions in Java?

What? – Assertions check conditions that must be true during development
How? – Use assert condition; or assert condition : "message";
Fails? – Throws AssertionError if the condition is false
When? – Only works if assertions are enabled (-ea flag)
Not for Production – Meant for testing, not for handling runtime errors

Example: Using assert

public void processFile(String fileNameTxt) {
    
    assert fileNameTxt.endsWith(".txt") 
            : "Invalid file type: " + fileNameTxt;
    
    //Other code to process the file!
}

Running with assertions enabled:
```
java -ea AssertionExample
```
Asserts - Best Practices
- Validate Assumptions – Use assertions to catch logic errors during development
- Pre/Post Conditions – Check method input/output expectations in private/internal code
- Never for User Input Validation – Don’t validate user input with assertions
- Never for Business Logic – Business rules must throw proper exceptions
- Don't Use for Security – Never rely on assertions for security-sensitive checks
- Add Messages – Use assert condition : "Helpful message" for clarity

When should you use variable arguments (varargs) in a method?

What? – Varargs (...) let a method take zero or more arguments
Syntax? – Use type... name as the last parameter in the method
Internally? – Treated as an array inside the method
Why? – Makes method calls flexible without overloading
JDK Examples?
- String.format(String format, Object... args)
- Collections.addAll(Collection<? super T> c, T... elements)
- List.of(E... elements)

Example: Using Varargs

public class VarargsExample {        
    public static int sum(int... numbers) {
        return Arrays.stream(numbers).sum();
    }

    public static void main(String[] args) {
        System.out.println(sum(1, 2, 3));
        System.out.println(sum(5, 10, 15, 20));
        System.out.println(sum());
    }
}

Best Practices for Varargs
- Use When Necessary – Avoid overusing varargs; prefer specific parameters if possible
- Only One Vararg – A method can’t have more than one varargs parameter
- Always Last – Varargs must be the last parameter in the method signature
- Avoid Ambiguity – Overloaded methods with varargs can confuse the compiler
- Handle Nulls Safely – Varargs can be null; check before using
- Combine with Streams – Use functional style (Arrays.stream(...)) for clean code

What are the best practices for working with date and time APIs in Java?

Evolution of Date and Time APIs

API	Introduced In	Issues	Recommended?
`java.util.Date`	Java 1.0	Mutable, time zone issues, bad API design	❌ No
`java.util.Calendar`	Java 1.1	Complex, still mutable, verbose	❌ No
`java.time` (`LocalDate`, `LocalTime`, `ZonedDateTime`)	Java 8	Immutable, easy to use, thread-safe	✅ Yes

Example: java.util.Date (Not Recommended)

import java.util.Date;

public class DateExample {
    public static void main(String[] args) {
        Date date = new Date();
        
        // Output: Mon Mar 04 12:30:45 IST 2024
        System.out.println("Current Date: " + date);  
    }
}

Example: Calendar (Better, but still not ideal)

import java.util.Calendar;

public class CalendarExample {
    public static void main(String[] args) {
        Calendar calendar = Calendar.getInstance();
        calendar.set(2024, Calendar.MARCH, 4);
        System.out.println("Date: " + calendar.getTime());  
    }
}

Best Practice: Use java.time API (Java 8+)

import java.time.*;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;

public class JavaTimeExample {
    public static void main(String[] args) {

        // 1️⃣ LocalDate – Immutable, thread-safe (unlike Date)
        LocalDate today = LocalDate.now();
        System.out.println("Today's Date: " + today);

        // 2️⃣ LocalDateTime + Formatting (no SimpleDateFormat)
        LocalDateTime dateTime = LocalDateTime.now();
        DateTimeFormatter formatter = 
            DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        System.out.println("Formatted: " + 
            dateTime.format(formatter));

        // 3️⃣ Specific Date – Easier than Calendar
        // No month-0 confusion (Jan = 1, not 0)
        LocalDate independenceDay = 
            LocalDate.of(1947, 8, 15);
        System.out.println("Independence Day: " + 
            independenceDay);

        // 4️⃣ Add Days/Months – Fluent API, clear syntax
        LocalDate nextMonth = today.plusMonths(1);
        System.out.println("Next Month: " + nextMonth);

        LocalDate tenDaysLater = today.plusDays(10);
        System.out.println("10 Days Later: " + 
            tenDaysLater);

        // 5️⃣ Subtract Time – No confusing Calendar math
        LocalDate lastYear = today.minusYears(1);
        System.out.println("Last Year: " + lastYear);

        // 6️⃣ Change Fields
        LocalDate changedYear = today.withYear(2020);
        System.out.println("Changed Year: " + 
            changedYear);

        LocalDate firstDay = today.withDayOfMonth(1);
        System.out.println("First Day: " + firstDay);

        // 7️⃣ Compare Dates – Easier than Date.before/after
        boolean isBefore = independenceDay.isBefore(today);
        System.out.println("Is Before Today? " + isBefore);

        boolean isAfter = today.isAfter(independenceDay);
        System.out.println("Is After Independence? " + 
            isAfter);

        // 8️⃣ Days Between – Use ChronoUnit directly
        long days = ChronoUnit.DAYS.between(
                        independenceDay, today);
        System.out.println("Days Since 1947: " + days);
    }
}

Advantages of java.time API:

Immutable and thread-safe.
Clear and concise API.
Better formatting support (DateTimeFormatter).

Best Practices for Date and Time Handling

Prefer java.time over Date and Calendar.
Use DateTimeFormatter for proper formatting instead of SimpleDateFormat.

What is the Use of Reflection?

What? – Reflection lets you inspect and interact with code at runtime
- Used For? – Dynamic loading, calling methods, accessing fields, working with annotations
- Common Uses
  - Dependency injection
  - Test frameworks
  - Annotation processing
JDK API Classes – Class, Method, Field, Constructor (from java.lang.reflect)

Example: Getting Class Information Using Reflection

import java.lang.reflect.Method;

public class ReflectionExample {
    public static void main(String[] args) {
        Class<String> clazz = String.class;

        // 1️⃣ Print declared methods of String class
        for (Method method : 
                clazz.getDeclaredMethods()) {
            System.out.println(
                "Method: " + method.getName());
        }
    }
}

Example: Creating Objects Using Reflection

import java.lang.reflect.Constructor;

class Example {
    public void display() {
        System.out.println("Reflection Example");
    }
}

public class ReflectionConstructorExample {
    public static void main(String[] args) 
                                throws Exception {
        
        Class<Example> clazz = Example.class;

        // Create instance dynamically
        Constructor<Example> constructor 
                = clazz.getDeclaredConstructor();
        
        Example obj = constructor.newInstance();
        
        obj.display();  // Output: Reflection Example
    }
}

Best Practices with Reflection:
- Use When Needed – Prefer reflection only for special use cases (frameworks, testing)
- Avoid in Hot Paths – Reflection is slower than direct access — not for performance-critical code
- Handle Exceptions Properly – Catch and log ClassNotFoundException, NoSuchMethodException, etc.
- Respect Security – Accessing private fields/methods may break encapsulation — use with caution
- Document Usage – Clearly explain why reflection is used in code comments
- Avoid Reflection for Business Logic – Keep it in utilities or framework-level code only
- Test Thoroughly – Reflective code is harder to debug — write strong tests to verify behavior

Why are annotations used in Java?

What? – Annotations are special markers that add metadata to code
JDK Examples:
- @Override – Tells the compiler you're overriding a super-class method or implementing an interface method.
  - Catches typos or mismatches early.
- @Deprecated – Marks a method or class as outdated.
  - Warns developers to avoid using it.
- @FunctionalInterface – Ensures the interface has only one abstract method.
  - Required for lambda expressions.
  - Fails at compile-time if multiple abstract methods exist in an interface.
Marker Annotations: Annotations without parameters
Framework Usage? – Widely used in Java, Spring, JUnit, Jakarta EE

Examples of Using Annotations

class Parent {
    void show() {
        System.out.println("Parent class method");
    }
}

class Child extends Parent {
    @Override
    void show() {
        System.out.println("Child class method");
    }

    @Deprecated
    void oldMethod() {
        System.out.println("This method is deprecated");
    }

    @SuppressWarnings("unchecked")
    void warningFree() {
        // No warning due to SuppressWarnings
        List rawList = new ArrayList(); 
    }
}

@FunctionalInterface
interface Greeter {
    void greet(String name);

    // ❌ Uncommenting the below method 
    // would cause a compile error
    
    // void sayBye(); 
}

How do you define and use a custom annotation in Java?

What? – Custom annotations are user-defined markers that add metadata to code
@Retention – Controls how long the annotation is retained
- SOURCE – Discarded by compiler, used only in code (e.g., @Generated for code gen tools)
- CLASS – Kept in bytecode, ignored at runtime (e.g., @Deprecated)
- RUNTIME – Available at runtime via reflection (e.g., @Override, custom annotations)
@Target – Controls where the annotation can be applied
- METHOD – Used on methods
- FIELD – Used on fields or variables
- TYPE – Used on classes, interfaces, enums
- PARAMETER – Used on method parameters
- CONSTRUCTOR, etc. – More specialized use cases

Creating a Custom Annotation:

import java.lang.annotation.*;

// Define the custom annotation
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@interface TestAnnotation {
    String value();  // Annotation element
}

Applying the Custom Annotation

class Example {
    @TestAnnotation("This is a test method")
    public void myMethod() {
        System.out.println("Method executed");
    }
}

Using Reflection to Process the Annotation

import java.lang.reflect.Method;

public class AnnotationProcessor {
    public static void main(String[] args) 
                            throws Exception {
        
        Example example = new Example();
        
        // Get the method
        Method method 
                = Example.class.getMethod("myMethod");

        // Check if annotation is present
        if (method.isAnnotationPresent(
                    TestAnnotation.class)) {

            // Retrieve the annotation
            TestAnnotation annotation 
                = method.getAnnotation(TestAnnotation.class);

            System.out.println(
                "Annotation Value: " + annotation.value());

            // Execute the method dynamically
            method.invoke(example);
        }
    }
}

Creating a Simple Unit Test Framework with Annotations

The @Test annotation is applied to test methods.
TestRunner automatically finds and runs methods marked with @Test.

The test description is displayed before executing each test.

import java.lang.annotation.*;
import java.lang.reflect.Method;

// Define a test annotation
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@interface Test {
    String description() default "No description";
}

// Example test class
class TestSuite {
    @Test(description = "Test for addition")
    public void testAddition() {
        System.out.println("Addition Test Passed!");
    }

    @Test(description = "Test for subtraction")
    public void testSubtraction() {
        System.out.println("Subtraction Test Passed!");
    }
}

// Annotation Processor
//Runs all methods with @Test annotation
public class TestRunner {
    public static void main(String[] args) 
                                throws Exception {
        
        TestSuite testSuite = new TestSuite();

        for (Method method : 
            TestSuite.class.getDeclaredMethods()) {

            if (method.isAnnotationPresent(Test.class)) {
                
                Test test 
                    = method.getAnnotation(Test.class);
                
                System.out.println(
                            "Running Test: " + 
                                test.description());

                // Execute the test method
                method.invoke(testSuite);
            }

        }
    }
}

Example Output

Running Test: Test for addition
Addition Test Passed!
Running Test: Test for subtraction
Subtraction Test Passed!

What are unnamed variables and patterns, and why are they useful?

Unnamed variables (_) and unnamed patterns (catch (NumberFormatException _)) help reduce clutter when a variable or exception is declared but not used.

Example 1: Using Unnamed Variable in Try-Catch

try {
    // Invalid integer
    int n = Integer.parseInt("abc"); 
} catch (NumberFormatException _) {  // No name needed
//} catch (NumberFormatException ex) { // 'ex' is unused
    System.err.println("Invalid number format!");
}

Example 2: Unnamed Pattern in Switch Expressions

static void checkObject(Object obj) {
    switch (obj) {
        case String _ 
            -> System.out.println("It's a string.");
        case Integer _ 
            -> System.out.println("It's an integer.");
        default 
            -> System.out.println("Unknown type.");
    }
}

Example 3: Unnamed Variable in For-Each Loops

String[] names = {"Alice", "Bob", "Charlie"};

//Since we don’t need to use the variable, `_` replaces it.
for (String _ : names) {
    System.out.println("Processing...");
}

Example 4: Unnamed Variable in Record Patterns

record Person(String name, int age) {}

static void printPerson(Object obj) {
    //Here, `name` is ignored, as we only need `age`.
    if (obj instanceof Person(_, int age)) {
        System.out.println("Person's age: " + age);
    }
}

Example 5: Ignoring Unused Return Values

static int calculate(int a, int b) {
    return a + b;
}

public static void main(String[] args) {
    _ = calculate(10, 20); // We ignore the return value
    System.out.println("Calculation done.");
}

Advantages

Cleaner Code – Removes unnecessary variable names when they are not used.
Improved Readability – Makes the intent clearer by avoiding unused variables.
Less Clutter – No warnings for unused variables, reducing distractions in IDEs.

How has pattern matching evolved across recent Java versions?

Before Java 14 Example

Requires explicit casting ((String) obj).

Redundant code for type checking.

public void process(Object obj) {
    if (obj instanceof String) {
        // Explicit casting needed
        String s = (String) obj;  
        System.out.println("Message: " + s);
    }
}

Java 14: Simplified instanceof Check

Eliminates explicit casting.
Declares variable inline.

Cleaner and safer.

public void process(Object obj) {
    if (obj instanceof String s) {
        // No explicit cast needed
        System.out.println("Message: " + s);  
    }
}

Java 21: Record Patterns

Java 21 allows automatic deconstruction of records.

Automatically extracts fields (sender, receiver, amount).

record Transaction(
    String sender, String receiver
    , double amount) {}

public void processTransaction(Object obj) {
    if (obj instanceof Transaction(
            String sender, String receiver,
                             double amount)) {
        System.out.println("Processing transaction: " 
            + sender + " -> " 
            + receiver + " : ₹" + amount);
    }
}

Java 21: Nested Record Patterns

Nested pattern matching extracts values directly.
Eliminates manual field access (order.customer().name()).

More concise and readable.

package com.in28minutes;

record Customer(String name, String email) {}

record Product(String name, double price) {}

record Order(Customer customer, Product product) {}


public class CustomerSupport {
    public static void processOrder(Object obj) {
        if (obj instanceof Order(
            Customer(String name, String email), 
            Product(String prodName, double price))) {

            System.out.println("Customer " + name + 
                        " ordered " + prodName + 
                        " for ₹" + price);

        }
    }

    public static void main(String[] args) {
        processOrder(new Order(
                        new Customer("Ranga","Email"), 
                        new Product("Cricket Bat",100)));
    }
}

How have switch expressions improved in modern Java?

Java 14: Arrow Syntax (->) in switch

No need for break statements.
More concise and readable.

Uses -> instead of case : syntax.

switch (day) {
    case "Monday" -> System.out.println("Start of the week");
    case "Friday" -> System.out.println("Weekend is near");
    case "Sunday" -> System.out.println("Weekend");
    default -> System.out.println("Regular day");
}

Java 14: Switch Expression with Return Values

switch as an expression (returns a value).

public class CustomerSupportSwitchExpression {
    public static void main(String[] args) {
        Object message = "Need help with my order";

        String response = switch (message) {
            
            case String text -> 
                "Processing text message: " 
                                    + text;
            
            case Integer ticketNumber -> 
                "Processing support ticket: #" 
                                    + ticketNumber;
            
            case Double rating -> 
                "Processing feedback rating: " 
                                    + rating + " stars";
            
            case byte[] attachment -> 
                "Processing attachment of size: " 
                                    + attachment.length;
            
            default -> "Unknown message type.";
        
        };

        System.out.println(response);
    }
}

Java 17: Switch Expression with Enums

Eliminates repetitive if-else logic.

enum Priority {
    LOW, MEDIUM, HIGH, CRITICAL
}

public class CustomerSupportJava17 {
    public static void main(String[] args) {
        
        // Example: High-priority ticket
        Priority priority = Priority.HIGH; 

        String response = switch (priority) {
            case LOW 
                -> "Response within 48 hours.";
            case MEDIUM 
                -> "Response within 24 hours.";
            case HIGH 
                -> "Immediate response required!";
            case CRITICAL 
                -> "Escalating to the highest level!";
        };

        System.out.println(response);
    }
}

Java 21: Switch Expression with Record Patterns

Pattern Matching in switch allows direct record deconstruction.

More concise and readable code.

sealed interface CustomerMessage 
    permits TextMessage, Ticket, Feedback, Attachment {}

record TextMessage(String text) implements CustomerMessage {}
record Ticket(int ticketNumber) implements CustomerMessage {}
record Feedback(double rating) implements CustomerMessage {}
record Attachment(byte[] file) implements CustomerMessage {}

public class CustomerSupportJava21 {
    public static void main(String[] args) {
        CustomerMessage message = new Ticket(1050);

        String response = switch (message) {
            case TextMessage(String text) 
                    -> "Processing text message: " 
                                        + text;
            case Ticket(int ticketNumber) 
                    -> "Processing support ticket: #" 
                                        + ticketNumber;
            case Feedback(double rating) 
                    -> "Processing feedback rating: " 
                                        + rating + " stars";
            case Attachment(byte[] file) 
                -> "Processing attachment of size: " 
                                        + file.length;
        };

        System.out.println(response);
    }
}

Java 21: Nested Record Patterns in Switch Expressions

Switch expressions work seamlessly with nested records.

Automatic deconstruction of records inside switch.

package com.in28minutes;

sealed interface CustomerMessage 
    permits TextMessage, Ticket, 
            Feedback, Attachment {}

record TextMessage(String text) 
        implements CustomerMessage {}

record Ticket(int ticketNumber) 
        implements CustomerMessage {}

record Feedback(double rating) 
        implements CustomerMessage {}

record Attachment(byte[] file) 
        implements CustomerMessage {}

record SupportRequest(String user, 
                        CustomerMessage message) {}

public class CustomerSupport {
    public static void main(String[] args) {
        SupportRequest request 
            = new SupportRequest("Alice", 
                            new Feedback(4.8));

        String response = switch (request) {
            
            case SupportRequest(String user, 
                    Ticket(int ticketNumber)) -> 
                "User " + user + 
                " has a support ticket: #" + ticketNumber;
            
            case SupportRequest(String user, 
                    Feedback(double rating)) -> 
                "User " + user + 
                " left a rating: " + rating + " stars";
            
            case SupportRequest(String user, 
                    TextMessage(String text)) -> 
                "User " + user + 
                " sent a message: " + text;
            
            case SupportRequest(String user, 
                    Attachment(byte[] file)) -> 
                "User " + user + 
                " uploaded a file of size: " + file.length;
        };

        System.out.println(response);
    }
}

📌 Java 22: when Guards in Switch Expressions

What? Add extra conditions inside switch cases
Why? Filter patterns without nesting if statements
Benefit? Cleaner and more powerful control flow

Example: Using when for Additional Filtering

record Feedback(double rating) implements CustomerMessage {}

public class SupportWithWhen {
    public static void main(String[] args) {
        CustomerMessage message = new Feedback(2.5);

        String response = switch (message) {
            case Feedback(double rating) when rating < 3.0 ->
                "We're sorry to hear that. Support will contact you.";
            case Feedback(double rating) ->
                "Thanks for your positive feedback!";
            default ->
                "Unhandled message type.";
        };

        System.out.println(response);
    }
}

On this page

# What are some best practices for using enums in Java?

# In what scenarios should you use an EnumSet?

# What is the purpose of using assertions in Java?

# When should you use variable arguments (varargs) in a method?

# What are the best practices for working with date and time APIs in Java?

# What is the Use of Reflection?

# Why are annotations used in Java?

# How do you define and use a custom annotation in Java?

# What are unnamed variables and patterns, and why are they useful?

# How has pattern matching evolved across recent Java versions?

# How have switch expressions improved in modern Java?