Start learning free

LESSON 11 OF 410 · VARIABLES

Variable Naming Rules in Java

Lesson Read the full explanation

TL ; DR:

  • In Java, we use the camelCase convention to name our variables. It implies separating different words with capital letters, like this:

    String companyName = "Apple";

int foundingYear = 1976;

boolean isUnicorn = true;

int numberOfEmployees = 137000;


Full lesson:

Variable names must consist ONLY of letters, numbers and underscores and they must start with a letter or underscore.

Bad variable names:

int 18spam;
String x.15;
Boolean #name;

If you try to create a variable with any of these names, Java will throw an error.

Naming conventions: camelCase and snake_case

Sometimes a variable name might consist of multiple words, for example if you want to store the first name of a person. You might be tempted to separate those names by whitespaces, like this:

String first name = "Kate";

This code will also throw an error.

When you name your variables, you want to use one of these two conventions:

snake_case = separate different words with an underscore (_), like this:

String first_name = "Jane";
String last_name = "Doe";

camelCase = separate different words with capital letters, like this:

String firstName = "Jane";
String lastName = "Doe";

It's important to be consistent with the casing technique you use. Do not combine both of them in the same code, like this:

String first_name = "Jane";
String lastName = "Doe";

Case sensitive:

Variable names are case sensitive:

String name = "Kate";
String Name = "Andy";
String NAME = "George";

System.out.println(name, Name, NAME); // Output: Kate Andy George

Although Java allows us to do this, it's always confusing and a bad coding practice to differentiate variable names just by case!

Mnemonic Variable Names:

Since we programmers are given a choice in how we choose our variable names, there is a bit of "best practice".

Sometimes we want them short like x and y, but sometimes we want them descriptive, especially if they are important.

Here is a great example:

int a = 25;
int b = 13;
int c = a * b;
System.out.println(c);

compared to:

int hours = 25;
int rate = 13;
int pay = hours * rate;
System.out.println(pay);

Java understands and is happy with both of these pieces of code. But it's clearly which version makes your reader happier.

Assignment
Follow the Coding Tutorial and let's let's name some variables well!

Hint
Look at the examples above if you get stuck.

STEP 1 OF 3
    Ctrl + Enter to check

    JAVA · VARIABLES

    Variable Naming Rules in Java, explained

    Introduction

    In this lesson, we will explore the rules and conventions for naming variables in Java. Proper variable naming is crucial for writing clear and maintainable code. It helps other developers understand your code more easily and reduces the likelihood of errors. Variable naming conventions are particularly useful in large projects where multiple developers collaborate.

    Understanding the Basics

    Before diving into the specifics of variable naming, it's important to understand what variables are. In Java, a variable is a container that holds data that can be changed during the execution of a program. Variables have a name, a type, and a value.

    For example:

    int age = 25;

    Here, int is the type, age is the name, and 25 is the value.

    Main Concepts

    Let's delve into the key concepts and techniques for naming variables in Java:

    1. Valid Characters

    Variable names must consist only of letters, numbers, and underscores. They must start with a letter or an underscore. For example:

    int _validName;
int validName2;

    Invalid names would include:

    int 2invalid;
int invalid-name;

    2. Naming Conventions

    Java developers typically use two naming conventions: camelCase and snake_case.

    camelCase: The first word is in lowercase, and each subsequent word starts with an uppercase letter.

    String firstName;
int numberOfEmployees;

    snake_case: Words are separated by underscores.

    String first_name;
int number_of_employees;

    Consistency is key. Do not mix these conventions within the same codebase.

    3. Case Sensitivity

    Variable names in Java are case-sensitive. This means name, Name, and NAME are considered different variables.

    String name = "Kate";
String Name = "Andy";
String NAME = "George";

System.out.println(name + ", " + Name + ", " + NAME); // Output: Kate, Andy, George

    While Java allows this, it's best to avoid using variable names that differ only by case to prevent confusion.

    4. Mnemonic Variable Names

    Choose variable names that are descriptive and meaningful. This makes your code easier to read and understand.

    int hoursWorked = 40;
