Java 23 introduces implicitly declared classes as a preview feature (JEP 477), simplifying Java programming for beginners and small programs. This feature allows writing Java code without explicit class declarations.

Understanding Implicitly Declared Classes

Step 1: Basic Concepts and Syntax

// Simple Java program without explicit class declaration // This file: HelloWorld.java void main() { System.out.println("Hello, World!"); } // You can compile and run this directly: // javac HelloWorld.java // java HelloWorld // Traditional equivalent: // public class HelloWorld { // public static void main(String[] args) { // System.out.println("Hello, World!"); // } // }

Step 2: Core Features and Restrictions

// ImplicitClassDemo.java // 1. Entry point - void main() is automatically the entry point void main() { System.out.println("Program started!"); // Call other methods greetUser("Alice"); calculateSum(10, 20); // Use fields counter = 5; incrementCounter(); System.out.println("Counter: " + counter); } // 2. Fields are automatically instance fields of the implicit class int counter = 0; String programName = "Implicit Class Demo"; // 3. Methods are automatically instance methods void greetUser(String name) { System.out.println("Hello, " + name + "! Welcome to " + programName); } void calculateSum(int a, int b) { int result = a + b; System.out.println(a + " + " + b + " = " + result); } void incrementCounter() { counter++; System.out.println("Counter incremented to: " + counter); } // 4. You can have static fields and methods static final String VERSION = "1.0"; static void printVersion() { System.out.println("Program Version: " + VERSION); } // Restrictions: // - No explicit class declaration // - No package declaration (goes to unnamed package) // - No imports (use fully qualified names or rely on automatic imports) // - Only one implicit class per source file

Practical Examples and Use Cases

Step 3: Real-World Examples

// Calculator.java - Simple calculator application void main() { System.out.println("Simple Calculator"); System.out.println("================="); double result = calculate("add", 15.5, 7.2); System.out.println("15.5 + 7.2 = " + result); result = calculate("multiply", 8, 4); System.out.println("8 × 4 = " + result); // Interactive mode interactiveCalculator(); } // Calculator operations double calculate(String operation, double a, double b) { return switch (operation.toLowerCase()) { case "add", "+" -> a + b; case "subtract", "-" -> a - b; case "multiply", "*", "×" -> a * b; case "divide", "/", "÷" -> { if (b == 0) throw new ArithmeticException("Division by zero"); yield a / b; } default -> throw new IllegalArgumentException("Unknown operation: " + operation); }; } // Interactive calculator mode void interactiveCalculator() { java.util.Scanner scanner = new java.util.Scanner(System.in); System.out.println("\nInteractive Mode (type 'quit' to exit)"); while (true) { System.out.print("Enter operation (+, -, *, /): "); String op = scanner.nextLine(); if ("quit".equalsIgnoreCase(op)) break; System.out.print("Enter first number: "); double num1 = scanner.nextDouble(); System.out.print("Enter second number: "); double num2 = scanner.nextDouble(); scanner.nextLine(); // consume newline try { double result = calculate(op, num1, num2); System.out.println("Result: " + result); } catch (Exception e) { System.out.println("Error: " + e.getMessage()); } } scanner.close(); System.out.println("Calculator closed."); }

Step 4: File Processing Example

