Java Naming Conventions

Conventions by Identifier Type

Each category of identifier in Java has its own established casing style. Departing from these conventions is legal but considered poor practice and is flagged by linters and code reviewers.

• Classes and interfaces — PascalCase (also called UpperCamelCase): every word starts with a capital letter, no underscores. Example: BankAccount, Runnable.
• Methods and variables — camelCase: the first word is lowercase, subsequent words are capitalized. Example: calculateTotal(), studentName.
• Constants — UPPER_SNAKE_CASE: all uppercase letters with underscores separating words, and almost always declared static final. Example: MAX_DISCOUNT, DEFAULT_TIMEOUT.
• Packages — all lowercase, typically the reversed domain name of the organization, with no underscores. Example: com.webnest.banking.

Why These Conventions Exist

The casing itself carries information: seeing Vehicle car = new Vehicle(); tells an experienced Java reader immediately that Vehicle is a type and car is a variable, purely from capitalization, without needing to look up either declaration. Consistent naming also avoids collisions — lowercase packages never clash visually with PascalCase class names even when a package and a class share a similar word.

Additional Naming Rules

Beyond casing style, identifiers should be descriptive rather than abbreviated (totalPrice rather than tp), and single-letter names are conventionally reserved for loop counters (i, j) or generic type parameters (T, E, K, V). Boolean variables and methods conventionally read as a question or assertion, such as isValid or hasPermission, which makes conditional code read naturally.

Enums, Generics, Getters and Acronyms

A few more cases come up in almost every real project, and the second example below shows each of them:

• Enums — the enum type is PascalCase like any class (OrderStatus), and its constants are UPPER_SNAKE_CASE because they are fixed values (PLACED, OUT_FOR_DELIVERY).
• Generic type parameters — a single capital letter: T for a type, E for a collection element, K and V for map keys and values, R for a return type.
• Getters and setters — get or set plus the field name in PascalCase (getCustomerName(), setCustomerName()). A boolean getter uses is instead (isActive()). Frameworks such as Spring and Jackson find properties by these exact names.
• Acronyms — treat them as ordinary words so the casing stays readable: HttpClient and parseJson() rather than HTTPClient and parseJSON(). The JDK is not fully consistent here (it has both HttpClient and URL), but most style guides recommend the word form for new code.

Examples

package com.webnest.inventory; // package: all lowercase

public class InventoryItem { // class: PascalCase

    static final int MAX_QUANTITY = 1000; // constant: UPPER_SNAKE_CASE

    private String itemName; // variable: camelCase
    private int quantityInStock; // variable: camelCase

    public boolean isInStock() { // method: camelCase, reads as a question
        return quantityInStock > 0;
    }

    public static void main(String[] args) {
        InventoryItem item = new InventoryItem();
        item.itemName = "Notebook";
        item.quantityInStock = 25;
        System.out.println(item.itemName + " in stock: " + item.isInStock());
    }
}

Notebook in stock: true

import java.util.ArrayList;
import java.util.List;

public class OrderService {
    enum OrderStatus { PLACED, SHIPPED, DELIVERED } // enum type: PascalCase; constants: UPPER_SNAKE_CASE

    static class Box<T> { // generic type parameter: a single capital letter
        private final T item;
        Box(T item) { this.item = item; }
        T getItem() { return item; }
    }

    private String customerName; // field: camelCase
    private boolean active;      // boolean field: plain adjective

    public String getCustomerName() { return customerName; }      // getter: get + field name
    public void setCustomerName(String name) { customerName = name; } // setter: set + field name
    public boolean isActive() { return active; }                  // boolean getter: is + field name
    public void setActive(boolean active) { this.active = active; }

    public static void main(String[] args) {
        OrderService service = new OrderService();
        service.setCustomerName("Asha");
        service.setActive(true);

        List<OrderStatus> history = new ArrayList<>();
        history.add(OrderStatus.PLACED);
        history.add(OrderStatus.SHIPPED);

        Box<OrderStatus> latest = new Box<>(OrderStatus.SHIPPED);
        System.out.println(service.getCustomerName() + " active: " + service.isActive());
        System.out.println("Status history: " + history);
        System.out.println("Latest status: " + latest.getItem());
    }
}

Asha active: true
Status history: [PLACED, SHIPPED]
Latest status: SHIPPED

Exercise

This program compiles, but every name breaks a Java naming convention. Rename the class, the constant, the method and the variables to follow the conventions. The output must not change.

Expected output: Total: 236

class order_item {
    static final int taxpercent = 18;

    static int Calculate_Total(int PRICE, int Qty) {
        int sub_total = PRICE * Qty;
        return sub_total + sub_total * taxpercent / 100;
    }

    public static void main(String[] args) {
        System.out.println("Total: " + Calculate_Total(100, 2));
    }
}

class OrderItem {
    static final int TAX_PERCENT = 18;

    static int calculateTotal(int price, int quantity) {
        int subTotal = price * quantity;
        return subTotal + subTotal * TAX_PERCENT / 100;
    }

    public static void main(String[] args) {
        System.out.println("Total: " + calculateTotal(100, 2));
    }
}

Quick quiz

Interview questions