Java Finest Practices |

Spread the love

In laptop programming, greatest practices are a set of casual guidelines that many builders observe to enhance software program high quality, readability, and maintainability. Finest practices are particularly helpful the place an software stays in use for lengthy intervals of time, in order that it was initially developed by one staff after which subsequently maintained by a distinct group of individuals.

The Working with Java Variables article offered numerous greatest practices for variable naming. This collection will now go a lot additional and canopy such subjects as class member scoping, strive/catch blocks, and even the formatting of fixed values. This tutorial will present an summary of the most effective practices for Java that we are going to be exploring over the following a number of weeks, together with an evidence of every entry in our high greatest practices for Java programming record.

Java Programming Finest Practices at a Look

Though the whole record of Java Finest Practices could be a prolonged one, there are a number of that are thought-about to be a superb beginning place for coders who’re taking their first steps into bettering their code high quality, together with utilizing correct naming conventions, make class members non-public, avoiding using empty catch blocks, avoiding reminiscence leaks, and correctly commenting code blocks:

  • Use Correct Naming Conventions
  • Class Members Must be Personal
  • Use Underscores in prolonged Numeric Literals
  • Keep away from empty catch Blocks
  • Use StringBuilder or StringBuffer for String Concatenation
  • Keep away from Redundant Initializations
  • Utilizing enhanced for loops as a substitute of for loops with a counter
  • Correct dealing with of Null Pointer Exceptions
  • Float or Double: which is the appropriate alternative?
  • Use of single quotes and double quotes
  • Avoiding Reminiscence leaks
  • Return Empty Collections as a substitute of returning Null parts
  • Environment friendly use of Strings
  • Pointless Objects Creation
  • Correct Commenting

Class Members in Java Must be Personal

In Java, the extra inaccessible the members of a category are, the higher! Step one is to make use of the non-public entry modifier. The aim is to foster ideally suited encapsulation, which is among the basic ideas of object-oriented programming (OOP). All-too-often, new builders fail to correctly assign entry modifiers to the courses or desire to maintain them public to make issues simpler.

Take into account this class the place fields are made public:

