Java - Getters and Setters

Getters and Setters in Java

Getters and Setters in Java are among the most frequently searched topics by Java beginners, students, and developers preparing for interviews. They play a crucial role in the concepts of Object-Oriented Programming (OOP), especially in Encapsulation, which is one of the core pillars of Java. These methods allow controlled access to private fields of a class. Because Java developers often search for topics like “Java getters and setters example”, “encapsulation using getters setters”, “difference between getter and setter in Java”, “benefits of getter and setter”, and “how to create getters and setters in Java”, this document includes all relevant keywords to help increase reach and impressions. This detailed HTML document explains getters and setters thoroughly with large explanations, code snippets, and outputs.

What Are Getters in Java?

A getter method in Java is used to retrieve or “get” the value of a private variable. Because Java follows the principle of data hiding, most instance variables inside a class are declared as private. To read the value of these private variables from outside the class, we use getter methods. They always return some value and do not modify the state of the object. Getters are also referred to as accessor methods. They help maintain encapsulation by providing controlled read access, preventing unauthorized direct access to fields. Most getter methods follow a standard naming convention: getFieldName(). For example, if the variable name is name, the getter should be getName(). Getters may include additional logic such as validation, formatting, or read restrictions if needed. This enhances control and improves the reliability of your code.

Example of a Getter Method in Java

class Student {
    private String name;

    public String getName() {
        return name;
    }
}

public class Main {
    public static void main(String[] args) {
        Student s = new Student();
        System.out.println("Student Name: " + s.getName());
    }
}

Output:

Student Name: null

What Are Setters in Java?

A setter method allows modifying or “setting” the value of a private field. These methods help control how data is assigned to fields inside a class. Setters are also known as mutator methods. Like getters, they follow a naming convention: setFieldName(). For example, if the variable name is age, the setter name must be setAge(). Setters are extremely useful for adding validation before assigning a value. For example, you may want to ensure that age cannot be negative or name should not be empty. By using setters, you centralize validation logic, making your Java class more secure and maintainable. Setters return void because their job is not to return data but to update the object’s state.

Example of a Setter Method in Java

class Student {
    private int age;

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

    public int getAge() {
        return age;
    }
}

public class Main {
    public static void main(String[] args) {
        Student s = new Student();
        s.setAge(20);
        System.out.println("Student Age: " + s.getAge());
    }
}

Output:

Student Age: 20

Why Do We Need Getters and Setters in Java?

Many beginners wonder why they cannot simply declare variables as public instead of creating getters and setters. While public variables may seem convenient, they completely break the principle of encapsulation. Encapsulation ensures that object fields are not exposed directly to the outside world. Getters and setters allow developers to enforce strict control over how data is accessed and modified. You can add validation inside setters, perform transformations inside getters, and maintain full control over your class behavior. They also help avoid accidental misuse of variables, reduce bugs, and make classes future-proof. Additionally, frameworks like Hibernate, Spring, and JavaBeans rely heavily on getter and setter conventions. Thus, for long-term development and maintainability, getters and setters are essential components of Java programming.

Example Showing the Need for Validation

class Employee {
    private double salary;

    public void setSalary(double salary) {
        if (salary > 0) {
            this.salary = salary;
        } else {
            System.out.println("Invalid salary value!");
        }
    }

    public double getSalary() {
        return salary;
    }
}

public class Main {
    public static void main(String[] args) {
        Employee e = new Employee();
        e.setSalary(-1000);
        System.out.println("Salary: " + e.getSalary());
    }
}

Output:

Invalid salary value!
Salary: 0.0

Java Naming Conventions for Getters and Setters

Java follows a strict naming convention for getter and setter methods. This not only keeps code readable but also ensures compatibility with Java frameworks and libraries. Getters begin with the prefix “get” followed by the variable name in CamelCase format. Setters begin with the prefix “set”. Private variable names generally start with lowercase letters. If a variable name starts with a capital letter or uses acronyms, Java still applies the same CamelCase rules. Following naming conventions ensures that automated tools, reflection APIs, and JavaBeans components work correctly. Many IDEs auto-generate getters and setters based on these naming conventions.