// FileProcessor.java - File manipulation utility void main() { if (java.lang.System.getProperty("file.name") != null) { String fileName = java.lang.System.getProperty("file.name"); processFile(fileName); } else { System.out.println("Usage: java -Dfile.name=filename.txt FileProcessor"); System.out.println("Available commands: read, count, stats"); } } void processFile(String fileName) { try { String command = java.lang.System.getProperty("command", "read"); switch (command) { case "read" -> readFile(fileName); case "count" -> countFileStats(fileName); case "stats" -> showFileStats(fileName); default -> System.out.println("Unknown command: " + command); } } catch (Exception e) { System.err.println("Error processing file: " + e.getMessage()); } } void readFile(String fileName) throws java.io.IOException { System.out.println("Reading file: " + fileName); System.out.println("=" .repeat(50)); java.nio.file.Path path = java.nio.file.Paths.get(fileName); java.util.List<String> lines = java.nio.file.Files.readAllLines(path); for (int i = 0; i < lines.size(); i++) { System.out.printf("%3d: %s%n", i + 1, lines.get(i)); } } void countFileStats(String fileName) throws java.io.IOException { java.nio.file.Path path = java.nio.file.Paths.get(fileName); String content = java.nio.file.Files.readString(path); int charCount = content.length(); int lineCount = content.split("\r\n|\r|\n").length; int wordCount = content.trim().isEmpty() ? 0 : content.split("\\s+").length; System.out.println("File Statistics for: " + fileName); System.out.println("Characters: " + charCount); System.out.println("Lines: " + lineCount); System.out.println("Words: " + wordCount); } void showFileStats(String fileName) throws java.io.IOException { java.nio.file.Path path = java.nio.file.Paths.get(fileName); java.nio.file.attribute.BasicFileAttributes attrs = java.nio.file.Files.readAttributes(path, java.nio.file.attribute.BasicFileAttributes.class); System.out.println("Detailed File Statistics:"); System.out.println("Name: " + path.getFileName()); System.out.println("Size: " + attrs.size() + " bytes"); System.out.println("Created: " + attrs.creationTime()); System.out.println("Modified: " + attrs.lastModifiedTime()); System.out.println("Is Directory: " + attrs.isDirectory()); System.out.println("Is Regular File: " + attrs.isRegularFile()); }

Advanced Implicit Class Features

Step 5: Working with Collections and Streams

// CollectionDemo.java - Demonstrates collections in implicit classes void main() { demonstrateLists(); demonstrateMaps(); demonstrateStreams(); } void demonstrateLists() { System.out.println("=== List Operations ==="); // Create and populate a list var names = java.util.List.of("Alice", "Bob", "Charlie", "Diana", "Eve"); // Traditional iteration System.out.println("All names:"); for (String name : names) { System.out.println(" - " + name); } // Filter and transform System.out.println("\nNames starting with A or E:"); names.stream() .filter(name -> name.startsWith("A") || name.startsWith("E")) .map(String::toUpperCase) .forEach(System.out::println); } void demonstrateMaps() { System.out.println("\n=== Map Operations ==="); var ageMap = new java.util.HashMap<String, Integer>(); ageMap.put("Alice", 25); ageMap.put("Bob", 30); ageMap.put("Charlie", 35); ageMap.put("Diana", 28); System.out.println("Age Map:"); ageMap.forEach((name, age) -> System.out.printf(" %s: %d years old%n", name, age)); // Find average age double averageAge = ageMap.values().stream() .mapToInt(Integer::intValue) .average() .orElse(0.0); System.out.printf("Average age: %.1f years%n", averageAge); } void demonstrateStreams() { System.out.println("\n=== Stream Operations ==="); var numbers = java.util.List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); // Various stream operations System.out.println("Original numbers: " + numbers); // Filter even numbers and square them var evenSquares = numbers.stream() .filter(n -> n % 2 == 0) .map(n -> n * n) .toList(); System.out.println("Even numbers squared: " + evenSquares); // Sum of all numbers int sum = numbers.stream() .mapToInt(Integer::intValue) .sum(); System.out.println("Sum of all numbers: " + sum); // Group by even/odd var grouped = numbers.stream() .collect(java.util.stream.Collectors.groupingBy( n -> n % 2 == 0 ? "Even" : "Odd")); System.out.println("Grouped numbers: " + grouped); }

Step 6: Error Handling and Validation

