Excerpt§
Some common Java variable naming styles like all lowercase, underscores, short names and numeric suffixes are not ideal as they violate conventions and reduce code readability.
Variable naming is an important part of writing clean, readable code in any programming language. In Java, there are specific naming conventions and styles that are recommended for variables and other identifiers. Some common styles, however, are not considered good practice as they can reduce code clarity and understandability. In this article, we’ll look at these not-recommended naming styles and why it’s better to follow standard Java conventions.
Introduction§
Variable names in Java should be descriptive and help convey the meaning and purpose of the variable. Styles like camelCase and avoiding underscores are recommended in the standard Java coding conventions. However, you’ll sometimes see variables named with styles like all lowercase, underscores, short abbreviations or numeric suffixes. These styles can cause readability issues though, so should generally be avoided.
Not Recommended Styles§
Here are some variable naming styles that are not recommended in Java:
Starting with Lowercase§
Variable names starting with a lowercase letter go against the standard Java naming conventions. For example:
1int myVar;
2String someVariable;
javaThese should be avoided even though they may seem fine at first glance.
Using Underscores§
While underscores are valid in Java variable names, they are somewhat discouraged as they can reduce readability:
1int my_var;
2String some_variable;
javaThe eye has to pause slightly when reading underscore-separated words.
Short or Abbreviated Names§
Overly short or abbreviated names don’t convey the true meaning of the variable:
1int var1;
2int tmp;
javaThese names require referring to other code or documentation to understand their purpose.
Names with Numeric Suffixes§
Using numeric suffixes like var1, var2, var3 might seem handy but these names areindistinguishable and easily confused:
1String var1;
2String var2;
javaIt’s not clear at a glance what the difference between them is.
Problems with These Styles§
Some issues caused by the above naming styles:
Violate Java naming conventions - This could confuse other Java developers and reduces standardization.
Reduce readability - The names don’t convey clear meaning which impacts understandability.
Increase cognitive load - Trying to decipher ambiguous names takes more mental effort.
Create maintainability issues - Poor names make code harder to maintain and build upon over time.
Recommended Styles§
Instead of the above styles, these are the recommended naming conventions to follow:
camelCase§
The camelCase (or lowerCamelCase) convention capitalizes each word except the first:
1int studentGrade;
2String lastName;
javaConvert text to camelCase online.
Descriptive Names§
Use longer, descriptive names rather than short abbreviations:
1int studentCount;
2int maximumStudents;
javaAim for clarity over brevity.
Advantages of Recommended Styles§
Recommended naming styles like camelCase have several advantages:
Follow Java standard coding conventions - More consistent with other Java code.
Improve readability - The meaning is clearer at first glance.
Reduce cognitive load - Easier to understand without extra mental effort.
Enhance maintainability - Built-in meaning makes code easier to maintain.
Examples of Good and Bad Names§
Here are examples of good and bad variable names:
Good Names
1int studentGrade;
2double totalSales;
javaBad Names
1int Var1;
2int _tmp;
javaYou can use online case conversion tools to check your names match Java conventions.
Conclusion§
Certain variable naming styles like underscore-separated or short abbreviations are not recommended in Java as they violate naming conventions and reduce code clarity. Instead, styles like camelCase and longer descriptive names are preferred. This helps improve readability, maintainability and adherence to coding standards. Following Java’s naming best practices leads to higher quality, more professional code.
