19.1 Encapsulation: Variables
Encapsulation is one of the four fundamental pillars of object-oriented programming (OOP). It is a mechanism that restricts direct access to some components of an object and protects the members of an object from being accessed directly. In programming terms, encapsulation is the process of hiding the implementation details of a class and allowing access to it only through public methods.
Variables play a crucial role in encapsulation. To understand the importance of variables in encapsulation, we first need to understand what variables are. In programming, a variable is a named storage location that can hold some data or information that can change during program execution. Variables are the backbone of any program as they allow programmers to store, access, and manipulate data.
In the context of encapsulation, variables are often declared private to restrict direct access to them. This means that these variables cannot be directly accessed or modified from outside the class. Instead, they can only be accessed or modified through public methods known as getters and setters.
The getters and setters methods are used to set or get the value of private variables. The getter method returns the value of the private variable, while the setter method sets or modifies the value. These methods give you greater control over how variables are accessed and modified, helping to maintain data integrity.
For example, consider a class 'Person' with a private variable 'age'. To access or modify a person's age, we need to use getter and setter methods. The getter method 'getAge' returns the person's age, while the setter method 'setAge' modifies the age. If we try to access the 'age' variable directly from outside the class, we will get an error, as the variable is private and cannot be accessed directly.
- Listen to the audio with the screen off.
- Earn a certificate upon completion.
- Over 5000 courses for you to explore!
Download the app
class Person {
private int age;
public int getAge() {
return age;
}
public void setAge(int age) {
if (age > 0) {
this.idade = age;
} else {
System.out.println("Invalid age!");
}
}
}
As you can see, the setAge method also includes a check to ensure that the age is valid (ie greater than zero). This helps ensure data integrity by preventing age from being set to an invalid value. This is an example of how encapsulation can be used to protect data and ensure that it is handled properly.
In summary, encapsulation is an important concept in object-oriented programming that helps protect data and ensure its integrity. Variables play a crucial role in encapsulation as they allow programmers to restrict direct access to data and ensure that it is handled appropriately. By using private variables and getter and setter methods, programmers can control how data is accessed and modified, providing greater control over the implementation of a class.