// ValidationDemo.java - Error handling in implicit classes void main() { try { validateUserInput(); processDataSafely(); demonstrateCustomException(); } catch (Exception e) { System.err.println("Program failed: " + e.getMessage()); e.printStackTrace(); } } void validateUserInput() { System.out.println("=== Input Validation ==="); java.util.Scanner scanner = new java.util.Scanner(System.in); try { System.out.print("Enter your age: "); String input = scanner.nextLine(); int age = validateAge(input); System.out.println("Valid age: " + age); } catch (InvalidInputException e) { System.err.println("Validation error: " + e.getMessage()); } finally { System.out.println("Validation completed."); } } int validateAge(String input) throws InvalidInputException { if (input == null || input.trim().isEmpty()) { throw new InvalidInputException("Age cannot be empty"); } try { int age = Integer.parseInt(input.trim()); if (age < 0 || age > 150) { throw new InvalidInputException("Age must be between 0 and 150"); } return age; } catch (NumberFormatException e) { throw new InvalidInputException("Age must be a valid number"); } } void processDataSafely() { System.out.println("\n=== Safe Data Processing ==="); var data = java.util.List.of("10", "20", "thirty", "40", "-5"); data.forEach(item -> { try { int value = Integer.parseInt(item); if (value > 0) { System.out.println("Valid positive number: " + value); } else { System.out.println("Invalid (non-positive): " + value); } } catch (NumberFormatException e) { System.out.println("Invalid format: '" + item + "'"); } }); } void demonstrateCustomException() throws CustomBusinessException { System.out.println("\n=== Custom Exceptions ==="); // Simulate a business rule violation double balance = 100.0; double withdrawal = 150.0; if (withdrawal > balance) { throw new CustomBusinessException( "Insufficient funds. Balance: " + balance + ", Attempted withdrawal: " + withdrawal); } System.out.println("Withdrawal successful"); } // Custom exception classes (nested in the implicit class) class InvalidInputException extends Exception { public InvalidInputException(String message) { super(message); } } class CustomBusinessException extends Exception { public CustomBusinessException(String message) { super(message); } }

Integration with Java Features

Step 7: Using Records and Pattern Matching

// RecordsDemo.java - Modern Java features with implicit classes void main() { demonstrateRecords(); demonstratePatternMatching(); demonstrateSealedTypes(); } void demonstrateRecords() { System.out.println("=== Records ==="); // Define and use records Person alice = new Person("Alice", 30, "[email protected]"); Person bob = new Person("Bob", 25, "[email protected]"); System.out.println(alice); System.out.println(bob); System.out.println("Are they equal? " + alice.equals(bob)); // Process list of people var people = java.util.List.of( alice, bob, new Person("Charlie", 35, "[email protected]") ); System.out.println("\nAll people:"); people.forEach(System.out::println); // Filter and process System.out.println("\nPeople over 28:"); people.stream() .filter(p -> p.age() > 28) .map(Person::name) .forEach(System.out::println); } void demonstratePatternMatching() { System.out.println("\n=== Pattern Matching ==="); var shapes = java.util.List.of( new Circle(5.0), new Rectangle(4.0, 6.0), new Circle(3.0), new Rectangle(2.0, 8.0) ); // Pattern matching with switch expressions shapes.forEach(shape -> { double area = calculateArea(shape); System.out.printf("Area of %s: %.2f%n", shape.getClass().getSimpleName(), area); }); // More complex pattern matching System.out.println("\nShape analysis:"); shapes.forEach(shape -> { String analysis = analyzeShape(shape); System.out.println(analysis); }); } void demonstrateSealedTypes() { System.out.println("\n=== Sealed Types ==="); var expressions = java.util.List.of( new Constant(42), new Add(new Constant(10), new Constant(32)), new Multiply(new Constant(3), new Constant(14)) ); expressions.forEach(expr -> { int result = evaluateExpression(expr); System.out.printf("%s = %d%n", expr, result); }); } // Record definitions record Person(String name, int age, String email) { // Compact constructor for validation public Person { if (age < 0) throw new IllegalArgumentException("Age cannot be negative"); if (email == null || !email.contains("@")) { throw new IllegalArgumentException("Invalid email"); } } } // Shape hierarchy for pattern matching sealed interface Shape permits Circle, Rectangle { double area(); } record Circle(double radius) implements Shape { public double area() { return Math.PI * radius * radius; } } record Rectangle(double width, double height) implements Shape { public double area() { return width * height; } } // Sealed types for expressions sealed interface Expression permits Constant, Add, Multiply { int evaluate(); } record Constant(int value) implements Expression { public int evaluate() { return value; } public String toString() { return String.valueOf(value); } } record Add(Expression left, Expression right) implements Expression { public int evaluate() { return left.evaluate() + right.evaluate(); } public String toString() { return "(" + left + " + " + right + ")"; } } record Multiply(Expression left, Expression right) implements Expression { public int evaluate() { return left.evaluate() * right.evaluate(); } public String toString() { return "(" + left + " × " + right + ")"; } } // Helper methods using pattern matching double calculateArea(Shape shape) { return switch (shape) { case Circle c -> Math.PI * c.radius() * c.radius(); case Rectangle r -> r.width() * r.height(); }; } String analyzeShape(Shape shape) { return switch (shape) { case Circle c when c.radius() > 4 -> "Large circle with radius " + c.radius(); case Circle c -> "Small circle with radius " + c.radius(); case Rectangle r when r.width() == r.height() -> "Square with side " + r.width(); case Rectangle r -> "Rectangle " + r.width() + "×" + r.height(); }; } int evaluateExpression(Expression expr) { return switch (expr) { case Constant c -> c.value(); case Add a -> evaluateExpression(a.left()) + evaluateExpression(a.right()); case Multiply m -> evaluateExpression(m.left()) * evaluateExpression(m.right()); }; }

