Java Identifiers: Naming Rules, Conventions, and Valid Examples

An identifier is simply the name you choose for the things you build in Java. When you write int totalPrice = 500; the word totalPrice is the identifier, while int is a keyword and 500 is a literal. That one line already contains all three ideas, which is why beginners often mix them up in the beginning.

Think of it the way you would think about naming a newborn. A legal name is not enough; a good name helps. totalPrice tells you what the number means, while x or d1 tells you nothing three months later. Java lets you name things fairly freely, but the language still sets a few hard rules.

Every one of these is an identifier, because you chose the name yourself:

• A class name such as InvoiceProcessor

• A variable name such as customerAge

• A method name such as calculateTotal

• A package name such as com.mycompany.billing

• A constant name such as MAX_RETRIES

Identifiers appear in almost every position a Java programmer can write a name. Recognising them makes the rest of this topic much easier.

This is the single most common confusion at the start of Java, so it is worth nailing down early.

DECLARING ONE VARIABLE, THREE DIFFERENT THINGS

    int  totalPrice  =  500;
     |      |          |
     |      |          +---> LITERAL   a fixed value written directly
     |      +--------------> IDENTIFIER a name YOU chose
     +---------------------> KEYWORD    a word reserved by Java

  KEYWORD    : int, class, return, if, while   (51 reserved words)
  LITERAL    : 500, 3.14, 'x', true, false, null
  IDENTIFIER : totalPrice, customerAge, calculateTotal

• Keywords belong to the language. Java refuses to let you use them as names.

• Literals are raw values. Writing true as a variable name is a compile error because true is the boolean literal.

• Identifiers are your own names. If Java did not reserve the word and you typed it yourself, it is an identifier.

Java is not fussy, but it does enforce five rules. Learn these and you can always check any name quickly.

THE FIVE RULES AT A GLANCE

  ┌────────────────────────────────────────────────────────────┐
  │ RULE 1  The first character must be a letter, _ or $      │
  │ RULE 2  Later characters may be letters, digits, _ or $   │
  │ RULE 3  There is no practical length limit                 │
  │ RULE 4  Identifiers are case-sensitive                     │
  │ RULE 5  A keyword or literal can never be an identifier    │
  └────────────────────────────────────────────────────────────┘

          howManyItems
          _
          $total
          user2
         ┌──────┐
         │ 2nd │───►  illegal, starts with a digit
         └──────┘

Rule one allows letters from any language, not just English. Names like café, élève and even customers written in Hindi or Japanese are perfectly legal Java identifiers, provided the characters are letters rather than symbols.

Rule four catches people out constantly. totalAmount and Totalamount are two different names, and using both in one class compiles without complaint even though it is a readability disaster.

Memorising rules is dull. Studying real names is much faster, so here is a table of names you are likely to meet in real projects.

public class ValidNames {
    public static void main(String[] args) {
        int order2 = 20;
        // fine
        int _tempValue = 5;
        // legal, but do not copy this style
        double $discount = 0.2;
        // legal, but do not copy this style
        int MAX_RETRIES = 3;
        // legal as a variable, wrong for a constant
        System.out.println(order2 + _tempValue + $discount + MAX_RETRIES);
    }
}

Java reserves 51 keywords. Add the three literals true, false and null, and none of those words can be a variable, class or method name.

WORDS YOU CANNOT USE AS IDENTIFIERS

  Keywords (a small sample of the 51)
  ┌─────────────────────────────────────────────────────────┐
  │  Types      int  long  double  float  char  boolean   │
  │  Flow       if  else  for  while  switch  break       │
  │  Objects    class  new  this  super  extends           │
  │  Modifiers  public  private  protected  static  final  │
  │  Errors     try  catch  finally  throw  throws         │
  │  Reserved   const  goto  (reserved, never used)        │
  └─────────────────────────────────────────────────────────┘

  Literals (values, not names)
  ┌─────────────────────────────────────────────────────────┐
  │  true   false   null                                    │
  └─────────────────────────────────────────────────────────┘

• The words const and goto are reserved by the specification but cannot actually appear in your code, so simply avoid them.

• From Java 9 onwards a single underscore is treated as a keyword, which is why int _ = 5; now fails to compile.

• Modern releases added contextual keywords such as var, record, sealed, permits and yield. They are only special in certain positions, so var can still be used as a name even though it is a poor idea.

• Naming a variable int, or trying to redeclare the same name twice in one scope, also produces errors that look like keyword problems but are actually scope problems.

Validity is enforced by the compiler. Conventions are enforced by good developers, and they are the reason professional Java code looks the way it does.