public class BandMember {
  public String title;
  public String instrument;

Class encapsulation is compromised right here as anybody can change these values instantly like so:

BandMember billy = new BandMember();
billy.title = "George";
billy.instrument = "drums";

Utilizing non-public entry modifier with class members retains the fields hidden stopping a consumer from altering the information besides by way of setter strategies:

public class BandMember {
  non-public String title;
  non-public String instrument;
  public void setName(String title) {
    this.title = title;
  public void setInstrument(String instrument)
    this.instrument = instrument;

Setters are additionally the perfect place to place validation code and/or housekeeping duties corresponding to incrementing a counter.

You’ll be able to study extra about entry modifiers in our tutorial: Overview of Java Modifiers.

We even have a fantastic tutorial overlaying the idea of Java Encapsulation in case you want a refresher.

Use Underscores in Prolonged Numeric Literals

Because of a Java 7 replace, builders can now write prolonged numeric literals which have elevated readability by together with underscores (_). Listed below are some prolonged numeric literals earlier than underscores had been permitted:

int minUploadSize = 05437326;
lengthy debitBalance = 5000000000000000L;
float pi = 3.141592653589F;

I believe you’ll agree that underscores make the values extra readable:

int minUploadSize = 05_437_326;
lengthy debitBalance = 5_000_000_000_000_000L;
float pi = 3.141_592_653_589F;

Keep away from Empty Catch Blocks

It’s a very dangerous behavior to go away catch blocks empty, for 2 causes: it will possibly both trigger this system to silently fail, or proceed alongside as if nothing occurred. Each of those outcomes could make debugging considerably tougher.

Take into account the next program which calculates sum of two numbers from command-line arguments:

public class Sum {
  public static void fundamental(String[] args) {
    int a = 0;
    int b = 0;
    strive {
      a = Integer.parseInt(args[0]);
      b = Integer.parseInt(args[1]);
    } catch (NumberFormatException ex) {
    int sum = a + b;
    System.out.println(a + " + " + b + " = " + sum);

Java’s parseInt() methodology throws a NumberFormatException, requiring the developer to encompass its invocation inside a strive/catch block. Sadly, this specific developer selected to disregard thrown exceptions! Because of this, passing in an invalid argument, corresponding to “45y” will trigger the related variable to be populated with the default for its kind, which is 0 for an int:

Java Sum Class Error

Usually, when catching an exception, programmers ought to take a number of of the next three actions:

  1. On the very least, inform the consumer concerning the exception, both get them to re-enter the invalid worth or allow them to know that this system should abort prematurely.
  2. Log the exception utilizing JDK Logging or Log4J.
  3. Wrap and re-throw the exception as a brand new, extra application-specific, exception.

Right here is our Sum software rewritten to tell the consumer that an enter was invalid and that this system might be aborting because of this:

public class Sum {
  public static void fundamental(String[] args) {
    int a = 0;
    int b = 0;
    strive {
      a = Integer.parseInt(args[0]);
    } catch (NumberFormatException ex) {
      System.out.println(args[0] + " just isn't a quantity. Aborting...");
    strive {
      b = Integer.parseInt(args[1]);
    } catch (NumberFormatException ex) {
      System.out.println(args[1] + " just isn't a quantity. Aborting...");
    int sum = a + b;
    System.out.println(a + " + " + b + " = " + sum);

We will observe the outcomes beneath:

Java error handling

Use StringBuilder or StringBuffer for String Concatenation

The “+” operator is a fast and simple option to mix Strings in Java. Earlier than the times of Hibernate and JPA, objects had been continued manually, by constructing an SQL INSERT assertion from the bottom up! Right here is one which shops some consumer information:

String sql = "Insert Into Customers (title, age)";
       sql += " values ('" + consumer.getName();
       sql += "', '" + consumer.getage();
       sql += "')";

Sadly, when concatenating quite a few strings as above, the the Java compiler has to create a number of intermediate String objects earlier than amalgamating these into the ultimate concatenated string.

As an alternative, we needs to be utilizing both the StringBuilder or StringBuffer class. Each embody capabilities to concatenate strings with out having to creating intermediate String objects, subsequently saving processing time and pointless reminiscence utilization.

The earlier code could possibly be rewritten utilizing StringBuilder as follows:

StringBuilder sqlSb = new StringBuilder("Insert Into Customers (title, age)");
sqlSb.append(" values ('").append(consumer.getName());
sqlSb.append("', '").append(consumer.getage());
String sqlSb = sqlSb.toString();

It is a little more work on the developer’s half, however effectively price it!

StringBuffer vs StringBuilder

Whereas each the StringBuffer and StringBuilder courses are preferable to the “+” operator, each usually are not created equally. The StringBuilder is the sooner of the 2, however just isn’t thread-safe. So, for String manipulations in a non-multi threaded atmosphere, we must always use StringBuilder; in any other case use the StringBuffer class.

Keep away from Redundant Initializations

Though sure languages like TypeScript strongly encourage you to initialize your variables at declaration time, this isn’t all the time crucial in Java, because it assigns default initialization values – like 0, false and null – to variables upon declaration.

Subsequently, a java greatest apply is to concentrate on the default initialization values of member variables whereas not initializing your variables explicitly until you’d prefer to set them to values aside from the defaults.

Here’s a quick program that calculates the sum of pure numbers from 1 to 1000. Discover that solely a few of the variables are initialized:

class VariableInitializationExample {
  public static void fundamental(String[] args) {
    // robotically set to 0
    int sum; 
    last numberOfIterations = 1000;

    // Set the loop counter to 1
    for (int i = 1; i &= numberOfIterations; ++i) {
      sum += i;
    System.out.println("Sum = " + sum);

Utilizing Enhanced For Loops As an alternative of For Loops with a Counter

Though for loops definitely have their place, there isn’t any query that the counter variable could be a supply of errors. For example, the counter variable can by the way get altered, earlier than is is used later within the code. Even beginning the index from 1 as a substitute of 0 may end up in sudden conduct. For these causes, the for-each loop (additionally known as an enhanced for loop) could also be a greater possibility.

Take into account the next code:

String[] names = {"Rob", "John", "George", "Steve"}; 
for (int i = 0; i < names.size; i++) {

Right here, variable i is performing double responsibility as a counter for a loop in addition to the index for the array names. Though this loop solely prints out every title it might turn into problematic if there have been code additional down the road that changed i. We will simply sidestep the entire problem by utilizing a for-each loop just like the one proven beneath:

for (String title : names) {

Far much less probability of errors there!

Correct dealing with of Null Pointer Exceptions

Null Pointer Exceptions are a surprisingly frequent incidence in Java, doubtless on account of its Object-Oriented design. Null Pointer Exceptions happen everytime you try to invoke a technique on a Null Object Reference. This often occurs once you name an occasion methodology earlier than the category has been instanciated, corresponding to within the case beneath:

Workplace workplace;

// later within the code...
Worker[] staff = workplace.getEmployees();

When you can by no means fully get rid of Null Pointer Exceptions, there are methods to mimimize them. One strategy is to verify for Null objects previous to invoking considered one of its strategies. Right here’s an instance that makes use of the ternary operator:

Workplace workplace;

// later within the code...
Worker[] staff = workplace == null ? 0 : workplace.getEmployees();

You may also wish to throw your individual Exception:

Workplace workplace;
Worker[] staff;

// later within the code...
if (workplace == null) {
  throw new CustomApplicationException("Workplace cannot be null!");
} else { 
  staff = workplace.getEmployees();

Float or Double: Which to Use?

Floats and doubles are related sorts, so it’s no shock that many builders are uncertain of which to go along with. Each cope with floating-point numbers, however possess very totally different options. For instance, float has a measurement of 32 bits whereas double is allotted twice as a lot reminiscence at 64 bits. Therefore, double can deal with a lot larger fractional numbers than float. Then there’s the problem of precision: float solely accommodate 7 bits of precision. Having a particularly small exponent measurement means a few of the bits are inevitable misplaced. Examine that to the double, which allocates a far larger variety of bits for the exponent, permitting it to deal with as much as 15 bits of precision.

Subsequently, float is usually advisable when pace is extra necessary than accuracy. Whereas most applications don’t contain massive computations, the distinction in precision can turns into fairly vital in math-intensive purposes. Float can be a good selection when the variety of decimal digits required is understood prematurely. When precision is very necessary, double needs to be your go-to. Simply take into account that Java enforces using double because the default information kind for coping with floating-point numbers so it’s possible you’ll wish to append the letter “f” to explicitly denote the float, e.g., 1.2f.

Use of Single Quotes and Double Quotes in Concatenation

In Java, double quotes (“) are used to carry strings and single quotes are for characters (represented by the char kind). Issues can happen once we attempt to concatenate characters collectively utilizing the + concatenation operator. The issue is that concatenating chars utilizing + converts the worth of the char into ascii and therefore yields a numerical output. Right here is a few instance code as an instance this level:

char a, b, c;
b = 'b';

str = a + b + c; // not "abc", however 294!

Simply as string concatenation is greatest completed utilizing both the StringBuilder or StringBuffer class, so too with characters! Within the above code, the a, b and c variables could also be mixed as a string as follows:

new StringBuilder().append(a).append(b).append(c).toString()

We will observe the specified outcomes beneath:

Java char Concatenation


Avoiding Reminiscence Leaks in Java

In Java, builders shouldn’t have a lot management over reminiscence administration, as Java takes care of that robotically by way of the method of rubbish assortment. Having stated that, there are some Java greatest practices that builders can make use of to assist forestall reminiscence leaks, corresponding to:

  • Attempt to not create pointless objects.
  • Don’t use the + operator for String Concatenation.
  • Don’t retailer an enormous quantity of information within the session.
  • Trip the session when not getting used.
  • Keep away from using static objects as a result of they dwell for the complete lifetime of the appliance.
  • When working with a database, don’t overlook to shut the ResultSet, Statements, and Connection objects within the lastly block.

Return Empty Collections as a substitute of the Null Reference

Do you know that the null reference is also known as the worst mistake in software program improvement? The null reference was invented in 1965 by Tony Hoare when he was designing the primary complete kind system for references in Object Oriented Language (OOP). Later, at a convention in 2009, Hoare apologized for inventing it, admitting that his creation “has led to innumerable errors, vulnerabilities, and system crashes, which have in all probability brought on a billion {dollars} of ache and harm within the final forty years.”

It’s a Java greatest apply to return empty values relatively than nulls typically, however it’s particularly necessary once you return a group, enumerable, or an object. Though your individual code could deal with the returned null worth, different builders could overlook to put in writing a null verify and even understand that null is a attainable return worth!

Right here is a few Java code that fetches an inventory of books in inventory as an ArrayList. Nonetheless, if the record is empty, an empty record is returned as a substitute:

non-public last Checklist<E-book> booksInStock = ...

public Checklist<E-book> getInStockBooks() {
  return booksInStock.isEmpty() ? Collections.emptyList() : new ArrayList<>(booksInStock);

That permits callers of the strategy to iterate over the record with out first having to verify for a null reference:

(E-book ebook: getInStockBooks()) {
  // do one thing with books

Environment friendly use of Strings in Java

We now have already talked concerning the uncomfortable side effects with using the + concatenation operator, however there are different issues we are able to do to make the most of strings extra effectively in order to not waste reminiscence and processor cycles. For instance, when instantiating a String object, it’s thought-about a Java greatest apply to create the String instantly relatively than use the constructor. The rationale? It’s method sooner to create the String instantly in comparison with utilizing a constructor (to not point out much less code!).

Listed below are two equal methods of making a String in Java; instantly vs. utilizing a constructor:

// instantly
String str = "abc";
// utilizing a constructor
char information[] = {'a', 'b', 'c'};
String str = new String(information);

Whereas each are equal, the direct strategy is the higher one.

Pointless Object Creation in Java

Do you know that object creation is among the most reminiscence consuming operations in Java? For that cause, it’s best to keep away from creating objects for no good cause and solely achieve this when completely required.

So how would one go about placing that into apply? Mockingly, creating Strings instantly as we noticed above is one option to keep away from creating objects unnecessarily!

Here’s a extra advanced instance:

The next Individual class consists of an isBabyBoomer() methodology that tells whether or not the individual falls into the “child boomer” age group and was born between 1946 and 1964:

public class Individual {
  non-public last Date birthDate;
  public boolean isBabyBoomer() {
    // Pointless allocation of pricy object!
    Calendar gmtCal =
    gmtCal.set(1946, Calendar.JANUARY, 1, 0, 0, 0);
    Date boomStart = gmtCal.getTime();
    gmtCal.set(1965, Calendar.JANUARY, 1, 0, 0, 0);
    Date boomEnd = gmtCal.getTime();
    return birthDate.compareTo(boomStart) >= 0 &&
           birthDate.compareTo(boomEnd)   <  0;

The isBabyBoomer() methodology unnecessarily creates a brand new Calendar, TimeZone, and two Date situations every time it’s invoked. One option to rectify this inefficiency is to make use of a static initializer in order that the Calendar, TimeZone, and Date objects are created solely as soon as, upon initialization, relatively than each time isBabyBoomer() is invoked:

class Individual {
  non-public last Date birthDate;
  // The beginning and ending dates of the infant growth.
  non-public static last Date BOOM_START;
  non-public static last Date BOOM_END;
  static {
    Calendar gmtCal =
    gmtCal.set(1946, Calendar.JANUARY, 1, 0, 0, 0);
    BOOM_START = gmtCal.getTime();
    gmtCal.set(1965, Calendar.JANUARY, 1, 0, 0, 0);
    BOOM_END = gmtCal.getTime();
  public boolean isBabyBoomer() {
    return birthDate.compareTo(BOOM_START) >= 0 &&
       birthDate.compareTo(BOOM_END)       <  0;

Correct Commenting in Java

Clear and concise feedback could be a actual life saver when making an attempt to decipher one other developer’s code. Listed below are a couple of tips for writing high quality feedback*:

  1. Feedback shouldn’t duplicate the code.
  2. Good feedback don’t excuse unclear code.
  3. In case you can’t write a transparent remark, there could also be an issue with the code.
  4. Clarify unidiomatic code in feedback.
  5. Embody hyperlinks to exterior references the place they are going to be most useful.
  6. Add feedback when fixing bugs.
  7. Use feedback to mark incomplete implementations. (these will often begin with the tag “TODO:”)

Ultimate Ideas on Java Finest Practices

On this installment of the Java Finest Practices collection, we realized concerning the high 15 Java greatest practices and explored class member encapsulation, using underscores in prolonged numeric literals, avoiding empty catch blocks, String concatenation performed proper, tips on how to keep away from redundant initializations, in addition to utilizing enhanced for loops.

Learn: Prime On-line Java Coaching Programs and Bundles

Leave a Reply

Your email address will not be published. Required fields are marked *