In Java, how do you typically define a constant variable so that its value cannot be changed after initialisation?

Introduction / Context:
In Java, constants are values that should not change once they are set. Common examples include mathematical constants, configuration flags, or fixed limits. Although Java does not have a dedicated const keyword that works like in some other languages, it provides a mechanism to prevent reassignment through the final keyword. Interviewers often ask how to declare constants to see whether you know the idiomatic Java style for defining unchangeable values.

Given Data / Assumptions:

• The language is Java.
• We want to declare a variable whose value must not change after it is assigned.
• We are concerned with compile time prevention of reassignment, not runtime checks.
• We may also want the constant to be available at the class level to all instances.

Concept / Approach:
Java uses the final keyword to indicate that a variable cannot be reassigned after it has been given a value. When you declare a field or local variable as final, the compiler enforces that it is assigned exactly once and cannot be changed later. For constants that belong to a class rather than an instance, the usual convention is to combine static and final, often with public and uppercase names, for example public static final double PI = 3.14159;. There is no working const keyword in Java; const is reserved but not implemented. Therefore final is the correct and idiomatic way to create constants in Java source code.

Step-by-Step Solution:
Step 1: Recall that final can be applied to variables, methods, and classes, with different effects in each case. Step 2: For variables, final means the variable can be assigned only once and that later assignments will cause a compile time error. Step 3: For a class level constant, apply both static and final, for example static final int MAX_SIZE = 100; so that the value belongs to the class and does not change. Step 4: Recognise that const is a reserved word in Java but is not used; attempting to compile code using const for variables does not declare a constant. Step 5: Choose the option that correctly states that final (often combined with static) is used to define constants.

Verification / Alternative check:
You can verify this by writing a small Java class with a final variable and attempting to reassign it. The compiler will report an error such as cannot assign a value to final variable. In contrast, if you declare a variable without final, reassignment is allowed. When you create public static final fields, IDEs and style guides typically format them in uppercase and treat them as constants. This practice is widely used in the Java standard library itself, further confirming that final and static final are the correct mechanisms for constants.

Why Other Options Are Wrong:
Option Declare the variable with the const keyword, which is reserved in Java for constants: The const keyword is reserved but not implemented; Java does not use it for declaring constants. Option Declare the variable without any access modifier so that it becomes constant by default: Access modifiers affect visibility, not mutability; variables are not constant by default. Option Declare the variable inside the main method only, which automatically makes it constant: The location of a declaration does not automatically enforce constancy; you must still use final to prevent reassignment.

Common Pitfalls:
A common mistake is to forget final when declaring values that should never change, which allows accidental reassignment. Another is to think that making a variable static or private automatically makes it a constant, which it does not. It is also easy to overlook that final prevents reassignment of the variable, but does not necessarily make an object immutable if the variable refers to a mutable object. For exam answers focused on syntax, however, it is enough to state clearly that final (and often static final) is used to define constants in Java.

Final Answer:
In Java, you define a constant by Declaring the variable with the final keyword, often combined with static for class level constants.