HOW EACH STYLE LOOKS IN PRACTICE PascalCase InvoiceProcessor calculateInvoiceTotal lowerCamelCase invoiceProcessor calculateInvoiceTotal UPPER_SNAKE_CASE INVOICE_PROCESSOR MAX_RETRY_COUNT

The pattern itself is not what Java checks. You could name a class CalculateTotal and it would compile, but every professional Java developer reading your file would immediately know you did not follow the language's conventions.

Classes are the biggest objects in your program, so give them the clearest names you can.

• Use PascalCase, so InvoiceProcessor rather than invoiceProcessor or invoice_processor.

• Prefer a singular noun. A class named Customer is much clearer than Customers, because one Customer object represents one customer.

• Keep related classes in the same family: Invoice, InvoiceItem and InvoiceProcessor belong together.

• Do not add type words such as Class or Helper to the end of a name, since InvoiceService already tells you it is a service.

• The file name must match the public class name exactly, including capital letters, so InvoiceProcessor.java.

public class InvoiceProcessor {
    private int invoiceId;
    private double invoiceTotal;
    public double getInvoiceTotal() {
        return invoiceTotal;
    }
}

These are the names you type most often, so it pays to make them consistent.

• Name variables with a singular, descriptive noun in lowerCamelCase, such as customerAge or accountBalance.

• Name methods with a verb, because a method performs an action: sendEmail, calculateTotal, isValid.

• Start boolean variables and methods with is, has, can or should, so conditions read like English sentences.

• Keep parameters short but meaningful. Use orderId rather than o, and never reuse the same single letter for unrelated values in one method.

• Short names are fine for obvious throwaway loops such as i, j and k, and for temporary values that disappear within a few lines.

public class BankAccount {
    private double accountBalance;
    // Verb + noun tells the reader what happens
    public boolean canWithdraw(double requestedAmount) {
        return requestedAmount > 0 && requestedAmount

A constant is any variable declared with both static and final. Because it never changes, its name should scream that fact.

• Write the whole name in UPPER_SNAKE_CASE with underscores between words.

• Use the pattern MAX_VALUE or DEFAULT_VALUE so the purpose is obvious at a glance.

• Keep the declaration next to the top of the class so readers find it immediately.

CONSTANTS YOU WILL MEET IN EVERY PROJECT MAX_RETRY_COUNT DEFAULT_TIMEOUT MIN_PASSWORD_LENGTH MAX_PAGE_SIZE DEFAULT_CURRENCY TAX_RATE

public class Configuration {
    static final int MAX_RETRY_COUNT = 3;
    static final int DEFAULT_TIMEOUT_MS = 5000;
    static final double TAX_RATE = 0.18;
    static final String DEFAULT_CURRENCY = "INR";
}

Java packages are written in all lowercase with dots separating the levels. The widely used pattern is to write your domain name backwards, which guarantees that names never clash across projects.

PACKAGE NAME BUILDS FROM THE DOMAIN BACKWARDS

    mycompany.com
        |
        +--> com.mycompany.billing          billing code
                    |
                    +--> com.mycompany.billing.invoice    invoice classes
                    +--> com.mycompany.billing.payment    payment classes

• Start with com, org, net, io or edu, which are the common top-level domains.

• Then add your company or organisation name in lowercase, with no spaces or hyphens.

• Add the project or module last, for example com.mycompany.billing.payment.

• Folder structure must match the package exactly, otherwise the compiler cannot find the classes.

package com.mycompany.billing.invoice;
public class Invoice {
    private String invoiceId;
}

Following conventions is not about looking fussy. It has real, practical benefits every day.

• Beginners can read unfamiliar code because the shape of a name tells them what it is before they open the file.

• Teams work faster because nobody has to ask what x means or which of two similar methods to call.

• Static analysis tools, log search and refactoring features such as Rename Class rely on predictable names.

• Interviewers read naming quality as a signal that you have written code other people had to maintain.

• Bug reports become readable. Search for customerEmail in your logs and you immediately know which code path ran.

Nearly every Java learner makes these five mistakes at least once.

• Using one-letter names everywhere. Your code becomes impossible to debug the moment it grows past a screen.

• Naming variables after their type, such as int intValue or String stringValue, which repeats information the declaration already gives.

• Adding the letter l or a capital I to names such as length or itemList, because lowercase l and number 1 look almost identical in most fonts.

• Being consistent everywhere except one place, so a class named UserService sits next to a method called get_user_data.

• Naming a boolean isAvailable when you actually mean available, and later writing if (available = true) by mistake, which assigns instead of comparing.

Keep this summary nearby while you write your first few programs.

Once these eight rows become habit, move on to variables and data types, where these names finally get values to hold.