Building Practical Applications

Step 8: Complete Mini-Applications

// TodoManager.java - Simple todo list manager void main() { System.out.println("Todo List Manager"); System.out.println("================="); var todoManager = new TodoManager(); // Add some initial tasks todoManager.addTask("Learn Java 23 implicit classes"); todoManager.addTask("Write sample programs"); todoManager.addTask("Test the new features"); // Interactive loop runInteractiveMode(todoManager); } void runInteractiveMode(TodoManager manager) { var scanner = new java.util.Scanner(System.in); boolean running = true; while (running) { printMenu(); System.out.print("Choose an option: "); String choice = scanner.nextLine().trim(); switch (choice) { case "1" -> { System.out.print("Enter task description: "); String task = scanner.nextLine(); manager.addTask(task); System.out.println("Task added!"); } case "2" -> { System.out.print("Enter task number to mark complete: "); try { int taskNum = Integer.parseInt(scanner.nextLine()); manager.completeTask(taskNum); System.out.println("Task marked complete!"); } catch (Exception e) { System.out.println("Error: " + e.getMessage()); } } case "3" -> { System.out.print("Enter task number to remove: "); try { int taskNum = Integer.parseInt(scanner.nextLine()); manager.removeTask(taskNum); System.out.println("Task removed!"); } catch (Exception e) { System.out.println("Error: " + e.getMessage()); } } case "4" -> manager.displayTasks(); case "5" -> { System.out.println("Goodbye!"); running = false; } default -> System.out.println("Invalid option!"); } System.out.println(); } scanner.close(); } void printMenu() { System.out.println(""" Menu: 1. Add Task 2. Complete Task 3. Remove Task 4. Show Tasks 5. Exit """); } // TodoManager class within the implicit class class TodoManager { private final java.util.List<TodoTask> tasks = new java.util.ArrayList<>(); private int nextId = 1; void addTask(String description) { var task = new TodoTask(nextId++, description, false); tasks.add(task); } void completeTask(int taskId) { var task = findTask(taskId); task = task.withCompleted(true); updateTask(task); } void removeTask(int taskId) { tasks.removeIf(task -> task.id() == taskId); } void displayTasks() { if (tasks.isEmpty()) { System.out.println("No tasks found."); return; } System.out.println("Your Tasks:"); System.out.println("-----------"); tasks.forEach(task -> { String status = task.completed() ? "✓" : " "; System.out.printf("[%s] %d. %s%n", status, task.id(), task.description()); }); } private TodoTask findTask(int taskId) { return tasks.stream() .filter(task -> task.id() == taskId) .findFirst() .orElseThrow(() -> new IllegalArgumentException("Task not found: " + taskId)); } private void updateTask(TodoTask updatedTask) { for (int i = 0; i < tasks.size(); i++) { if (tasks.get(i).id() == updatedTask.id()) { tasks.set(i, updatedTask); return; } } } } record TodoTask(int id, String description, boolean completed) { public TodoTask { if (description == null || description.trim().isEmpty()) { throw new IllegalArgumentException("Description cannot be empty"); } } public TodoTask withCompleted(boolean completed) { return new TodoTask(this.id, this.description, completed); } }

