There are some protocols that when followed differentiate a good program from a mediocre program. Here are some tips that will help you become good Java programmers:
Object creation in Java is one of the most expensive operation in terms of memory utilization and performance impact. It is thus advisable to create or initialize an object only when it is required in the code.
Making a class field public can cause lot of issues in a program. For instance you may have a class called MyCalender. This class contains an array of String weekdays. You may have assume that this array will always contain 7 names of weekdays. But as this array is public, it may be accessed by anyone. Someone by mistake also may change the value and insert a bug!
But writing getter method does not exactly solve our problem. The array is still accessible. Best way to make it unmodifiable is to return a clone of array instead of array itself. Thus the getter method will be changed to.
}
Making a class immutable is to make it unmodifiable. The information the class preserve will stay as it is through out the lifetime of the class. Immutable classes are simple, they are easy to manage. They are thread safe. They make great building blocks for other objects.
{
{
First you can not inherit multiple classes in Java but you can definitely implements multiple interfaces. It’s very easy to change the implementation of an existing class and add implementation of one more interface rather then changing full hierarchy of class.
Local variables are great. But sometimes we may insert some bugs due to copy paste of old code. Minimizing the scope of a local variable makes code more readable, less error prone and also improves the maintainability of the code.
Writing code is fun. But “do not reinvent the wheel”. It is very advisable to use an existing standard library which is already tested, debugged and used by others. This not only improves the efficiency of programmer but also reduces chances of adding new bugs in your code. Also using a standard library makes code readable and maintainable.
Wrapper classes are great. But at same time they are slow. Primitive types are just values, whereas Wrapper classes are stores information about complete class.
The first sop will print true whereas the second one will print false. The problem is when comparing two wrapper class objects we can’t use == operator. It will compare the reference of object and not its actual value.
{
Always carefully use Strings in your code. A simple concatenation of strings can reduce performance of program. For example if we concatenate strings using + operator in a for loop then everytime + is used, it creates a new String object. This will affect both memory usage and performance time.
String fast =
Whenever your method is returning a collection element or an array, always make sure you return empty array/collection and not null. This will save a lot of if else testing for null elements. For instance in below example we have a getter method that returns employee name. If the name is null it simply return blank string “”.
{
}
Defensive copies are the clone objects created to avoid mutation of an object. For example in below code we have defined a Student class which has a private field birth date that is initialized when the object is constructed.
Now we may have some other code that uses the Student object.
In above code we just created a Student object with some default birthdate. But then we changed the value of year of the birthdate. Thus when we print the birth date, its year was changed to 2019!
This ensures we have another copy of birthdate that we use in Student class.
Here are two bonus Java best practice Tips for you.
Finally blocks should never have code that throws exception. Always make sure finally clause does not throw exception. If you have some code in finally block that does throw exception, then log the exception properly and never let it come out :)
Never throw java.lang.Exception directly. It defeats the purpose of using checked Exceptions. Also there is no useful information getting conveyed in caller method.
Tip 1: Avoid creating unnecessary objects and always prefer to do Lazy Initialization
Object creation in Java is one of the most expensive operation in terms of memory utilization and performance impact. It is thus advisable to create or initialize an object only when it is required in the code.
public class Countries { private List
countries; public List
getCountries()
{
//initialize
only when required if(null ==
countries)
{
countries = new ArrayList();
} return countries;
}
}
Tip 2: Never make an instance fields of class public
Making a class field public can cause lot of issues in a program. For instance you may have a class called MyCalender. This class contains an array of String weekdays. You may have assume that this array will always contain 7 names of weekdays. But as this array is public, it may be accessed by anyone. Someone by mistake also may change the value and insert a bug!
public class MyCalender
{
public String[]
weekdays = {"Sun",
"Mon",
"Tue",
"Thu",
"Fri",
"Sat",
"Sun"};
//some
code }
Best
approach as many of you already know is to always make the field private and
add a getter method to access the elements.
private String[] weekdays = {"Sun",
"Mon",
"Tue",
"Thu",
"Fri",
"Sat",
"Sun"};
public String[] getWeekdays()
{
return weekdays;
}
But writing getter method does not exactly solve our problem. The array is still accessible. Best way to make it unmodifiable is to return a clone of array instead of array itself. Thus the getter method will be changed to.
public String[]
getWeekdays()
{
return weekdays.clone(); }
Tip 3: Always try to minimize Mutability of a class
Making a class immutable is to make it unmodifiable. The information the class preserve will stay as it is through out the lifetime of the class. Immutable classes are simple, they are easy to manage. They are thread safe. They make great building blocks for other objects.
However
creating immutable objects can hit performance of an app. So always choose
wisely if you want your class to be immutable or not. Always try to make a
small class with fewer fields immutable.
To
make a class immutable you can define its all constructors private and then
create a public static method
to initialize and object and return it.
to initialize and object and return it.
public class Employee
{
private String
firstName; private String
lastName; //private
default constructor private Employee(String
firstName, String lastName) {
this.firstName = firstName; this.lastName = lastName; } public static Employee
valueOf (String firstName, String lastName) {
return new Employee(firstName,
lastName); }
}
Tip 4: Try to prefer Interfaces instead of Abstract classes
First you can not inherit multiple classes in Java but you can definitely implements multiple interfaces. It’s very easy to change the implementation of an existing class and add implementation of one more interface rather then changing full hierarchy of class.
Again
if you are 100% sure what methods an interface will have, then only start
coding that interface. As it is very difficult to add a new method in an
existing interface without breaking the code that has already implemented it.
On contrary a new method can be easily added in Abstract class without breaking
existing functionality.
Tip 5: Always try to limit the scope of Local variable
Local variables are great. But sometimes we may insert some bugs due to copy paste of old code. Minimizing the scope of a local variable makes code more readable, less error prone and also improves the maintainability of the code.
Thus,
declare a variable only when needed just before its use.
Always
initialize a local variable upon its declaration. If not possible at least make
the local instance assigned
null value.Tip 6: Try to use standard library instead of writing your own from scratch
Writing code is fun. But “do not reinvent the wheel”. It is very advisable to use an existing standard library which is already tested, debugged and used by others. This not only improves the efficiency of programmer but also reduces chances of adding new bugs in your code. Also using a standard library makes code readable and maintainable.
For
instance Google has just released a new library Google Collections that can be
used if you want to add advance collection functionality in your code.
Tip 7: Wherever possible try to use Primitive types instead of Wrapper classes
Wrapper classes are great. But at same time they are slow. Primitive types are just values, whereas Wrapper classes are stores information about complete class.
Sometimes
a programmer may add bug in the code by using wrapper due to oversight. For example,
in below example:
int x
= 10;
int y
= 10;
Integer
x1 =
new Integer(10);
Integer
y1 =
new Integer(10);
System.out.println(x
== y);
System.out.println(x1 == y1);
The first sop will print true whereas the second one will print false. The problem is when comparing two wrapper class objects we can’t use == operator. It will compare the reference of object and not its actual value.
Also
if you are using a wrapper class object then never forget to initialize it to a
default value. As by default all wrapper class objects are initialized to
null.
Boolean
flag;
if(flag == true) {
System.out.println("Flag
is set");
}
{
else {
System.out.println("Flag
is not set");
}
The
above code will give a
NullPointerException as it tries to box the values
before comparing with true and as its null.Tip 8: Use Strings with utmost care
Always carefully use Strings in your code. A simple concatenation of strings can reduce performance of program. For example if we concatenate strings using + operator in a for loop then everytime + is used, it creates a new String object. This will affect both memory usage and performance time.
Also
whenever you want to instantiate a String object, never use its constructor but
always instantiate it directly. For example:
//slow instantiation
String
slow =
new String("Yet another string
object"); //fast instantiation String fast =
"Yet another string object";Tip 9: Always return empty Collections and Arrays instead of null
Whenever your method is returning a collection element or an array, always make sure you return empty array/collection and not null. This will save a lot of if else testing for null elements. For instance in below example we have a getter method that returns employee name. If the name is null it simply return blank string “”.
public String
getEmployeeName() {
return (null==employeeName
? "":
employeeName); }
Tip 10: Defensive copies are savior
Defensive copies are the clone objects created to avoid mutation of an object. For example in below code we have defined a Student class which has a private field birth date that is initialized when the object is constructed.
public class Student
{
private Date
birthDate; public Student(birthDate)
{ this.birthDate = birthDate; } public Date
getBirthDate() { return this.birthDate; }
}
Now we may have some other code that uses the Student object.
public static void main(String
[]arg) { Date birthDate = new Date();
Student student = new Student(birthDate);
birthDate.setYear(2019);
System.out.println(student.getBirthDate());
}
In above code we just created a Student object with some default birthdate. But then we changed the value of year of the birthdate. Thus when we print the birth date, its year was changed to 2019!
To
avoid such cases, we can use Defensive copies mechanism. Change the constructor
of Student class to following.
public Student(birthDate)
{
this.birthDate = new Date(birthDate);
}
This ensures we have another copy of birthdate that we use in Student class.
Two bonus Tips
Here are two bonus Java best practice Tips for you.
Tip 11: Never let exception come out of finally block
Finally blocks should never have code that throws exception. Always make sure finally clause does not throw exception. If you have some code in finally block that does throw exception, then log the exception properly and never let it come out :)
Tip 12: Never throw “Exception”
Never throw java.lang.Exception directly. It defeats the purpose of using checked Exceptions. Also there is no useful information getting conveyed in caller method.
No comments:
Post a Comment