DEPARTMENT OF COMPUTER SCIENCE ENGINEERING

Java programming
LAB MANUAL

Regulation : R22/JNTUH
Academic Year : 2023-2024

II B. TECH I SEMESTER
2. Write a Java program to demonstrate the OOP principles. [i.e., Encapsulation, Inheritance,
Polymorphism and Abstraction]
// Encapsulation: Using private fields and public methods to access them
class BankAccount {
private double balance;

public void deposit(double amount) {

if (amount > 0) {
balance += amount;
}
}

public void withdraw(double amount) {

if (amount > 0 && amount <= balance) {
balance -= amount;
}
}

public double getBalance() {

return balance;
}
}

// Inheritance: Creating a subclass that inherits from a superclass

class SavingsAccount extends BankAccount {
private double interestRate;

public SavingsAccount(double initialBalance, double interestRate) {

deposit(initialBalance);
this.interestRate = interestRate;
}
 public void applyInterest() {
double interest = getBalance() * interestRate;
deposit(interest);
}
}

// Polymorphism: Demonstrating polymorphism through method overriding

class CheckingAccount extends BankAccount {
public void withdraw(double amount) {
if (amount > 0) {
super.withdraw(amount); // Call the superclass method
}
}
}

// Abstraction: Creating an abstract class with an abstract method

abstract class Shape {
public abstract double calculateArea();
}

class Circle extends Shape {

private double radius;

public Circle(double radius) {

this.radius = radius;
}

public double calculateArea() {

return Math.PI * radius * radius;
}
}
public class OOPDemo {
public static void main(String[] args) {
// Encapsulation
BankAccount account = new BankAccount();
account.deposit(1000);
account.withdraw(200);
System.out.println("Account Balance: " + account.getBalance());

// Inheritance
SavingsAccount savingsAccount = new SavingsAccount(5000, 0.05);
savingsAccount.applyInterest();
System.out.println("Savings Account Balance: " + savingsAccount.getBalance());

CheckingAccount checkingAccount = new CheckingAccount();

checkingAccount.deposit(2000);
checkingAccount.withdraw(300);
System.out.println("Checking Account Balance: " + checkingAccount.getBalance());

// Polymorphism
Shape shape = new Circle(5.0);
System.out.println("Area of the Circle: " + shape.calculateArea());

// Abstraction
// Shape shape = new Shape(); // Error: Cannot instantiate an abstract class
}
}

OUTPUT:
3. Write a Java program to handle checked and unchecked exceptions. Also, demonstrate the usage
of custom exceptions in real time scenario.
PROGRAM:
// Custom Checked Exception
class InsufficientBalanceException extends Exception {
public InsufficientBalanceException(String message) {
super(message);
}
}

// Custom Unchecked Exception

class InvalidInputException extends RuntimeException {
public InvalidInputException(String message) {
super(message);
}
}

class BankAccount {
private double balance;

public BankAccount(double initialBalance) {

balance = initialBalance;
}

// Handle Checked Exception

 public void withdraw(double amount) throws InsufficientBalanceException {
if (amount > balance) {
throw new InsufficientBalanceException("Insufficient balance to withdraw " + amount);
}
balance -= amount;
}

// Handle Unchecked Exception

public void deposit(double amount) {
if (amount <= 0) {
throw new InvalidInputException("Invalid input: Amount must be greater than zero");
}
balance += amount;
}

public double getBalance() {

return balance;
}
}

public class ExceptionHandlingDemo {

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

try {
account.withdraw(1500); // This will throw InsufficientBalanceException
} catch (InsufficientBalanceException e) {
System.out.println("Error: " + e.getMessage());
}

try {
account.deposit(-500); // This will throw InvalidInputException
 } catch (InvalidInputException e) {
System.out.println("Error: " + e.getMessage());
}

// Real-time scenario: Handling exceptions when processing user data

try {
processUserData("John", -25);
} catch (InvalidInputException e) {
System.out.println("Error: " + e.getMessage());
}
}

// Real-time scenario: Method that processes user data

public static void processUserData(String name, int age) {
if (name == null || name.length() == 0) {
throw new InvalidInputException("Invalid name: Name cannot be empty");
}
if (age < 0) {
throw new InvalidInputException("Invalid age: Age cannot be negative");
}

// Process user data here

System.out.println("User Data Processed: Name - " + name + ", Age - " + age);
}
}
OUTPUT:
4. Write a Java program on Random Access File class to perform different read and write operations.
PROGRAM:
import java.io.RandomAccessFile;
import java.io.IOException;

