Scribd
Upload
38 views

Java Pillar 1 Encapsulation

Encapsulation is a fundamental concept in object-oriented programming that involves hiding the internal representation of an object from other objects. In Java, encapsulation is achieved through the use of access modifiers such as public, private, protected, and package-private to control access to classes, methods and fields. Getters and setters also help achieve encapsulation by providing controlled access to an object's internal state. Encapsulation provides benefits like increased security, flexibility, maintainability and reusability of code.

Uploaded by

Danish Baig
Copyright
© © All Rights Reserved
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
38 views

Java Pillar 1 Encapsulation

Encapsulation is a fundamental concept in object-oriented programming that involves hiding the internal representation of an object from other objects. In Java, encapsulation is achieved through the use of access modifiers such as public, private, protected, and package-private to control access to classes, methods and fields. Getters and setters also help achieve encapsulation by providing controlled access to an object's internal state. Encapsulation provides benefits like increased security, flexibility, maintainability and reusability of code.

Uploaded by

Danish Baig
Copyright
© © All Rights Reserved
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 3

java Pillar 1: Encapsulation

Encapsulation is one of the four pillars of object-oriented programming (OOP) in Java. It is a


fundamental concept that enables developers to create objects that can encapsulate data and
functionality, and control their access to other objects in a program. In this article, we will
explore encapsulation in Java in detail.
Encapsulation refers to the practice of hiding the internal details of an object from the outside
world. This is done to prevent other objects from accessing or modifying the internal state of an
object in ways that are not intended. Encapsulation is important because it helps to maintain the
integrity of an object and to prevent unexpected changes that can cause errors or unexpected
behavior.
In Java, encapsulation is achieved through the use of access modifiers, which control the level of
access that other objects have to the data and methods of a class. Java has four access modifiers:
public, private, protected, and package-private.
Public access modifier: The public access modifier is the least restrictive and allows all other
objects in the program to access the data and methods of a class. This means that a public field or
method can be accessed from any part of the program. For example, consider the following code:
typescriptCopy code
public class Car { public String make; public String model; public int year; public void
startEngine() { // start the engine } }
In this example, the Car class has three public fields: make, model, and year, and one public
method: startEngine(). This means that any other object in the program can access these fields
and methods.
Private access modifier: The private access modifier is the most restrictive and allows only the
methods of the same class to access the data and methods. This means that a private field or
method can be accessed only from within the class in which it is defined. For example, consider
the following code:
csharpCopy code
public class Car { private int mileage; public void setMileage(int mileage) { this.mileage =
mileage; } public int getMileage() { return this.mileage; } }
In this example, the Car class has one private field: mileage, and two public methods:
setMileage() and getMileage(). The setMileage() method is used to set the value of the mileage
field, while the getMileage() method is used to retrieve the value of the mileage field. Since the
mileage field is private, it can be accessed only from within the Car class.
Protected access modifier: The protected access modifier allows the methods of the same class
and the subclasses to access the data and methods. This means that a protected field or method
can be accessed from within the same class and its subclasses. For example, consider the
following code:
typescriptCopy code
public class Vehicle { protected String make; protected String model; protected void
startEngine() { // start the engine } } public class Car extends Vehicle { public void startCar()
{ startEngine(); } }
In this example, the Vehicle class has two protected fields: make and model, and one protected
method: startEngine(). The Car class extends the Vehicle class and has one public method:
startCar(). The startCar() method calls the startEngine() method, which is defined in the Vehicle
class. Since the startEngine() method is protected, it can be accessed from within the Car class.
Package-private access modifier: The package-private access modifier allows the methods of the
same class and other classes in the same package to access the data and methods. This means that
a package-private field or method can be accessed from within the same class and other classes
in the same package. For example, consider the following code:
Example:
package com.example.vehicle; public class Car { String make; String model; void startEngine()
{ // start the engine } }
In this example, the Car class has two package-private fields: make and model, and one package-
private method: startEngine(). Since the Car class and any other class in the same package can
access these fields and methods, they are not accessible from classes in other packages.
Encapsulation also involves the use of getters and setters, which are methods used to access and
modify the values of private fields. Getters and setters are used to provide controlled access to
the internal state of an object. For example, consider the following code:
typescriptCopy code
public class Person { private String name; private int age; public String getName() { return
this.name; } public void setName(String name) { this.name = name; } public int getAge()
{ return this.age; } public void setAge(int age) { this.age = age; } }
In this example, the Person class has two private fields: name and age. The class also has two
pairs of getter and setter methods: getName() and setName() for the name field, and getAge()
and setAge() for the age field. These methods are used to control access to the private fields and
ensure that they are accessed and modified only in ways that are intended.
Encapsulation has several benefits, including:
1. Increased security: Encapsulation prevents unauthorized access to an object's internal
state, which helps to improve the security of a program.
2. Increased flexibility: Encapsulation allows changes to be made to an object's internal
state without affecting other parts of a program.
3. Improved maintainability: Encapsulation makes it easier to maintain and modify a
program because changes to the internal state of an object can be made without affecting
other parts of the program.
4. Improved reusability: Encapsulation makes it easier to reuse code because the
implementation details of an object are hidden from other parts of the program.
In summary, encapsulation is an important concept in Java that enables developers to create
objects that can encapsulate data and functionality and control their access to other objects in a
program. Encapsulation is achieved through the use of access modifiers, getters and setters, and
other OOP principles. Encapsulation provides several benefits, including increased security,
flexibility, maintainability, and reusability.

You might also like