Getters And Setters

Getters

Getters give public access to private data. They may also make a small modification of the returned result.

Let's look the following example:

class Square { private // default value for side double side = 1; public double getSide() { return this.side; } } public class Main { public static void main(String[] args) { Square square = new Square(); // square.side; System.out.println(square.getSide()); } }

Output:

1.0

There are 2 things to notice in the code:

• If we uncomment line 19 the code will not compile. That's because a private member (declared at line 5) cannot be directly accessed outside the class body.
• At line 20 a private member is accessed outside the class body. That's not done directly (like in line 19) but through a public function - a getter. This is how a private member can be accessed outside the class body.

Let's add more stuff:

class Square { private // default value for side double side = 2.5; public double getSide() { return this.side; } double getPerimeter() { return this.side * 4; } double getArea() { return this.side * this.side; } } public class Main { public static void main(String[] args) { Square square = new Square(); System.out.println("Side = " + square.getSide()); System.out.println("Perimeter = " + square.getPerimeter()); System.out.println("Area = " + square.getArea()); } }

Output:

Side = 2.5 Perimeter = 10.0 Area = 6.25

The only things that were added are 2 getters - getPerimeter and getArea. Simply they are getters that return a private member with a small modification.

Setters

Setters allow for a private variable to be modified. They are important since they can provide validation before a value is set.

Let's look at the following example:

class Person { private String name; int age; public String getName() { return this.name; } int getAge() { return this.age; } // basic setter function: void setName(String nameNewValue) { this.name = nameNewValue; } // setter function with validation: void setAge(int ageNewValue) { if (ageNewValue < 0) { this.age = 0; } // set the new value this.age = ageNewValue; } void printData() { System.out.println("Name: " + name); System.out.println("Age: " + age); } } public class Main { public static void main(String[] args) { Person person = new Person(); person.setName("Emily"); person.setAge(20); // person.setAge(-1); person.printData(); } }

Output:

Name: Emily Age: 20

Explanation:

• Value of the private member name is modified at line 21 without any validation.
• At lines 25 - 33 is defined a setter that has validation. If the validation fails a value of 0 is set at line 28. If validation passes (age >= 0) then the passed value is set (line 32).
• If we uncomment line 44 then the person object's age will have a value of zero. That's due to the validation at line 26.

Why using getters and setters?

Because private members can have validation before modification (setter) and controlled access (getter).

It seems easier to have only public members. This way there is no need for getters and setters. It's a better practice to have private members that are accessed with getter and modified through setter. This way a validation can be provided in a setter and the public access can be done only to some members - those which have getters.