public class RandomAccessFileDemo {

public static void main(String[] args) {
try {
// Create a RandomAccessFile for read and write operations
RandomAccessFile file = new RandomAccessFile("data.txt", "rw");

// Write data to the file

file.writeUTF("Hello, World!");
file.writeInt(42);
file.writeDouble(3.14159);

// Set the file pointer to the beginning of the file

file.seek(0);

// Read and display the data

String str = file.readUTF();
int num = file.readInt();
double pi = file.readDouble();

System.out.println("String: " + str);

System.out.println("Int: " + num);
System.out.println("Double: " + pi);

// Set the file pointer to a specific position (in bytes)

long position = 12;

// Check if there are enough bytes available to read a boolean

 if (file.length() >= position + 1) {
file.seek(position);
boolean bool = file.readBoolean();
System.out.println("Boolean: " + bool);
} else {
System.out.println("Not enough data to read the boolean.");
}

// Close the file

file.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
OUTPUT:

5. Write a Java program to demonstrate the working of different collection classes. [Use package
structure to store multiple classes].
PROGRAM:
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;

public class CollectionDemo {

public static void main(String[] args) {
// Demonstrating ArrayList
ArrayList<String> arrayList = new ArrayList<String>();
arrayList.add("Apple");
 arrayList.add("Banana");
arrayList.add("Cherry");
System.out.println("ArrayList Elements: " + arrayList);

// Demonstrating HashMap
HashMap<Integer, String> hashMap = new HashMap<Integer, String>();
hashMap.put(1, "One");
hashMap.put(2, "Two");
hashMap.put(3, "Three");
System.out.println("HashMap Elements: " + hashMap);

// Demonstrating HashSet
HashSet<String> hashSet = new HashSet<String>();
hashSet.add("Red");
hashSet.add("Green");
hashSet.add("Blue");
System.out.println("HashSet Elements: " + hashSet);
}
}
OUTPUT:

6. Write a program to synchronize the threads acting on the same object. [Consider the example of
any reservations like railway, bus, movie ticket booking, etc.]
PROGRAM:
import java.util.concurrent.locks.ReentrantLock;

class TicketBooking {
private int availableSeats;
private final ReentrantLock lock;
 public TicketBooking(int totalSeats) {
availableSeats = totalSeats;
lock = new ReentrantLock();
}

public void bookTicket(int numSeats) {

lock.lock();
try {
if (numSeats <= availableSeats) {
System.out.println(Thread.currentThread().getName() + " booked " + numSeats + "
seat(s).");
availableSeats -= numSeats;
} else {
System.out.println(Thread.currentThread().getName() + " couldn't book " + numSeats + "
seat(s). Insufficient seats.");
}
} finally {
lock.unlock();
}
}
}

public class MovieTicketBooking {

public static void main(String[] args) {
final TicketBooking booking = new TicketBooking(10); // 10 available seats

Thread customer1 = new Thread(new Runnable() {

public void run() {
booking.bookTicket(3);
}
}, "Customer 1");
 Thread customer2 = new Thread(new Runnable() {
public void run() {
booking.bookTicket(4);
}
}, "Customer 2");

Thread customer3 = new Thread(new Runnable() {

public void run() {
booking.bookTicket(2);
}
}, "Customer 3");

customer1.start();
customer2.start();
customer3.start();
}
}
OUTPUT:

8. Write a Java program that works as a simple calculator. Use a grid layout to arrange buttons for the
digits and for the +, -,*, % operations. Add a text field to display the result. Handle any possible
exceptions like divided by zero
PROGRAM:
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class SimpleCalculator {

 public static void main(String[] args) {
SwingUtilities.invokeLater(new Runnable() {
public void run() {
JFrame frame = new CalculatorFrame();
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);
}
});
}
}

class CalculatorFrame extends JFrame {

private JTextField display;
private double num1;
private String operator;
private boolean isNewInput;

public CalculatorFrame() {
setTitle("Simple Calculator");
setLayout(new BorderLayout());
setSize(300, 400);

display = new JTextField();

display.setHorizontalAlignment(JTextField.RIGHT);
display.setEditable(false);
add(display, BorderLayout.NORTH);

JPanel buttonPanel = new JPanel(new GridLayout(5, 4));

add(buttonPanel, BorderLayout.CENTER);

String[] buttonLabels = {
"7", "8", "9", "/",
 "4", "5", "6", "*",
"1", "2", "3", "-",
"0", "C", "=", "+"
};

for (String label : buttonLabels) {

JButton button = new JButton(label);
buttonPanel.add(button);
button.addActionListener(new ButtonListener());
}

num1 = 0;
operator = "";
isNewInput = true;
}

private class ButtonListener implements ActionListener {

public void actionPerformed(ActionEvent event) {
String input = event.getActionCommand();

if (isNewInput) {
display.setText("");
isNewInput = false;
}

if (input.matches("[0-9]")) {
display.setText(display.getText() + input);
} else if (input.equals("C")) {
num1 = 0;
operator = "";
display.setText("");
} else if (input.matches("[/+\\-*]")) {
 num1 = Double.parseDouble(display.getText());
operator = input;
isNewInput = true;
} else if (input.equals("=")) {
try {
double num2 = Double.parseDouble(display.getText());
double result = calculate(num1, num2, operator);
display.setText(String.valueOf(result));
isNewInput = true;
} catch (NumberFormatException e) {
display.setText("Error");
} catch (ArithmeticException e) {
display.setText("Divide by zero");
}
}
}

private double calculate(double num1, double num2, String operator) {

if (operator.equals("+")) {
return num1 + num2;
} else if (operator.equals("-")) {
return num1 - num2;
} else if (operator.equals("*")) {
return num1 * num2;
} else if (operator.equals("/")) {
if (num2 == 0) {
throw new ArithmeticException("Divide by zero");
}
return num1 / num2;
} else {
return num2;
}
 }
}
}
OUTPUT: