Best coding practices in Java

Introduction

Writing error free code seems more than enough but that’s not the case. A code must be written following set of guidelines and coding standards. Code quality can be improved drastically by applying java coding best practices. This will make code more understandable, reusable and maintainable. Implicit effect of using best coding practices sometimes even increase code performance and efficiency

Importance of writing clean java code

• Maintainability – Clean code is easy to modify and update.

• Debugging – Clean code is less prone to errors. It is also easier to isolate and fix issues within the code.

• Scalability – Clean code is modular, reusable, and accommodative of future changes

• Collaboration – Clean code allows teammates to understand each other’s code.

• Documentation – Clan code is self-explanatory and reduces the need for excessive comments.

• Efficiency – Clean code removes code duplication and unnecessary complexity, which improves performance.

• Readability – Clean code is easy to read, reduces confusion, and improves maintainability

Here are some of best coding practices we can follow:

Use of standard project structure

Project structure outlines how to arrange various components in your project, such as Java source files, test files, documentation files, build files, and configuration files. A clear project structure makes it easy to understand, navigate and modify a project codebase. On the other hand, a poor project structure can cause confusion, especially when working with projects with many files. Although Java doesn’t enforce a specific project structure, build tools such as Maven suggests a project structure you can follow.

Class members access should be private

To maintain encapsulation principle, it is considered best practice to keep accessibility of class members as inaccessible as possible.

This can be achieved using private access modifier with class members. Even though this is basic concept of OOP, many developers still do not assign access modifier to the classes and prefer to keep it public for their ease.

Below is example of employee class having name and Id as private members variables can be accessed only using object of Employee class.

Naming conventions

If proper naming convention is not decided or agreed upon at the start of project things can get very clumsy very fast especially considering there are multiple developers working on the project.

• Package Name

• Class Names

• Methods Names

• Variables Names 

• Constant variables

Avoid hard coding values

Hardcoding refers to embedding values directly into yoursource code instead of using variables. Altering the source code of your program is the only way to change values hardcoded into your programs. Hardcoded values limit reusability and testability and can also lead to duplication and undesired behavior from your program.

To improve code reusability, testability, and maintainability, which are key features of clean Java code, it is important that you avoid hard coding values in your program source code. Instead, replace hard-coded values with abstractions such as constant variables or enums.

Use underscore in lengthy numeric values

This feature is introduced in java 7 helping writing lengthy numeric values in more readable way.

Restrict number of method parameters

Parameters are necessary when working with methods. However, care should be taken to avoid using too many parameters in one method. Too many parameters may indicate that your method is addressing more than one concern and violates the single responsibility principle.

Too many method parameters make your code less readable since keeping track of their types and meanings is difficult. To write clean Java code, you should: limit the number of method parameters and use objects or data structures instead of individual parameters or group-related parameters into objects.

Here is an example of a Java method with too many method parameters

Here is how we can refactor the code above by grouping related parameters into an object to improve readability.

Never leave catch block empty

It is best practice in java programming to write proper and meaningful message in the catch block while writing exception handling.  Fresh developers often leave catch block empty as they are only ones working on the code but when exception is caught by empty catch block, program output doesn’t show anything.

Use StringBuilder or StringBuffer for string concatenation

Using “+” operator to join strings together is a common practice in many programming languages including java.  This is common practice used by most of developers and it’s not wrong. However when you need to concatenate several strings using “+” operator becomes inefficient as Java compiler creates multiple intermediate String objects before creating final concatenated string

Best practice in such cases would be to use StringBuilder or StringBuffer build in functions. These functions modify string without creating intermediate String objects saving processing time and unnecessary memory usage.

// instead of “+” operator to concatenate string objects

// Use string builder as below

Avoid re-initialization of member variables

Most of developers initialize member variables in the class with values such as 0, null or false etc. In java, member variables already have default initialized values, hence it is advised to be aware of default values assigned to member variables and avoid reinitializing the values again explicitly.

In below example, class member variables string, float and integer variable has default values in the class and no need to initialize them again

Use enhanced for loops

Using count variable in for loop is common practice followed by developers in many languages like C, C++, Java to name few.  Experienced java developers uses enhanced for loop instead of old fashioned count based for loop mainly count based for loop is error prone. Especially counter variable can get altered accidentally or it may be used later in different context.

To eliminate such error prone situations, using enhanced for loop is highly recommended.

Below snippet shows for loop using count variable

Using enhanced for loop to avoid count variable error

Null pointer handling exceptions

Null pointer exceptions are very common errors in java programming. This exception occurs when program attempts to call a method on null object reference.

In below example, if empList or empObj is null, then empObj.listEmployees().count call will throw null pointer exception

Null pointer exception can be handled as below:

Single and double quotes in string concatenation

We all know single quote represent character variable and double quote represent string variable. Sometimes while performing concatenation, it is common mistake that single quoted character concatenated by their integer values and not as character itself.

To avoid above mistake, always use double quotes while performing concatenation.

Code comments

It is highly recommended to add comments in the code. Comments provide additional information in understanding the code and can be used to generate java documentation using Javadoc plugin.

Code comments are delimited by //.  Java allows multiple line comment surrounded by /* */ mainly used for writing code logic information as notes in the code.

Static code analysis

Static analysis tools allow you to inspect your application source code and ensure adherence to coding standards, spot vulnerabilities, and detect bugs during development.

Conclusion

Writing clean Java code is key to developing high-quality software.

In this blog, I have shared some of the best and most common practices that can help developers to write clean Java code. However, it is important to note that this isn’t a definitive list of what it takes to write clean Java code. Other key factors that contribute to writing clean Java code include tools available, and goals of the team you’re working with. You can write readable, testable, extensible, and modular code by embracing these principles.