int hourlyRate = 15;
int totalPay = hoursWorked * hourlyRate;
System.out.println(totalPay);

    Compare this to:

    int a = 40;
int b = 15;
int c = a * b;
System.out.println(c);

    The first example is much clearer and easier to understand.

    Examples and Use Cases

    Let's look at some examples to illustrate these concepts:

    Example 1: Valid and Invalid Variable Names

    int validName;
int _validName;
int validName2;

// Invalid names
int 2invalidName;
int invalid-name;
int invalid name;

    Example 2: camelCase and snake_case

    String firstName = "John";
String lastName = "Doe";

String first_name = "Jane";
String last_name = "Smith";

    Example 3: Case Sensitivity

    String name = "Alice";
String Name = "Bob";
String NAME = "Charlie";

System.out.println(name + ", " + Name + ", " + NAME); // Output: Alice, Bob, Charlie

    Example 4: Mnemonic Variable Names

    int length = 10;
int width = 5;
int area = length * width;
System.out.println(area); // Output: 50

    Common Pitfalls and Best Practices

    Here are some common mistakes to avoid and best practices to follow:

    Common Pitfalls

    • Using non-descriptive names like x and y for important variables.
    • Mixing camelCase and snake_case in the same codebase.
    • Using variable names that differ only by case.

    Best Practices

    • Use descriptive and meaningful names for variables.
    • Be consistent with your naming convention.
    • Avoid using single-letter names except for loop counters.

    Advanced Techniques

    As you become more experienced, you may encounter advanced techniques for variable naming, such as:

    1. Prefixes and Suffixes

    Using prefixes like is for boolean variables or num for numeric variables can make your code more readable.

    boolean isAvailable;
int numEmployees;

    2. Constants

    Constants are typically written in uppercase letters with underscores separating words.

    final int MAX_USERS = 100;

    Code Implementation

    Here is a well-commented code snippet demonstrating the correct use of variable naming conventions:

    // This class demonstrates proper variable naming conventions in Java
public class VariableNaming {

    public static void main(String[] args) {
        // camelCase convention
        String companyName = "Apple";
        int foundingYear = 1976;
        boolean isUnicorn = true;
        int numberOfEmployees = 137000;

        // snake_case convention
        String first_name = "Jane";
        String last_name = "Doe";

        // Case sensitivity
        String name = "Kate";
        String Name = "Andy";
        String NAME = "George";

        // Mnemonic variable names
        int hoursWorked = 40;
        int hourlyRate = 15;
        int totalPay = hoursWorked * hourlyRate;

        // Output the results
        System.out.println("Company: " + companyName);
        System.out.println("Founded: " + foundingYear);
        System.out.println("Is Unicorn: " + isUnicorn);
        System.out.println("Employees: " + numberOfEmployees);
        System.out.println("First Name: " + first_name);
        System.out.println("Last Name: " + last_name);
        System.out.println("Names: " + name + ", " + Name + ", " + NAME);
        System.out.println("Total Pay: " + totalPay);
    }
}

    Debugging and Testing

    When debugging code related to variable naming, consider the following tips:

    • Check for typos in variable names.
    • Ensure consistency in naming conventions.
    • Use meaningful names to make debugging easier.

    To test your code, you can write unit tests that verify the correctness of your variable assignments and calculations.

    Thinking and Problem-Solving Tips

    When approaching problems related to variable naming, consider these strategies:

    • Break down complex problems into smaller, manageable parts.
    • Use descriptive names to make your code self-documenting.
    • Practice by writing code and reviewing examples from experienced developers.

    Conclusion

    In this lesson, we covered the importance of proper variable naming in Java. We discussed the rules and conventions for naming variables, common pitfalls to avoid, and best practices to follow. By mastering these concepts, you can write clear, maintainable, and error-free code.

    Remember to practice and apply these techniques in your projects to become a better programmer.

    Additional Resources

    For further reading and practice, consider the following resources:

    Keep going with JavaAbout 340 step-by-step lessons, from your first line of code to coding interviews. Free to start.
    Start learning free