Java

You may already be familiar with Java, but if not, it’s worth noting that Java is a versatile and widely-used programming language. Known for its platform independence, Java allows developers to write code once and run it anywhere, thanks to the Java Virtual Machine (JVM). It’s a high-level, object-oriented language that has become a cornerstone of software development, powering everything from enterprise applications to Android mobile apps and web servers.

My Best Practices

My recommended best practices for Java are both common and widely adopted. Moreover, these practices are versatile and can be applied to most object-oriented programming (OOP) languages.

Visit My General Coding Best Practices

Leverage polymorphism

• Polymorphism is a powerful feature in Java and other object-oriented programming languages. it simplifies the calling code by allowing a single interface to work with different implementations, enabling flexibility and clean design.
• Think of polymorphism as exemplified in an ExceptionHandler class:

  class ExceptionHandler {
    public void handle(CustomException exception) {
      // Handle my custom exception according to business logic
    }
  
    public void handle(NullPointerException exception) {
      // Handle null pointer exception to aid in resolution
    }
  
    public void handle(NotFoundException exception) {
      // Handle not foud exception as an http exception for example
    }
  }
  

Avoid inheritance

• Inheritance is a fundamental feature in Java, but excessive use can significantly hinder maintainability, making code harder to understand, extend and modify.
• Inheritance should be limited to straightforward extensions that effectively redude duplicate code and simplify maintenance.
• Whenever possible, prefer composition over inheritance. Focusing on creating reusable classes promotes cleaner, more modular code and overall maintainability.

Handle Exceptions

• Always ensure resources are properly closed to prevent resource leaks and maintain application stability. The try-with-resources statement provides a simple and effective way to manage resources such as files, database connections, or streams. It ensures that resources are automatically closed when no longer needed, even in the event of an exception.

See also my general best practices on exception handling

Avoid Concurrency

• If your code is concurrent, make use of thread management tools from the java.util.concurrent package. This package offers utilities such as:
  • Executors for efficient thread management
  • Futures for handling async results
  • Concurrent collections for thread safe insertion, deletion and access
  • Sync utilities for coordinating threads
  • Atomic variables for safe operations on primitive types

See also my general best practices on concurrency

Streams

• Consider using streams whenever you do not need to mutate variables outside their scope. Streams enable concise, functional, and expressive code. By combining streams with well-defined custom functions, you can further enhance code readability and maintainability:

  List<String> namesForPeopleVeryOld = persons.stream()
                      .filter(Person::isOld)
                      .map(Person::getName)
                      .collect(Collectors.toList());
  

Shorthand Type Declaration (Java 10+)

• Use the keyword var exclusively for local variables to enhance readability and reduce redundancy when writing code. This approach also ensures that type safety is maintened:

  var name = "John";
  

Prefer Ifs Over Switches

• If using Java 14+, consider utilizing the new switch expression, which enhances readability and simplifies code:

  var flavourDesignation = switch (flavour) {
      case VANILLA -> "Sweety Vanilla";
      case CHOCOLATE -> "Strong Cocoa Chocolate";
      default -> "Raw for the strongest";
  };
  

See also my general best practices on switch statements

Optional ain’t an option

• When an object can be null, consider using the Optional API to enhance readability and eleminate unnecessary null checks:

  Optional<Integer> age = Optional.ofNullable(form.getAge());
  age.ifPresent(FormValidator::validateAge);
  

Optional does not support primitive types

Testing

• Consider using test extensions for complex setups and tear-downs when working with Junit 5. For Junit 4, create classes that extend ExternalResource and override the before and after methods, or implement the TestRule interface to achieve similar functionality.

  public class MyLifeCycleExtension implements 
      BeforeTestExecutionCallback, 
      AfterTestExecutionCallback
  {
      @Override
      public void beforeTestExecution(ExtensionContext context) {
        // Setup before the test
      }
  
      @Override
      public void afterTestExecution(ExtensionContext context) {
        // Teardown after the test
      }
  }
  

• Consider using the method doAnswer from Mockito for handling complex and dynamic return behaviours. However, avoid using it in new code, as tests should remain simple, and cyclomatic complexity should be minimized to ensure clarity and maintainability.

• Consider using the ArgumentMatcher class from Mockito to validate complex arguments in tests. For improved reusability and maintainability, define these matchers in dedicated classes.

This page is still a work in progress