Prev Next

Java / Java 21 Coding Standards Interview Questions

How do you apply the Single Responsibility Principle in Java 21 class design standards?

The Single Responsibility Principle says a class should have exactly one reason to change; in practice this means separating "what the data is" from "what happens to it" and from "how it is delivered or persisted".

public record Invoice(String id, BigDecimal total) {}          // data
public class InvoiceTaxCalculator { BigDecimal apply(Invoice i) {...} } // one responsibility
public class InvoiceRepository { void save(Invoice i) {...} }          // another responsibility

Java 21's records make the "data" half of this split explicit and enforced by the compiler: a record cannot quietly grow business logic that depends on mutable internal state, because it has none, which naturally pushes behavior out into dedicated collaborator classes like a calculator or a validator.

A practical litmus test during review is to describe the class's job in one sentence without using "and" - if a class needs "calculates tax and saves the invoice and sends a notification" to be described accurately, it has three responsibilities and should be split into three classes.

The Single Responsibility Principle states that a class should:
A practical review test for SRP is to check whether the class's purpose:

More Related questions...

What is a coding standard in Java, and why does it matter for Java 21 projects? What are the standard naming conventions for classes and interfaces in Java 21? What are the standard naming conventions for methods and variables in Java? What is the purpose of a static analysis tool like Checkstyle in a Java 21 codebase? What is a record in Java 21, and why do coding standards recommend it for data carriers? What is a text block in Java 21? Define var and explain the coding standard guidelines around its use in Java 21? What are sealed classes in Java 21? Describe the recommended package naming convention in Java style guides? List the common Javadoc conventions required in Java coding standards? What is the purpose of the @Override annotation in Java coding standards? What are the types of comments recommended in Java style guides? How do you format a pattern-matching switch expression per Java 21 coding standards? What is the purpose of the final keyword in Java 21 coding standards? How do you apply consistent indentation and brace style in Java 21 code? What is the purpose of pattern matching for instanceof in Java 21? Describe the standard naming convention for custom exception classes in Java? What are the recommended import ordering rules in Java coding standards? Why is a record preferred over a traditional POJO for immutable data carriers? How does pattern matching for switch change the coding standard for type-checking code? What is the difference between var and explicit typing under Java 21 style guides? Why should you avoid wildcard imports in Java 21 projects? How do you troubleshoot a NullPointerException using Objects.requireNonNull as a coding standard? Why doesn't Checkstyle allow tab characters in most Java 21 style guides? When should you use a sealed interface instead of an enum? What happens when you omit a break statement in a traditional switch under coding standards? How is exception handling standardized in Java 21 with multi-catch and try-with-resources? Why is virtual thread naming convention different from platform thread naming? When should you choose text blocks over string concatenation? How do you optimize import statements and static imports per a Java style guide? What is the difference between checked and unchecked exceptions under Java coding standards? Why should you prefer immutable records over mutable classes for DTOs? Explain the standard structure and member ordering of a Java class file? Which is better and why: an enhanced switch or an if-else chain for type checks? How do you apply the Single Responsibility Principle in Java 21 class design standards? Explain the lifecycle of a virtual thread under Java 21 coding standard recommendations? Explain the execution flow of a switch expression using guarded patterns? Explain the internal working of sealed class exhaustiveness checking by the compiler? How can you optimize code readability using record patterns and deconstruction? How do you troubleshoot deprecated API usage flagged by Java 21 standards tooling? Why is structured concurrency recommended over raw thread management in Java 21? What is the difference between synchronized blocks and virtual-thread-friendly designs? How does the compiler enforce exhaustiveness in a switch over sealed types? Why should you avoid finalizers in favor of try-with-resources under Java 21 standards? Explain the internal working of the Sequenced Collections API introduced in Java 21? How do you design a thread-safe class following Java 21 coding standards? When should you use module-info.java for encapsulation as per coding standards? Which is better and why: exceptions versus sealed result types for error handling? How can you optimize static analysis coverage for Java 21 features like pattern matching? Explain the internal working of Generational ZGC and its influence on object-lifecycle coding standards?
Show more question and Answers...


Comments & Discussions