Scribd
Upload
103 views16 pages

Java Lab Manual (Aids)

Java lab experiments

Uploaded by

Vemula Naresh
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
103 views16 pages

Java Lab Manual (Aids)

Java lab experiments

Uploaded by

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

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:

You might also like