As Java developers, we are looking for ways to be more efficient. In addition to syntax and knowledge of the programming language, some practices will improve code quality and make it more maintainable.
Here are a few Coding practices I use as a Java developer.
Using Functional Programming Paradigms
Java 8 introduced functional interfaces, lambda expressions, and Stream APIs. These help us write cleaner, concise, and readable code.
Still, I see people using the imperative programming style. There is nothing wrong with that, but they must use better ways to write more readable code.
Suppose there is a list of strings. We want to create a separate list with all strings whose length is less than 5.
Using traditional approach
List<String> filtered = new ArrayList<>();
for (String s : strings) {
if (s.length() < 5) {
filtered.add(s);
}
}
Functional approach to the above problem
List<String> filtered = strings.stream()
.filter(s -> s.length() > 5)
.collect(Collectors.toList());
Write code with Testability in mind
We should not consider writing unit tests as a separate task. In such cases, we often write code, which makes it difficult to write tests.
We should design the code so that it is testable from the beginning. It is important to ensure that the components are loosely coupled.
- Keep the methods small and ensure a Single Responsibility Principle for the class.
- Use proper dependency injection to loosely couple classes from their dependency.
- Avoid static classes if not needed. They are challenging to mock for testing.
// Hard to test
public class OrderProcessor {
public void process(Order order) {
// Direct instantiation creates tight coupling
PaymentGateway gateway = new PaymentGateway();
gateway.processPayment(order);
// Static method call is difficult to mock
EmailSender.sendConfirmation(order);
}
}
// Designed for testability
public class OrderProcessor {
private final PaymentGateway paymentGateway;
private final EmailService emailService;
public OrderProcessor(PaymentGateway paymentGateway, EmailService emailService) {
this.paymentGateway = paymentGateway;
this.emailService = emailService;
}
public void process(Order order) {
paymentGateway.processPayment(order);
emailService.sendConfirmation(order);
}
}
Use Composition Over Inheritance
Inheritance binds the parent and child classes, creating tight coupling. This makes the code less flexible and difficult to maintain.
Consider the case below, where we have different types of employees.
Inheritance Approach
// Inheritance approach
public class Employee { /* ... */ }
public class Manager extends Employee { /* ... */ }
public class Developer extends Employee { /* ... */ }
This creates inflexible relationships. What will happen if the developer becomes a manager? This inheritance will not be correct.
Using Composition
// Composition approach
public class Employee {
private PersonalInfo personalInfo;
private List<Role> roles;
private PaymentDetails paymentDetails;
// Methods to add/remove roles, etc.
}
public interface Role {
void performDuties();
}
public class DeveloperRole implements Role { /* ... */ }
public class ManagerRole implements Role { /* ... */ }
Master Concurrent Programming Techniques
Thread management is an essential part of developing any application. It is necessary to understand and use concurrent programming efficiently.
It is important to understand thread safety issues. Use atomic classes, concurrent collections, and synchronization techniques efficiently.
ExecutorService for thread pool Management
ExecutorService executor = Executors.newFixedThreadPool(10);
Future<Result> future = executor.submit(() -> processData(input));
// Do some other work
Result result = future.get(); // Block until the result is available
CompletableFuture for complex workflows
CompletableFuture<Order> future = CompletableFuture
.supplyAsync(() -> findOrder(orderId))
.thenApply(this::enrichOrder)
.thenCompose(order ->
CompletableFuture.supplyAsync(() -> calculateTax(order)))
.exceptionally(ex -> handleError(ex));
Using SOLID Principles
These principles are the foundation of object-oriented design.
- Single Responsibility Principle: A class should have only one reason to change.
- Open/Closed Principle: The class should be open for extension, but modifications should not be allowed.
- Liskov Substitution Principle: Subtypes must be substitutable for their base types.
- Interface Segregation Principle: Create small, focused interfaces rather than general-purpose interfaces.
- Dependency Inversion Principle: High-level modules should depend on abstractions, not low-level modules.
These were some of the principles. Principles are not rules but guidelines for writing clean, readable code.
Thanks for reading. If you enjoy my content and want to show support, you can check out my other articles, give a few claps, and follow me for more such content. I write on Java, Productivity, and Technology.
