09/09/2025 Tips

10 mẹo giúp code Java của bạn sạch hơn và dễ bảo trì

Java Clean Code Best Practices Mẹo hay
Trở về

10 mẹo giúp code Java của bạn sạch hơn và dễ bảo trì

Code sạch không chỉ giúp dự án của bạn dễ đọc hơn mà còn giúp giảm thiểu bug và tăng khả năng bảo trì. Dưới đây là 10 mẹo giúp code Java của bạn trở nên sạch hơn và dễ bảo trì hơn.

1. Đặt tên biến có ý nghĩa

Tên biến nên mô tả chính xác mục đích sử dụng của biến đó. Tránh những tên viết tắt hoặc quá ngắn gọn khiến người đọc khó hiểu.

// Không tốt
int d; // Ngày là gì?

// Tốt
int daysSinceCreation;
int elapsedTimeInDays;

2. Tuân thủ quy tắc đặt tên

  • Tên lớp: Danh từ, viết hoa chữ cái đầu (PascalCase): UserAccount, ProductService
  • Tên phương thức: Động từ, camelCase: getUserById(), calculateTotal()
  • Tên hằng số: Viết hoa, phân cách bằng gạch dưới: MAX_CONNECTIONS, DEFAULT_TIMEOUT

3. Giữ phương thức ngắn gọn

Mỗi phương thức nên thực hiện một nhiệm vụ duy nhất và không quá dài. Nếu phương thức của bạn vượt quá 20-30 dòng, hãy cân nhắc chia nhỏ nó.

// Không tốt
public void processUserData(User user) {
    // 50 dòng code thực hiện nhiều chức năng
}

// Tốt
public void processUserData(User user) {
    validateUser(user);
    updateUserInformation(user);
    notifyUserChanged(user);
}

4. Tận dụng nguyên tắc OOP

Đóng gói (Encapsulation)

Sử dụng private cho các trường dữ liệu và cung cấp getter/setter khi cần thiết.

public class User {
    private String name;
    
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
}

Kế thừa và đa hình

Sử dụng kế thừa để tái sử dụng code và đa hình để tăng tính linh hoạt.

public abstract class Shape {
    public abstract double calculateArea();
}

public class Circle extends Shape {
    private double radius;
    
    @Override
    public double calculateArea() {
        return Math.PI * radius * radius;
    }
}

5. Tránh lặp code (DRY - Don’t Repeat Yourself)

Nếu bạn thấy mình đang viết cùng một đoạn code nhiều lần, hãy tách nó thành một phương thức riêng.

// Không tốt
if (user.isActive()) {
    System.out.println("User: " + user.getName());
    System.out.println("Email: " + user.getEmail());
}

if (admin.isActive()) {
    System.out.println("User: " + admin.getName());
    System.out.println("Email: " + admin.getEmail());
}

// Tốt
private void printActiveUserInfo(User user) {
    if (user.isActive()) {
        System.out.println("User: " + user.getName());
        System.out.println("Email: " + user.getEmail());
    }
}

6. Sử dụng annotation đúng cách

Annotations giúp cung cấp metadata cho code của bạn và làm cho nó dễ hiểu hơn.

// @Override đảm bảo bạn đang ghi đè phương thức từ lớp cha
@Override
public String toString() {
    return "User{name='" + name + "'}";
}

// @Deprecated đánh dấu phương thức không nên sử dụng nữa
@Deprecated
public void oldMethod() {
    // ...
}

// @SuppressWarnings chỉ nên sử dụng khi bạn chắc chắn cảnh báo là không cần thiết
@SuppressWarnings("unchecked")
public List<String> getItems() {
    // ...
}

7. Xử lý ngoại lệ đúng cách

Không bỏ qua các ngoại lệ và luôn cung cấp thông tin hữu ích khi ngoại lệ xảy ra.

// Không tốt
try {
    // code có thể ném ngoại lệ
} catch (Exception e) {
    // Bỏ qua hoặc không xử lý gì
}

// Tốt
try {
    // code có thể ném ngoại lệ
} catch (IOException e) {
    logger.error("Không thể đọc file cấu hình", e);
    throw new ConfigurationException("Lỗi cấu hình", e);
}

8. Sử dụng các cấu trúc dữ liệu phù hợp

Chọn cấu trúc dữ liệu phù hợp với nhu cầu của bạn để tối ưu hiệu suất và tính dễ đọc.

// Chọn ArrayList khi cần truy cập ngẫu nhiên nhanh
List<String> items = new ArrayList<>();

// Chọn LinkedList khi cần thêm/xóa phần tử thường xuyên
List<String> queue = new LinkedList<>();

// Chọn HashSet khi cần kiểm tra tồn tại nhanh chóng
Set<String> uniqueItems = new HashSet<>();

// Chọn TreeSet khi cần duy trì thứ tự
Set<String> sortedItems = new TreeSet<>();

9. Viết comment có ý nghĩa

Comment nên giải thích tại sao code làm điều gì đó, không phải nó làm gì. Tránh những comment hiển nhiên.

// Không tốt
// Tăng counter lên 1
counter++;

// Tốt
// Tăng số lần thử lại để theo dõi giới hạn thử lại tối đa
retryCount++;

10. Áp dụng nguyên tắc SOLID

  • Single Responsibility: Mỗi lớp chỉ nên có một lý do để thay đổi
  • Open/Closed: Mở rộng nhưng đóng sửa đổi
  • Liskov Substitution: Các lớp con phải thay thế được lớp cha
  • Interface Segregation: Nhiều interface nhỏ tốt hơn một interface lớn
  • Dependency Inversion: Phụ thuộc vào abstraction, không phụ thuộc vào implementation
// Nguyên tắc Single Responsibility
public class UserRepository {
    public User findById(long id) {
        // Chỉ chịu trách nhiệm tìm kiếm user
    }
}

public class UserValidator {
    public boolean isValid(User user) {
        // Chỉ chịu trách nhiệm xác thực user
    }
}

Kết luận

Viết code sạch là một kỹ năng quan trọng mà mọi lập trình viên Java nên rèn luyện. Bằng cách áp dụng 10 mẹo trên, bạn không chỉ làm cho code của mình dễ đọc hơn mà còn giảm thiểu bug và tăng khả năng bảo trì. Hãy nhớ rằng, code sạch không chỉ là viết code cho máy tính hiểu mà còn là viết code cho con người đọc và hiểu.

Chatbot