Encapsulation

Access modifiers (public, private, protected)

Access modifiers in Object-Oriented Programming control the visibility and accessibility of class members (fields and methods), helping to enforce encapsulation and protect data integrity.

Public

• Members declared as public are accessible from anywhere in the program
• They can be accessed by other classes, subclasses, and even outside the package or module
• Use public when you want to expose functionality or data to other parts of the application

Private

• Members marked private are accessible only within the class where they are defined
• This is used to restrict access to sensitive data or internal logic
• Private fields and methods help enforce encapsulation by hiding internal implementation details

Protected

• Members with protected access are visible within the same class, its subclasses, and sometimes within the same package/module (language-dependent)
• Protected is used when you want to allow inherited classes to access or modify members while still limiting external access

Why Use Access Modifiers

• They enforce clear boundaries between the internal and external parts of a class
• They reduce the risk of accidental changes to critical data
• They improve code maintainability, security, and reusability

Access modifiers are essential tools for controlling access levels in a class, promoting safe coding practices, and supporting object-oriented principles like encapsulation and abstraction.

Getters and setters

Getters and setters are special methods used in Object-Oriented Programming to access and modify the private fields of a class while preserving encapsulation and data integrity.

Getters

• A getter is a method that retrieves or returns the value of a private field
• It allows controlled read access to internal class data from outside the class
• Getters are typically named with a prefix like get followed by the field name (e.g., getname())
• They can also perform additional logic before returning the value, such as formatting or validation

Setters

• A setter is a method that updates or sets the value of a private field
• It enables controlled write access to class data from outside the class
• Setters are usually named with a prefix like set followed by the field name (e.g., setname(value))
• They can include logic to validate or restrict changes to ensure data consistency

Why Use Getters and Setters

• They help enforce encapsulation by hiding direct access to internal fields
• They provide a controlled interface to read and update values safely
• They allow future changes in logic without affecting external code that uses the class
• They can include checks, transformations, or triggers that execute automatically when data is accessed or changed

Example Behavior

• A private field salary can be accessed using getsalary() and updated with setsalary()
• The setter might include a rule to prevent setting a negative salary
• The getter might format the salary as currency before returning it

Using getters and setters ensures robust, maintainable, and secure object-oriented design by controlling how class data is accessed and modified.

Data hiding and information security

Data hiding and information security are core principles of Object-Oriented Programming aimed at protecting internal object data and maintaining application integrity through controlled access mechanisms.

What is Data Hiding?

• Data hiding refers to restricting direct access to an object’s internal state (its fields)
• It is achieved by making class fields private and exposing them through controlled methods like getters and setters
• This ensures that data cannot be accidentally or maliciously modified from outside the class

Role in Information Security

• By hiding data, developers limit the exposure of sensitive information and prevent unintended interactions
• It prevents unauthorized access, reducing vulnerabilities in the code
• Validations within setter methods can block invalid or harmful inputs, further securing the application

Benefits of Data Hiding

• Improves code reliability by minimizing errors due to unintended changes
• Enhances maintainability by clearly defining boundaries for data access
• Supports abstraction, allowing complex internal workings to be hidden while exposing only essential features
• Encourages encapsulated and modular design

Implementation Techniques

• Use access modifiers like private or protected for fields
• Provide public getter and setter methods with validation logic
• Apply security best practices such as input sanitization and proper error handling within accessors

Data hiding plays a vital role in software security by ensuring that critical data is accessed only through well-defined, secure interfaces. It supports the broader goal of information security by protecting object integrity and reducing exposure to potential threats.

Example: designing a class with encapsulation

Encapsulation is a fundamental concept in Object-Oriented Programming that involves bundling data (fields) and methods (functions) within a class while restricting direct access to some of the object’s components to protect its internal state.

Purpose of Encapsulation

• Protects object data from unauthorized access and modification
• Enforces a controlled way to interact with an object using methods
• Promotes modular and maintainable code

Class Design Example

• Class Name: bank account
• Private Fields: account number, owner name, balance
• Public Methods:

Encapsulation in Action

• All fields are private, so they cannot be accessed directly from outside the class
• Methods handle all interactions with the object’s state
• Validations inside methods prevent invalid operations (like negative deposits or over-withdrawals)

Benefits of This Approach

• Internal state is secure and consistent
• Code is easier to debug and extend
• Users of the class don’t need to know how data is managed internally

This design demonstrates proper encapsulation by ensuring that data is hidden and accessed only through well-defined, secure methods. It improves maintainability, security, and reliability in object-oriented software development.