Example: Naming Convention

private String firstName;

public String getFirstName() {
    return firstName;
}

public void setFirstName(String firstName) {
    this.firstName = firstName;
}

Output: (No direct output — naming convention example)

Benefits of Using Getters and Setters

There are many advantages to using getter and setter methods. First, they enhance encapsulation by restricting direct field access. Second, they allow validation of data before modifying the state of an object, preventing invalid or dangerous values. Third, they enable transformation of output values inside getters, such as formatting names or converting values. Fourth, they make it easier to maintain and expand a class in the future without breaking code. Fifth, automated tools like serialization libraries and Java frameworks depend on getter and setter conventions. Sixth, they keep your code clean, readable, and professionally structured. Thus, getters and setters form a foundational part of advanced Java development.

Example with Extra Logic in Getter

class Product {
    private String name;

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

    public String getName() {
        return name.toUpperCase();
    }
}

public class Main {
    public static void main(String[] args) {
        Product p = new Product();
        p.setName(" laptop ");
        System.out.println("Product Name: " + p.getName());
    }
}

Output:

Product Name: LAPTOP

Encapsulation Using Getters and Setters

Encapsulation is the process of wrapping data and methods into a single unit and controlling access using access modifiers. In Java, private variables cannot be accessed outside the class, making them safe and secure. To interact with these private variables, Java provides getters and setters. This ensures that the internal data of a class remains protected from accidental or malicious modification. Encapsulation improves code security, reduces complexity, and makes the software more reliable. It also allows developers to change the internal implementation of a class without affecting the outside world. Hence, getters and setters are fundamental tools for maintaining proper encapsulation.

Encapsulation Example

class BankAccount {
    private double balance;

    public void deposit(double amount) {
        if (amount > 0)
            balance += amount;
    }

    public double getBalance() {
        return balance;
    }
}

public class Main {
    public static void main(String[] args) {
        BankAccount b = new BankAccount();
        b.deposit(500);
        System.out.println("Balance: " + b.getBalance());
    }
}

Output:

Balance: 500.0

Auto-Generated Getters and Setters in IDEs

Most Java IDEs such as IntelliJ IDEA, Eclipse, and NetBeans provide built-in features to automatically generate getter and setter methods. This reduces typing time, avoids mistakes, and ensures proper naming convention usage. Auto-generated code helps beginners learn the correct structure of getter and setter methods. This also increases productivity for professional Java developers who frequently work with large classes. Although automated generation is convenient, developers must still understand how getters and setters work internally. Knowing how to manually write these methods is essential during interviews, examinations, and coding challenges.

Example (generated but written manually here)

private int id;

public int getId() {
    return id;
}

public void setId(int id) {
    this.id = id;
}

 Using Getters and Setters

In real-world Java applications, getters and setters are used extensively in enterprise systems, banking applications, e-commerce systems, student management systems, and more. They ensure data security by preventing direct field access and allow developers to enforce rules. Below is a practical example demonstrating how a Student Management System uses getters and setters to maintain organized and controlled data handling. This example also shows object creation, method calling, and output generation.

Example

class Student {
    private String name;
    private int marks;

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

    public String getName() {
        return name;
    }

    public void setMarks(int marks) {
        if (marks >= 0 && marks <= 100) {
            this.marks = marks;
        }
    }

    public int getMarks() {
        return marks;
    }
}

public class Main {
    public static void main(String[] args) {
        Student s = new Student();
        s.setName("Nila");
        s.setMarks(92);

        System.out.println("Student Name: " + s.getName());
        System.out.println("Marks: " + s.getMarks());
    }
}

Output:

Student Name: Nila
Marks: 92

Getters and Setters are foundational concepts in Java programming. They support encapsulation, maintain clean code architecture, and enable safe access to private variables. Every Java developer—from beginner to professional—must understand and apply getters and setters properly. This detailed document covered the meaning, purpose, benefits, naming conventions, examples, validation logic, real-life use cases, and complete working examples with outputs. With this knowledge, you can confidently implement encapsulation and build secure, scalable, and maintainable Java applications.