Java Identifiers — Rules, Naming Conventions & Best Practices

public class Triangle {
//  ↑ keyword  ↑ identifier

    private int sides;
//  ↑ keyword  ↑ keyword  ↑ identifier

    public Triangle() {
//  ↑ keyword  ↑ identifier (constructor = class name)
        this.sides = 3;
//                   ↑ literal (integer literal '3')
    }

    public boolean isValid() {
//  ↑ keyword  ↑ keyword  ↑ identifier (method name)
        return true;
//      ↑ keyword  ↑ boolean literal (NOT a keyword!)
    }

    public String describe() {
//                ↑ identifier (String is a class, not a keyword)
        return "I am a triangle";
//             ↑ String literal
    }
}

// ❌ BAD: cryptic, meaningless names
int x = 86400;
double d = 0.18;
String s = "ACTIVE";
boolean b = true;
List<String> l = new ArrayList<>();

// ✅ GOOD: intent-revealing, self-documenting names
int secondsInOneDay     = 86400;
double gstRateIndia     = 0.18;
String accountStatus    = "ACTIVE";
boolean isEmailVerified = true;
List<String> errorMessages = new ArrayList<>();

// ✅ GOOD: Boolean variable names — use is/has/can/should prefix
boolean isLoggedIn       = false;
boolean hasAdminPrivilege = true;
boolean canEditProfile   = false;
boolean shouldRetry      = true;

// ✅ GOOD: Collection names — plural noun
List<User> users             = new ArrayList<>();
Map<String, Integer> scores  = new HashMap<>();
Set<String> uniqueEmails     = new HashSet<>();

// ✅ GOOD: Loop variables — descriptive for complex loops
for (int rowIndex = 0; rowIndex < matrix.length; rowIndex++) {
    for (int colIndex = 0; colIndex < matrix[rowIndex].length; colIndex++) {
        // Nested loop: explicit names prevent confusion
    }
}

// ❌ Inconsistent acronym treatment (old style)
String userID    = "U001";
String baseURL   = "https://api.example.com";
int    XMLlength = 1024;
class  HTTPSClient { }

// ✅ Modern Java / Google Style: acronym = normal word
String userId    = "U001";   // Id, not ID
String baseUrl   = "https://api.example.com"; // Url, not URL
int    xmlLength = 1024;     // Xml, not XML
class  HttpsClient { }       // Https, not HTTPS

// Exception: standalone acronyms (all-caps is fine for constants)
static final String BASE_URL = "https://api.example.com";
static final int    HTTP_PORT = 80;
static final int    HTTPS_PORT = 443;

public class PaymentService {
    
    // ❌ BAD: vague, noun-based, unclear intent
    public void payment() { }
    public boolean check(String card) { return false; }
    public String data(long id) { return null; }
    public void thing(Order order) { }
    
    // ✅ GOOD: verb-first, intent-revealing
    public void processPayment(Payment payment) { }
    public boolean validateCreditCard(String cardNumber) { return false; }
    public String fetchTransactionDetails(long transactionId) { return null; }
    public void cancelOrderWithRefund(Order order) { }
    
    // ✅ GOOD: Getter/Setter pattern (JavaBeans)
    private double taxRate;
    public double getTaxRate() { return taxRate; }
    public void setTaxRate(double taxRate) { this.taxRate = taxRate; }
    
    // ✅ GOOD: Boolean method — 'is' prefix
    public boolean isPaymentExpired(Payment payment) { return false; }
    public boolean hasInsufficientBalance(Account account) { return false; }
    
    // ✅ GOOD: Factory method — 'of' pattern
    public static PaymentService of(String apiKey) {
        return new PaymentService();
    }
}

// ✅ GOOD: Nouns / Noun phrases for Classes
class User { }
class BankAccount { }
class HttpRequestHandler { }
class OrderLineItem { }
class DatabaseConnectionPool { }

// ✅ GOOD: Adjectives / Role-describing names for Interfaces
interface Runnable { }         // Can be run
interface Serializable { }     // Can be serialized
interface Comparable<T> { }    // Can be compared
interface AutoCloseable { }    // Can be auto-closed
interface UserRepository { }   // Repository role (DDD)

// ✅ GOOD: Design Pattern names embedded in class name
class UserServiceImpl implements UserService { }   // Implementation
class PaymentFactory { }                           // Factory Pattern
class OrderBuilder { }                             // Builder Pattern
class LoggerSingleton { }                         // Singleton Pattern
class NotificationObserver { }                    // Observer Pattern
class DatabaseProxy { }                           // Proxy Pattern

// ❌ BAD: Vague, abbreviation-heavy, non-descriptive
class Mgr { }        // Manager of what?
class Util { }       // Utility for what?
class Data { }       // What kind of data?
class Obj { }        // Just 'object'?
class Helper { }     // Helping with what?

public class AppConstants {
    
    // ✅ Mathematical constants
    public static final double PI                = 3.141592653589793;
    public static final double EULER_NUMBER      = 2.718281828459045;
    
