Start learning free

LESSON 13 OF 410 · VARIABLES

Constants in Java

Lesson Read the full explanation

There is a special type of variable in Java, which is called constant or final.

A constant is a variable that we do not want to change the value of during the whole program.


Creation:

You create a constant variable just like you create a normal one, but adding the keyword final before the variable's data type:

final String ourName = "AlgoCademy";

System.out.println(ourName); // Output: AlgoCademy

Reassignment not allowed:

However, a final variable cannot be reassigned because it is constant. If you try to reassign a final variable, you’ll get an error.

For example, this code:

final String ourName = "AlgoCademy";

ourName = "Andy"; // Here is the problem

would produce error: cannot assign a value to final variable

Usage:

It seems like constants are just variables with some limitations. So, why use them when we can do the same things (and more) with normal variables?

The power of constants lies in their limitation! Constants were invented to provide some level of guarantee that the code can't change the underlying value.

This is not of much importance for a smaller project, but matters on a larger project with multiple components written by multiple authors.

Picture this: You are the first developer to have ever worked at a new startup. When you have written the core code, you created some important variables that describe your company:

final String companyName = "Apple";
final String foundingDate = "April 1st, 1976";
final String founderName = "Steve Jobs";

Ten years later, your company blew up and you have hundreds of Software Engineers managing millions of lines of code.

I bet you wouldn't love it if a Junior Developer was able to do this successfully:

companyName = "Microsoft";
founderName = "Bill Gates";

But you are smart! You made those variables constants ten years ago and have nothing to worry about now. As for the Junior, they'll just get an error and probably a slap on the wrist by their manager.

Assignment
Follow the Coding Tutorial and let's work with constants!

Hint
Look at the examples above if you get stuck.

STEP 1 OF 1
    Ctrl + Enter to check

    JAVA · VARIABLES

    Constants in Java, explained

    Introduction

    In this lesson, we will explore the concept of constants in Java, also known as final variables. Constants are a fundamental part of programming that help ensure the integrity and reliability of your code. They are particularly useful in scenarios where you want to prevent the modification of certain values throughout the execution of your program.

    Understanding the Basics

    Constants in Java are variables whose values cannot be changed once they are initialized. This is achieved by using the final keyword. Understanding constants is crucial because they help in maintaining the consistency and predictability of your code.

    Here is a simple example to illustrate the concept:

    final int MAX_USERS = 100;
System.out.println(MAX_USERS); // Output: 100

    In this example, MAX_USERS is a constant, and its value cannot be changed once it is set to 100.

    Main Concepts

    Let's delve deeper into the key concepts and techniques related to constants in Java:

    • Declaration: Constants are declared using the final keyword followed by the data type and the variable name.
    • Initialization: Constants must be initialized at the time of declaration. If not, the compiler will throw an error.
    • Immutability: Once a constant is initialized, its value cannot be changed. Any attempt to reassign a constant will result in a compilation error.

    Here is an example demonstrating these concepts:

    final double PI = 3.14159;
System.out.println(PI); // Output: 3.14159

// Attempting to reassign PI will cause an error
// PI = 3.14; // Error: cannot assign a value to final variable PI

    Examples and Use Cases

    Constants are widely used in various contexts. Here are a few examples:

    final int DAYS_IN_WEEK = 7;
final String COMPANY_NAME = "TechCorp";
final double GRAVITY = 9.81;

    In these examples, the constants represent values that are universally accepted and should not change, such as the number of days in a week, the name of a company, and the gravitational constant.

    Common Pitfalls and Best Practices

    When working with constants, it's important to avoid common mistakes and follow best practices:

    • Avoid Reassignment: Do not attempt to reassign a constant after it has been initialized.
    • Use Descriptive Names: Use meaningful and descriptive names for constants to improve code readability.
    • Group Related Constants: Group related constants together, possibly in a separate class or interface, to keep your code organized.

    Advanced Techniques

    In addition to basic constants, Java allows you to create constant expressions and use constants in more advanced scenarios:

    final int BASE_SALARY = 50000;
final int BONUS = 10000;
final int TOTAL_COMPENSATION = BASE_SALARY + BONUS;
System.out.println(TOTAL_COMPENSATION); // Output: 60000

    In this example, TOTAL_COMPENSATION is a constant expression that combines other constants.

    Code Implementation

    Here is a complete example demonstrating the use of constants in a real-world scenario:

    public class CompanyInfo {
    public static final String COMPANY_NAME = "TechCorp";
    public static final String FOUNDING_DATE = "January 1st, 2000";
    public static final String FOUNDER_NAME = "Jane Doe";

    public static void main(String[] args) {
        System.out.println("Company Name: " + COMPANY_NAME);
        System.out.println("Founding Date: " + FOUNDING_DATE);
        System.out.println("Founder Name: " + FOUNDER_NAME);
    }
}

    This code defines a class CompanyInfo with three constants representing the company's name, founding date, and founder's name. The main method prints these values to the console.

    Debugging and Testing

    When working with constants, debugging is usually straightforward since their values do not change. However, it's important to ensure that constants are correctly initialized and used. Here are some tips:

    • Check Initialization: Ensure that all constants are properly initialized at the time of declaration.
    • Write Tests: Write unit tests to verify that constants are used correctly in your code.

    Here is an example of a simple test case:

    import static org.junit.Assert.*;
import org.junit.Test;

public class CompanyInfoTest {
    @Test
    public void testCompanyName() {
        assertEquals("TechCorp", CompanyInfo.COMPANY_NAME);
    }
}

    Thinking and Problem-Solving Tips

    When dealing with constants, consider the following strategies:

    • Identify Invariants: Identify values in your code that should remain constant and declare them as constants.
    • Use Constants for Configuration: Use constants for configuration values that should not change during runtime.
    • Refactor Magic Numbers: Replace magic numbers and hard-coded strings with constants to improve code readability and maintainability.

    Conclusion

    In this lesson, we covered the concept of constants in Java, their significance, and how to use them effectively. Constants help ensure the integrity and reliability of your code by preventing unintended modifications. By understanding and applying the concepts discussed, you can write more robust and maintainable code.

    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