POJO Class in Java

Last Updated on May 31, 2023 by Prepbytes

POJO stands for Plain Old Java Object. It is a term used to describe a Java class that follows simple conventions and does not depend on any specific frameworks or libraries. A POJO typically contains private fields with corresponding getter and setter methods, and it may also include additional methods for behaviour.

POJOs are commonly used to encapsulate data and represent entities in an application. They are often used in frameworks like Java Persistence API (JPA) for mapping database records to Java objects, or in serialization/deserialization processes where objects are converted to and from formats like JSON or XML.

The key characteristic of a POJO is its simplicity and lack of dependencies on specific frameworks or technologies, making it easier to understand, test, and maintain.

Best Practises and POJO Restrictions

Due to the clarity and reusability, it offers in the program, the Java POJO class has grown in popularity over time. They are easier to understand and create since the POJO class does not have stringent naming convention constraints. Since it is not constrained by any Java framework, any Java program can utilize it.

Since POJOs are often straightforward, they don’t rely on additional libraries, interfaces, or annotations. The likelihood that it may be utilized in other project types (web, desktop, console, etc.) is increased because installing packages or importing modules wouldn’t be necessary.

A POJO has getter and setter methods and functions as a pure data structure. For getting and modifying a variable’s value outside the enclosing class, getters and setters are crucial. A getter gets a variable’s value, whereas a setter modifies a variable’s value.

Although there aren’t many limitations in the Java POJO class, there are a few things that shouldn’t be included.

A POJO in Java shouldn’t be:

• Pojo classes shouldn’t override existing classes.
• Predefined interfaces shouldn’t be implemented by a POJO class.
• Predefined annotations shouldn’t be present in a POJO class.

Example of POJO in Java

public class Person {
    private String name;
    private int age;

    public Person() {
        // Default constructor
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Getter and setter methods for name
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    // Getter and setter methods for age
    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

In this example, the Person class is a basic POJO that represents a person with a name and an age. Here’s an explanation of the different parts of the code:

The class Person is defined with two private instance variables name and age which are encapsulated within the class.

The class has two constructors: a default constructor with no arguments, and a parameterized constructor that takes name and age as arguments. This allows flexibility in creating instances of the Person class.

Getter and setter methods are provided for accessing and modifying the values of the private variable’s name and ages. These methods follow the standard naming convention (getVariableName and setVariableName), allowing other parts of the program to interact with the private variables indirectly.

The getter methods return the values of the respective variables, while the setter methods set new values for the variables.

By adhering to these conventions, the Person class can be considered a POJO. It is a simple and self-contained Java class that does not rely on any external frameworks or dependencies. Its purpose is to represent a person’s data, and it can be easily instantiated, modified, and accessed by other parts of the application.

Properties of POJO in Java

The properties, or characteristics, of a POJO (Plain Old Java Object) in Java include:

• Simplicity: A POJO is a simple Java class that adheres to a set of conventions without requiring any specialized frameworks or dependencies.
• Standard Java Bean Conventions: A POJO typically follows the standard Java Bean conventions, which include private fields with corresponding getter and setter methods for accessing and modifying the field values.
• Encapsulation: The fields of a POJO are encapsulated, meaning they are declared as private and accessed through public getter and setter methods. This ensures proper encapsulation and allows for better control over the object’s state.
• No Business Logic: A POJO should not contain complex business logic. Its primary purpose is to hold and represent data rather than perform significant computations or business operations.
• Serializable: POJOs can often implement the Serializable interface, allowing them to be serialized and deserialized. This is useful for scenarios where the object needs to be stored, transmitted or persisted.
• No Framework Dependencies: A key characteristic of a POJO is its independence from specific frameworks or libraries. It should not rely on any particular framework or technology, making it more portable, reusable, and easier to understand and maintain.
• Testing and Mocking: POJOs are easily testable since they do not have dependencies on external frameworks or services. This makes it simpler to write unit tests and mock the POJO’s behaviour as needed.

By adhering to these properties, POJOs promote clean and modular code design, making it easier to work with Java objects in various scenarios and promoting code reusability.

Working of POJO Class

An object class in Java is the POJO class. It includes business logic. In a Model View Controller architecture, after viewing, the controller would communicate with the business logic, which would then get in touch with the Java POJO class to retrieve the data. The phrase "business logic" describes the comprehensive collection of guidelines that specify how data will be handled or stored inside a business or application domain.

Below is the working of the POJO class.

The POJO class contains the same members as the database object in the example above because the database entity serves as a representation of the POJO.

Use of POJO Class in Java

The POJO class was developed so that Java programs may utilize the objects. The main benefit of the POJO class is that it eliminates the need to repeatedly generate objects in other Java programs. Simply said, we may use the get() and set() methods to access the objects.

The steps listed below can be used to access objects from the POJO class:

• Assemble POJO classes for things
• Utilize the set() function to set the values.
• Use the get() function to retrieve the values.

Here is an example of how to use a POJO class in a Java program:

package Jtp.PojoDemo;  
public class MainClass {  
    public static void main(String[] args) {  
        // Create an Employee class object  
Employee obj= new Employee();  
obj.setName("Ankit"); // Setting the values using the set() method  
obj.setId("A001");  
obj.setSal(200000);  
System.out.println("Name: "+ obj.getName()); //Getting the values using the get() method  
System.out.println("Id: " + obj.getId());  
System.out.println("Salary: " +obj.getSal());  
    }  
}  

Output

Name: Ankit
Id: A001
Salary: 200000.0

Conclusion
In conclusion, a POJO (Plain Old Java Object) is a simple Java class that adheres to certain conventions and does not depend on specific frameworks or technologies. It is primarily used to encapsulate data and represents entities within an application. The Key points regarding A POJO class are simplicity, Standard Java Bean Conventions, Encapsulation, No Business Logic, Independence, Serialization/Deserialization, and Testing & Mocking.

By adhering to these principles, POJOs promote clean and modular code design, facilitate code reuse, and enhance testability. They are widely used in various Java applications, especially in areas like data transfer objects, database mapping, and serialization/deserialization processes.

Frequently Asked Questions

Q1. What is the purpose of using a POJO class in Java?
Ans. A POJO class is used to encapsulate data and represent entities within an application. It provides a simple and standardized way to work with Java objects, promoting code reusability, maintainability, and testability.

Q2. Can a POJO class have methods other than getter and setter methods?
Ans. Yes, a POJO class can have additional methods for behavior, not just getter and setter methods. However, it is recommended to keep the logic within a POJO class minimal and focus on data representation rather than complex business logic.

Q3. Is it necessary to implement the Serializable interface in a POJO class?
Ans. No, implementing the Serializable interface is not necessary for a class to be considered a POJO. However, if serialization or deserialization is required for the class, implementing Serializable allows objects of the class to be converted into byte streams or other formats for storage, transmission, or persistence.

Q4. Can a POJO class have constructor overloading?
Ans. Yes, a POJO class can have multiple constructors, including constructor overloading. This allows flexibility in creating instances of the class with different sets of arguments.

Q5. Can a POJO class have static fields or methods?
Ans. Yes, a POJO class can have static fields and methods. However, it is important to ensure that the static elements are used appropriately and do not violate the principles of a POJO, such as maintaining encapsulation and not introducing unnecessary complexity.

Q6. Is a JavaBean the same as a POJO class?
Ans. In general, a JavaBean is a type of POJO that strictly follows certain conventions, such as having a public no-argument constructor and providing property change listeners. However, not all POJOs are necessarily JavaBeans, as they may not adhere to the complete set of JavaBean conventions.