Migration and Best Practices

Step 9: Migration Guidelines and Patterns

// MigrationGuide.java - Demonstrates migration from traditional to implicit classes void main() { demonstrateMigrationExamples(); showBestPractices(); discussLimitations(); } void demonstrateMigrationExamples() { System.out.println("=== Migration Examples ==="); // Example 1: Simple main method migration System.out.println("1. Simple main() migration:"); System.out.println(" BEFORE: public class HelloWorld { public static void main(...) {} }"); System.out.println(" AFTER: void main() { ... }"); // Example 2: Field and method migration System.out.println("\n2. Field and method migration:"); System.out.println(" Instance fields and methods become directly accessible"); } void showBestPractices() { System.out.println("\n=== Best Practices ==="); var practices = java.util.List.of( "1. Use for small programs and scripts", "2. Perfect for learning Java basics", "3. Great for quick prototypes and utilities", "4. Use meaningful method names", "5. Keep methods focused and small", "6. Use local variables appropriately", "7. Handle exceptions properly", "8. Document complex logic with comments" ); practices.forEach(System.out::println); } void discussLimitations() { System.out.println("\n=== Limitations ==="); var limitations = java.util.List.of( "1. No package declaration (unnamed package only)", "2. No explicit imports (use FQN or rely on implicit imports)", "3. Single implicit class per source file", "4. Not suitable for large applications", "5. Limited access control (everything is package-private)", "6. No explicit constructors", "7. Cannot extend other classes explicitly" ); limitations.forEach(System.out::println); System.out.println("\nWhen to use traditional classes:"); var traditionalUseCases = java.util.List.of( "• Large-scale applications", "• Library development", "• Complex class hierarchies", "• Need for packages and access control", "• Team development with multiple classes" ); traditionalUseCases.forEach(System.out::println); } // Utility methods for common patterns String formatDuration(long milliseconds) { long seconds = milliseconds / 1000; long minutes = seconds / 60; long hours = minutes / 60; return String.format("%02d:%02d:%02d", hours, minutes % 60, seconds % 60); } void logWithTimestamp(String message) { String timestamp = java.time.LocalDateTime.now().format( java.time.format.DateTimeFormatter.ISO_LOCAL_TIME); System.out.printf("[%s] %s%n", timestamp, message); } <T> void printCollection(String title, java.util.Collection<T> collection) { System.out.println(title + ":"); if (collection.isEmpty()) { System.out.println(" (empty)"); } else { collection.forEach(item -> System.out.println(" - " + item)); } }

Key Benefits and Use Cases

Benefits of Implicitly Declared Classes:

1. Reduced Boilerplate: No need for explicit class declarations
2. Beginner-Friendly: Lower barrier to entry for new Java programmers
3. Quick Scripting: Perfect for small utilities and scripts
4. Simplified Syntax: Cleaner code for simple programs
5. Educational Value: Great for teaching Java concepts gradually

Ideal Use Cases:

1. Learning and Education: Introductory programming courses
2. Quick Scripts: One-off utilities and automation scripts
3. Prototyping: Rapid proof-of-concept development
4. Code Examples: Simplified demonstration code
5. Small Tools: Command-line utilities and simple applications

When to Use Traditional Classes:

1. Large Applications: Complex systems with multiple components
2. Library Development: Code meant for reuse by others
3. Team Projects: Collaborative development with clear structure
4. Enterprise Systems: Applications requiring packages and modules
5. Framework Development: Code that needs extensibility and inheritance

Implicitly declared classes in Java 23 represent a significant step toward making Java more accessible while maintaining its power and robustness for enterprise development.