    // ✅ Configuration constants
    public static final int    MAX_RETRY_ATTEMPTS  = 3;
    public static final int    DEFAULT_TIMEOUT_MS  = 5000;
    public static final int    MAX_POOL_SIZE        = 20;
    public static final String DEFAULT_CHARSET      = "UTF-8";
    public static final String DATE_FORMAT_ISO8601  = "yyyy-MM-dd'T'HH:mm:ssZ";
    
    // ✅ HTTP constants
    public static final int    HTTP_PORT   = 80;
    public static final int    HTTPS_PORT  = 443;
    public static final String API_VERSION = "v2";
    
    // ✅ Enum constants (inside enum — same SCREAMING_SNAKE convention)
    enum OrderStatus {
        PENDING,
        PAYMENT_RECEIVED,
        PROCESSING,
        SHIPPED,
        DELIVERED,
        CANCELLED_BY_USER,
        CANCELLED_BY_SYSTEM
    }
    
    // ❌ BAD: camelCase for constants — confusing, unprofessional
    public static final int maxRetryAttempts = 3;   // Wrong convention
    public static final String defaultCharset = "UTF-8"; // Wrong
}

// ✅ Standard: reverse domain + project + module
package com.techsustainify.banking.account;
package com.techsustainify.banking.payment;
package org.apache.commons.lang3;
package io.spring.framework.context;

// ✅ Open-source project (no domain): short project name
package java.util;
package java.lang;
package javax.servlet;

// ✅ Internal enterprise package structure
package com.company.projectname.feature.layer;
// Example: com.infosys.bankingapp.transfer.service
//          com.wipro.hrms.payroll.repository
//          in.gov.uidai.aadhaar.verification

// ❌ BAD: uppercase letters — violates convention
package Com.TechSustainify.Banking; // WRONG

// ❌ BAD: spaces or hyphens (impossible anyway — compile error)
// package com.tech sustainify; // Compile error

// ✅ If package name contains reserved word: append underscore
package com.example.int_;   // 'int' is keyword, add underscore
package com.example.class_; // 'class' is keyword, add underscore

public class UnicodeDemo {
    public static void main(String[] args) {
        // ✅ Valid: Hindi (Devanagari) identifiers
        int उम्र = 25;           // 'umra' = age in Hindi
        String नाम = "Rahul";    // 'naam' = name in Hindi
        
        // ✅ Valid: Japanese identifiers
        int 年齢 = 30;            // 'nenrei' = age in Japanese
        
        // ✅ Valid: Arabic identifiers
        double سعر = 99.99;      // 'si'r' = price in Arabic
        
        // ✅ Valid: Greek mathematical notation
        double π = Math.PI;
        double λ = 0.5;          // lambda — useful in physics code
        double Δx = 0.001;       // delta-x
        
        // ✅ Valid: Unicode escape sequences
        int \u0041ge = 25; // \u0041 = 'A', so identifier is 'Age'
        
        System.out.println(नाम + " is " + उम्र + " years old.");
    }
}

// Java's built-in identifier validation methods
public class IdentifierValidator {
    
    public static boolean isValidIdentifier(String name) {
        if (name == null || name.isEmpty()) return false;
        
        // First character: must be valid START character
        if (!Character.isJavaIdentifierStart(name.charAt(0))) {
            return false;
        }
        
        // Remaining characters: must be valid PART characters
        for (int i = 1; i < name.length(); i++) {
            if (!Character.isJavaIdentifierPart(name.charAt(i))) {
                return false;
            }
        }
        return true;
    }
    
    public static void main(String[] args) {
        System.out.println(isValidIdentifier("age"));      // true
        System.out.println(isValidIdentifier("2age"));     // false
        System.out.println(isValidIdentifier("_count"));   // true
        System.out.println(isValidIdentifier("my-var"));   // false
        System.out.println(isValidIdentifier("नाम"));      // true (Unicode)
    }
}

// ✅ Java 7+: Underscores in numeric literals (readability)
int   population  = 1_400_000_000;  // 1.4 billion
long  nationalDebt = 3_000_000_000_000L;
double pi6digits  = 3.141_592;
int   hexColor    = 0xFF_00_FF;     // In hex literals too!

// ✅ Java 21+: Unnamed variable pattern (underscore as throwaway)
try {
    riskyOperation();
} catch (Exception _) {  // We don't need the exception object
    log.warn("Operation failed, retrying...");
}

// ✅ Java 21+: Unnamed pattern variable
if (obj instanceof Point(var x, var _)) {  // y-coordinate unused
    System.out.println("X coordinate: " + x);
}

// ❌ Java 21+: Single _ as named variable — ILLEGAL
// int _ = 5;  // Compile error in Java 21+

// ✅ How the COMPILER uses $ (you'll see these in bytecode)
// Inner class:      OuterClass$InnerClass.class
// Anonymous class:  OuterClass$1.class, OuterClass$2.class
// Lambda:           ClassName$$Lambda$1.class
// Record:           Point$record.class

