Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                
Scribd
Upload
11 views

Java Encapsulation Examples

oop notes on encapsulation

Uploaded by

khanamazra82
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
11 views

Java Encapsulation Examples

oop notes on encapsulation

Uploaded by

khanamazra82
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 6

Here are a few program examples that demonstrate the use of encapsulation through getter and setter

methods, along with detailed explanations.


### Example 1: Employee Details
This example shows how to encapsulate an employee's information, such as name and salary, and
access it via getter and setter methods.
Code:
package encapsulation;
class Employee {
private String name;
private double salary;

// Getter for name


public String getName() {
return name;
}

// Setter for name


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

// Getter for salary


public double getSalary() {
return salary;
}

// Setter for salary


public void setSalary(double salary) {
if (salary > 0) { // Validation to ensure salary is positive
this.salary = salary;
} else {
System.out.println("Salary must be greater than zero.");
}
}
}

public class TestEmployee {


public static void main(String[] args) {
Employee emp = new Employee();

// Setting values through setter methods


emp.setName("John Doe");
emp.setSalary(50000);
// Retrieving values through getter methods
System.out.println("Employee Name: " + emp.getName());
System.out.println("Employee Salary: $" + emp.getSalary());
}
}

Explanation:
- **Encapsulation** is achieved by making the `name` and `salary` fields private.
- The `setName()` and `setSalary()` methods allow controlled access to modify the private fields.
- The `getName()` and `getSalary()` methods provide read access to these fields.
- Additional logic is included to ensure the salary is positive.
Example 2: Student Marks

In this example, we encapsulate a student's details (name and marks) and ensure that the marks are
within a valid range.
Code:
package encapsulation;

class Student {
private String name;
private int marks;

// Getter for name


public String getName() {
return name;
}

// Setter for name


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

// Getter for marks


public int getMarks() {
return marks;
}

// Setter for marks with validation


public void setMarks(int marks) {
if (marks >= 0 && marks <= 100) { // Validation to ensure marks are between 0 and 100
this.marks = marks;
} else {
System.out.println("Invalid marks. Must be between 0 and 100.");
}
}
}

public class TestStudent {


public static void main(String[] args) {
Student student = new Student();

// Setting values
student.setName("Alice");
student.setMarks(85);

// Getting values
System.out.println("Student Name: " + student.getName());
System.out.println("Student Marks: " + student.getMarks());

// Trying to set invalid marks


student.setMarks(120); // This will trigger the validation message
}
}
Explanation:
- **Encapsulation** is used to protect the `name` and `marks` fields.
- The `setMarks()` method has validation to ensure that the marks fall within the range of 0 to 100.
- This example shows how encapsulation allows for data validation and restricted access to class
members.
Example 3: Bank Account

This example encapsulates a bank account's details and provides controlled access for depositing and
withdrawing money.
Code:
package encapsulation;

class BankAccount {
private String accountNumber;
private double balance;

// Getter for account number


public String getAccountNumber() {
return accountNumber;
}

// Setter for account number


public void setAccountNumber(String accountNumber) {
this.accountNumber = accountNumber;
}
// Getter for balance
public double getBalance() {
return balance;
}

// Method to deposit money


public void deposit(double amount) {
if (amount > 0) {
balance += amount;
} else {
System.out.println("Deposit amount must be positive.");
}
}

// Method to withdraw money


public void withdraw(double amount) {
if (amount > 0 && amount <= balance) {
balance -= amount;
} else {
System.out.println("Invalid withdrawal amount or insufficient balance.");
}
}
}

public class TestBankAccount {


public static void main(String[] args) {
BankAccount account = new BankAccount();

// Setting account details


account.setAccountNumber("123456789");
account.deposit(1000); // Depositing money

// Checking balance
System.out.println("Account Number: " + account.getAccountNumber());
System.out.println("Balance: $" + account.getBalance());

// Withdrawing money
account.withdraw(500);
System.out.println("Updated Balance: $" + account.getBalance());

// Attempting an invalid withdrawal


account.withdraw(600); // This will trigger the validation message
}
}
```
Explanation:
- **Encapsulation** ensures that the `accountNumber` and `balance` are only modified through setter
methods and controlled operations like `deposit()` and `withdraw()`.
- The `withdraw()` method checks if the withdrawal amount is valid before proceeding.
- This example shows how encapsulation is useful in real-world scenarios like banking, where data
protection and validation are crucial.
Example 4: Car Details

This example encapsulates the details of a car (model and speed), and speed is regulated using setter
methods.
Code:
package encapsulation;

class Car {
private String model;
private int speed;

// Getter for model


public String getModel() {
return model;
}

// Setter for model


public void setModel(String model) {
this.model = model;
}

// Getter for speed


public int getSpeed() {
return speed;
}

// Setter for speed with validation


public void setSpeed(int speed) {
if (speed >= 0 && speed <= 200) {
this.speed = speed;
} else {
System.out.println("Speed must be between 0 and 200 km/h.");
}
}
}
public class TestCar {
public static void main(String[] args) {
Car car = new Car();

// Setting car details


car.setModel("Tesla Model S");
car.setSpeed(150);

// Getting car details


System.out.println("Car Model: " + car.getModel());
System.out.println("Car Speed: " + car.getSpeed() + " km/h");

// Trying to set invalid speed


car.setSpeed(250); // This will trigger the validation message
}
}
```

#### Explanation:
- **Encapsulation** is used to protect the `model` and `speed` fields.
- The `setSpeed()` method ensures that the car's speed stays within a valid range (0 to 200 km/h).
- This example demonstrates how encapsulation can be used to enforce rules and constraints on class
data.

---

In all these examples, encapsulation provides control over how fields are accessed and modified,
ensuring data integrity and allowing validation where needed.

You might also like