Builder design pattern in Java
Source: Medium In this article, we will learn how to design and create objects for a class using the Builder design pattern .
Why do we need the Builder design pattern?
The Builder pattern is designed to create objects using a nested public static class that has the same data fields as the outer class. The Builder pattern was created to solve the problems that the Factory and Abstract Factory design patterns had when a class object contains many field values and/or data. Before we move on to the Builder pattern , let's see what exactly the problems are with the Factory and Abstract Factory patterns for scenarios where an object has many field values:-
Having too many arguments to pass from the client program to the Factory class can lead to errors because in most cases the type of the arguments is the same and it is difficult for the client to maintain the order of the arguments.
-
Some parameters may be optional, but in the Factory pattern we are forced to send all parameters, and optional parameters must be sent as NULL files .
-
If the object is “heavy” and complex to design, then all these difficulties will become part of the Factory classes, which often leads to confusion.
What is the Builder Design Pattern?
The Builder pattern solves the problem with lots of optional parameters and inconsistent states by providing a way to incrementally create an object. For this, a method is used that actually returns the final object.
How to implement the Builder design pattern in Java?
If we follow the steps below, we get a step-by-step process of creating an object and getting it:-
Create a static nested class as a Builder class and then copy all the fields from the outer class to the Builder class . We must follow the naming convention, so if the class name is Person , then the Builder class must be named PersonBuilder .
-
The Builder class must have a public constructor with all required fields as parameters.
-
The Builder class must have methods for setting optional parameters, and it must return the same Builder object after setting the optional field.
-
The final step is to provide a build() method on the Builder class that will return the object needed by the client program. To do this, we need to have a private constructor in the main class with the Builder class as an argument.
Example:
Let's look at an example to get a clear idea of the Builder design pattern .public class Employee {
private String name;
private String company;
private boolean hasCar;//optional
private boolean hasBike;//optional
private Employee(EmployeeBuilder employeeBuilder) {
name = employeeBuilder.name;
company = employeeBuilder.company;
hasCar = employeeBuilder.hasCar;
hasBike = employeeBuilder.hasBike;
}
public String getName() {
return name;
}
public String getCompany() {
return company;
}
public boolean isHasCar() {
return hasCar;
}
public boolean isHasBike() {
return hasBike;
}
public static class EmployeeBuilder {
private String name;
private String company;
private boolean hasCar;//optional
private boolean hasBike;//optional
//constructor for required fields
public EmployeeBuilder(String name, String company) {
this.name = name;
this.company = company;
}
//setter methods for optional fields
public EmployeeBuilder setHasCar(boolean hasCar) {
this.hasCar = hasCar;
return this;
}
public EmployeeBuilder setHasBike(boolean hasBike) {
this.hasBike = hasBike;
return this;
}
//Build the Employee object
public Employee build() {
return new Employee(this);
}
}
}
class TestBuilder {
public static void main(String[] args) {
//Building the object of Employee thru the build() method provided in EmployeeBuilder class.
Employee employee = new Employee.EmployeeBuilder("Vikram", "ABC").setHasBike(false).setHasBike(true).build();
}
}How serialization and deserialization works in Java
Source: Medium I switched to Java in January of this year after an internship. Before that, I mostly wrote in PHP and a little bit in JavaScript. I've never dealt with serialization before, although serialization actually exists in PHP as well. True, in Java it is used much more often. Today I'll walk you through how serialization and deserialization work in Java and show you several ways to use them.What is serialization and deserialization
Serialization is the transformation of an object from a class into a sequence of bytes in the Java Virtual Machine (JVM) for transmission to another Java Virtual Machine. If the Java Virtual Machine recreates an object from bytes, then this process is called deserialization.Serialization and Deserialization Example
Serialization
Let's create a class whose object will be serialized:import java.io.*;
public class Person implements Serializable{
int id = 0;
String name = "empty";
public Person(int identity, String nomenclature) {
name = nomenclature;
id = identity;
}
}public static void main(String[] args) throws FileNotFoundException, IOException {
String filename = "filename here";
Person person = new Person(1, "John");
// serialization
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(filename));
try {
out.writeObject(person);
System.out.println("Success");
} catch(Exception e) {
System.out.println("Unsuccessful");
} finally {
if(out != null) {
out.close();
}
}
}Deserialization
public static void main(String[] args) throws FileNotFoundException, IOException {
String filename = "filename here";
Person person = new Person(1, "John");
// Deserialization
ObjectInputStream in = new ObjectInputStream(new FileInputStream(filename));
try {
Person personObj = (Person)in.readObject();
System.out.println("Person Id is " +personObj.id + " while name is " + personObj.name);
} catch (Exception e) {
e.printStackTrace();
} finally {
if(in != null) {
in.close();
}
}
}
GO TO FULL VERSION