Java 23 Preview: Implicitly Declared Classes

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.

Table of Contents

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:

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

Ideal Use Cases:

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

When to Use Traditional Classes:

Large Applications: Complex systems with multiple components
Library Development: Code meant for reuse by others
Team Projects: Collaborative development with clear structure
Enterprise Systems: Applications requiring packages and modules
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.