// ❌ AVOID: $ in hand-written code
String $name = "Tech";          // Confusing — looks auto-generated
class $UserService { }           // Never do this

// ⚠️ Exception: JavaScript interop (GWT, legacy code)
// Some frameworks used $ for bridge classes — acceptable in that context

// ✅ The only acceptable human use: Lombok-generated code
// (Lombok sometimes generates fields with $ to avoid name clashes)
// But even then, Lombok handles it — you never write $ yourself

// ❌ ANTI-PATTERN 1: Meaningless single letters
int a = getUserCount();
int b = getActiveUsers();
double c = a / (double) b * 100;

// ✅ BETTER: Self-documenting
int totalUsers  = getUserCount();
int activeUsers = getActiveUsers();
double activeUserPercentage = totalUsers / (double) activeUsers * 100;

// ❌ ANTI-PATTERN 2: Hungarian Notation
String strFirstName;
int    intAge;
boolean bIsAdmin;
List<String> arrNames;

// ✅ BETTER: Type-free naming
String firstName;
int    age;
boolean isAdmin;
List<String> names;

// ❌ ANTI-PATTERN 3: Abbreviation overload
public int calcTtlAmt(List<Ord> ords, Usr usr, Disc dsc) {
    int ttl = 0;
    for (Ord o : ords) { ttl += o.getAmt(); }
    return applyDsc(ttl, dsc, usr);
}

// ✅ BETTER: Full, readable names
public double calculateTotalAmount(List<Order> orders, User user, Discount discount) {
    double totalAmount = 0.0;
    for (Order order : orders) {
        totalAmount += order.getAmount();
    }
    return applyDiscount(totalAmount, discount, user);
}

package com.techsustainify.userservice.domain;
//      ↑ all lowercase, reverse domain, feature-first structure

import java.time.LocalDateTime;
import java.util.Optional;

// Class: PascalCase, noun phrase
public class UserAccount {
    
    // Constants: SCREAMING_SNAKE_CASE
    private static final int    MAX_LOGIN_ATTEMPTS    = 5;
    private static final long   SESSION_TIMEOUT_MS    = 1_800_000L; // 30 min
    private static final String DEFAULT_TIMEZONE      = "Asia/Kolkata";
    
    // Fields: lowerCamelCase, nouns
    private final long          userId;
    private       String        emailAddress;
    private       String        hashedPassword;
    private       boolean       isEmailVerified;
    private       boolean       isAccountLocked;
    private       int           failedLoginAttempts;
    private       LocalDateTime lastLoginTimestamp;
    private       LocalDateTime accountCreatedAt;
    
    // Constructor: same name as class (PascalCase)
    public UserAccount(long userId, String emailAddress) {
        this.userId             = userId;
        this.emailAddress       = emailAddress;
        this.isEmailVerified    = false;
        this.isAccountLocked    = false;
        this.failedLoginAttempts = 0;
        this.accountCreatedAt   = LocalDateTime.now();
    }
    
    // Getters: get + FieldName (camelCase)
    public long          getUserId()              { return userId; }
    public String        getEmailAddress()        { return emailAddress; }
    public boolean       isEmailVerified()        { return isEmailVerified; }
    public boolean       isAccountLocked()        { return isAccountLocked; }
    public LocalDateTime getLastLoginTimestamp()  { return lastLoginTimestamp; }
    
    // Action methods: verb + noun, lowerCamelCase
    public void recordSuccessfulLogin() {
        this.lastLoginTimestamp  = LocalDateTime.now();
        this.failedLoginAttempts = 0;
        this.isAccountLocked     = false;
    }
    
    public void recordFailedLoginAttempt() {
        this.failedLoginAttempts++;
        if (this.failedLoginAttempts >= MAX_LOGIN_ATTEMPTS) {
            lockAccount();
        }
    }
    
    // Private helper: same convention, private visibility
    private void lockAccount() {
        this.isAccountLocked = true;
    }
    
    // Validation: is/has/can prefix for boolean return
    public boolean isEligibleForPasswordReset() {
        return isEmailVerified && !isAccountLocked;
    }
    
    public boolean hasExceededLoginAttempts() {
        return failedLoginAttempts >= MAX_LOGIN_ATTEMPTS;
    }
    
    // Factory method: static, 'of' pattern
    public static UserAccount of(long userId, String email) {
        return new UserAccount(userId, email);
    }
}

package com.techsustainify.userservice.repository;

// Interface: PascalCase, role-based noun
public interface UserAccountRepository {
    
    // Method: verb + noun, returns Optional for nullable results
    Optional<UserAccount> findByUserId(long userId);
    Optional<UserAccount> findByEmailAddress(String emailAddress);
    List<UserAccount>     findAllLockedAccounts();
    
    // Persistence methods: save/delete/update convention
    UserAccount save(UserAccount userAccount);
    void        deleteByUserId(long userId);
    boolean     existsByEmailAddress(String emailAddress);
    
    // Query methods: count/sum/aggregate pattern
    long countActiveUsersRegisteredAfter(LocalDateTime registrationDate);
}