Clean code is essential for maintaining and scaling Java applications. This guide covers principles and practices for writing clean, maintainable, and efficient Java code.
Key areas covered:
// Bad Example
class data {
public static int calc(int a, int b) {
return a + b;
}
}
// Good Example
public class CalculatorService {
public int add(int firstNumber, int secondNumber) {
return firstNumber + secondNumber;
}
public double calculateAverage(List numbers) {
return numbers.stream()
.mapToInt(Integer::intValue)
.average()
.orElse(0.0);
}
}
// Bad Example
class emp {
private String n;
private int a;
public void setN(String n) {
this.n = n;
}
}
// Good Example
public class Employee {
private String name;
private int age;
private Department department;
public void setName(String name) {
this.name = name;
}
public void assignToDepartment(Department department) {
this.department = department;
}
} // Bad Example
public class OrderProcessor {
private List l;
private int x;
private boolean f;
public void process(String s) {
for(String i : l) {
// Processing
}
}
}
// Good Example
public class OrderProcessor {
private List orderIds;
private int totalOrders;
private boolean isProcessing;
public void processOrder(String orderId) {
for(String existingOrder : orderIds) {
if(existingOrder.equals(orderId)) {
handleDuplicateOrder(orderId);
return;
}
}
processNewOrder(orderId);
}
private void handleDuplicateOrder(String orderId) {
log.warn("Duplicate order detected: {}", orderId);
}
private void processNewOrder(String orderId) {
// Order processing logic
}
} // Bad Example
public class UserService {
public void createUser(User user) {
// User creation logic
// Email sending logic
// Logging logic
// Validation logic
}
}
// Good Example
public class UserService {
private final EmailService emailService;
private final UserValidator validator;
private final UserRepository repository;
public UserService(EmailService emailService,
UserValidator validator,
UserRepository repository) {
this.emailService = emailService;
this.validator = validator;
this.repository = repository;
}
public void createUser(User user) {
validator.validate(user);
repository.save(user);
emailService.sendWelcomeEmail(user);
}
}
public class UserValidator {
public void validate(User user) {
validateEmail(user.getEmail());
validateUsername(user.getUsername());
}
private void validateEmail(String email) {
// Email validation logic
}
private void validateUsername(String username) {
// Username validation logic
}
}// Bad Example
public class PaymentProcessor {
public void processPayment(String type, double amount) {
if (type.equals("credit")) {
processCreditPayment(amount);
} else if (type.equals("debit")) {
processDebitPayment(amount);
}
}
}
// Good Example
public interface PaymentMethod {
void processPayment(double amount);
}
public class CreditCardPayment implements PaymentMethod {
@Override
public void processPayment(double amount) {
// Credit card payment logic
}
}
public class DebitCardPayment implements PaymentMethod {
@Override
public void processPayment(double amount) {
// Debit card payment logic
}
}
public class PaymentProcessor {
public void processPayment(PaymentMethod method,
double amount) {
method.processPayment(amount);
}
}com.company.project/
├── config/
│ ├── SecurityConfig.java
│ └── DatabaseConfig.java
├── controller/
│ ├── UserController.java
│ └── OrderController.java
├── service/
│ ├── UserService.java
│ └── OrderService.java
├── repository/
│ ├── UserRepository.java
│ └── OrderRepository.java
├── model/
│ ├── User.java
│ └── Order.java
└── util/
└── ValidationUtil.javapublic class OrderService {
// Constants
private static final int MAX_ORDERS = 100;
// Fields
private final OrderRepository repository;
private final OrderValidator validator;
// Constructor
public OrderService(OrderRepository repository,
OrderValidator validator) {
this.repository = repository;
this.validator = validator;
}
// Public methods
public Order createOrder(OrderRequest request) {
validateRequest(request);
Order order = buildOrder(request);
return saveOrder(order);
}
// Private methods
private void validateRequest(OrderRequest request) {
validator.validate(request);
}
private Order buildOrder(OrderRequest request) {
return Order.builder()
.customerId(request.getCustomerId())
.items(request.getItems())
.build();
}
private Order saveOrder(Order order) {
return repository.save(order);
}
}// Bad Example
public class ReportGenerator {
public void generateReport(User user) {
// 100+ lines of code doing multiple things
}
}
// Good Example
public class ReportGenerator {
private final DataCollector dataCollector;
private final ReportFormatter formatter;
private final ReportSender sender;
public void generateReport(User user) {
ReportData data = collectData(user);
Report report = formatReport(data);
sendReport(report, user);
}
private ReportData collectData(User user) {
return dataCollector.collect(user);
}
private Report formatReport(ReportData data) {
return formatter.format(data);
}
private void sendReport(Report report, User user) {
sender.send(report, user.getEmail());
}
}// Bad Example
public class NotificationService {
public void sendEmailNotification(User user) {
String message = "Hello " + user.getName();
// Email sending logic
logNotification("email", user);
}
public void sendSMSNotification(User user) {
String message = "Hello " + user.getName();
// SMS sending logic
logNotification("sms", user);
}
}
// Good Example
public interface NotificationStrategy {
void send(User user, String message);
}
public class NotificationService {
private final Map
strategies;
private final NotificationLogger logger;
public void sendNotification(String type,
User user, String message) {
NotificationStrategy strategy =
strategies.get(type);
strategy.send(user, message);
logger.log(type, user);
}
} Writing clean code is essential for maintaining and scaling Java applications. By following the principles and practices outlined in this guide, you can create more maintainable and efficient code.
Remember to focus on readability, maintainability, and proper organization for better code quality.