Why Java Uses static & final for Constants

In Java, the `static final` combination is used to create constants, rather than using `const` as in some other programming languages. This choice is due to historical reasons and language design principles.

Historical Reasons:
Java was first introduced in the mid-1990s, and at that time, the `const` keyword was already reserved for potential future use. However, it was never implemented as a keyword for creating constants in Java.
The decision to use `static final` for constants might have been influenced by the syntax and design choices made during Java's early development.

Immutable Objects:
The `final` keyword in Java indicates that a variable cannot be reassigned after it is initialized. When used in conjunction with `static`, it means that the variable is a class-level constant and not tied to any specific instance of the class.
Java prefers the use of immutable objects for constants, and by using `static final`, you ensure that the value remains constant throughout the program execution.

Clear Visibility and Scope:
Using `static final` makes it clear that a variable is intended to be a constant and is associated with the class rather than an instance of the class.
Constants created with `static final` are usually named using uppercase letters with underscores between words (e.g., `MAX_VALUE`) to distinguish them easily from regular variables.

Here's an example of how constants are typically declared in Java:

public class Constants {
public static final int MAX_VALUE = 100;
public static final String DEFAULT_NAME = "John Doe";
}

In contrast, the `const` keyword has a different meaning in some other programming languages, like C++, where it is used to create variables that are immutable within a local scope.

However, in Java, the `final` keyword serves this purpose, and the decision to not introduce the `const` keyword has been maintained for consistency and backward compatibility.