EXP3: CLASS AND OBJECTS: STUDY AND IMPLEMENT CLASSES BASED

APPLICATION USING JAVA

Write a program to create a “distance” class with methods where distance is computed
in terms of feet and inches, how to create objects of a class

//23BCP471

class Distance {

int feet;

int inches;

// Constructor

Distance(int feet, int inches) {

this.feet = feet;

this.inches = inches;

// Method to display distance

void displayDistance() {

System.out.println(feet + " feet and " + inches + " inches");

// Clone method

Distance cloneDistance() {

return new Distance(this.feet, this.inches);

}
}

public class DistanceTest {

public static void main(String[] args) {

Distance d1 = new Distance(5, 10); // Create first object

Distance d2 = d1; // Assign reference to another variable
 Distance d3 = d1.cloneDistance(); // Create a clone of the first object

d1.displayDistance();

d2.displayDistance();
System.out.print("Clone: ");

d3.displayDistance();

OUTPUT:

Modify the “distance” class by creating constructor for assigning values (feet and inches) to
the distance object. Create another object and assign second object as reference variable to
another object reference variable. Further create a third object which is a clone of the first
object.

//23BCP471

class Demo {

public int publicVar = 100; // Public access

private int privateVar = 200; // Private access

// Public getter

public int getPrivateVar() {

return privateVar;

// Method to modify variable

public void modifyPublicVar(int value) {
publicVar = value;
 }

public void modifyPrivateVar(int value) {

privateVar = value;
}

class Test {

static void modifyPrimitive(int x) {

x = 50; // Does not affect the original

static void modifyObject(Demo obj) {

obj.modifyPublicVar(300); // Affects the original

public static void main(String[] args) {

Demo obj = new Demo();

// Public and private access

System.out.println("Public variable: " + obj.publicVar);

System.out.println("Private variable (via getter): " + obj.getPrivateVar());

// Passing by value vs reference

int primitive = 10;

modifyPrimitive(primitive);
System.out.println("After modifying primitive: " + primitive); // No change

modifyObject(obj);
 System.out.println("After modifying object: " + obj.publicVar); // Changed

// Use of final keyword

final int finalVar = 100;

// finalVar = 200; // Error: Cannot assign a value to final variable

System.out.println("Final variable: " + finalVar);

Output:

Write a program that implements two constructors in the class. We call the other constructor
using ‘this’ pointer, from the default constructor of the class.
class Demo {

int value;

// Default constructor

Demo() {

this(10); // Invokes the parameterized constructor

System.out.println("Default constructor called.");

}

// Parameterized constructor

Demo(int value) {
this.value = value;
 System.out.println("Parameterized constructor called with value: " + value);

public class ConstructorTest {

public static void main(String[] args) {

Demo obj = new Demo(); // Calls the default constructor

Output:

Write a program in Java in which a subclass constructor invokes the constructor of the super
class and instantiate the values.

class Parent {

int parentValue;

// Constructor of superclass

Parent(int value) {

this.parentValue = value;
System.out.println("Parent constructor called with value: " + value);

class Child extends Parent {

int childValue;

// Constructor of subclass
 Child(int parentValue, int childValue) {

super(parentValue); // Call superclass constructor

this.childValue = childValue;

System.out.println("Child constructor called with value: " + childValue);

}

public class InheritanceTest {

public static void main(String[] args) {

Child obj = new Child(100, 200); // Instantiate subclass

}
}
Output:

EXP4: INHERITANCE: STUDY AND IMPLEMENT VARIOUS TYPES OF

INHERITANCE IN JAVA.

Write a program in Java to demonstrate single inheritance, multilevel inheritance and

hierarchical inheritance.

class Animal {

void eat() {

System.out.println("This animal eats food.");

}

class Dog extends Animal {

 void bark() {

System.out.println("The dog barks.");

public class SingleInheritance {

public static void main(String[] args) {

Dog dog = new Dog();

dog.eat(); // Inherited from Animal

dog.bark();

}
}
Output:

2)

class Animal {

void eat() {

System.out.println("This animal eats food.");

}

class Mammal extends Animal {

void walk() {

System.out.println("This mammal walks.");

}
}
class Dog extends Mammal {

void bark() {

System.out.println("The dog barks.");

}
}

public class MultilevelInheritance {

public static void main(String[] args) {

Dog dog = new Dog();

dog.eat(); // Inherited from Animal

dog.walk(); // Inherited from Mammal

dog.bark();
}

Output:

Java Program to demonstrate the real scenario (e.g., bank) of Java Method Overriding where
three classes are overriding the method of a parent class. Creating a parent class.

class Bank {
double getRateOfInterest() {
return 0; // Base rate

class SBI extends Bank {

@Override
double getRateOfInterest() {
 return 5.4;

class ICICI extends Bank {

@Override

double getRateOfInterest() {

return 6.8;

class HDFC extends Bank {

@Override

double getRateOfInterest() {

return 7.1;

public class BankExample {

public static void main(String[] args) {

Bank sbi = new SBI();

Bank icici = new ICICI();

Bank hdfc = new HDFC();

System.out.println("SBI Rate of Interest: " + sbi.getRateOfInterest() + "%");

System.out.println("ICICI Rate of Interest: " + icici.getRateOfInterest() + "%");

System.out.println("HDFC Rate of Interest: " + hdfc.getRateOfInterest() + "%");

}
}
Output:

Write a java program for the use of super and this keyword
class Employee {

String name;

int id;

Employee(String name, int id) {

this.name = name; // Refers to the current object's field

this.id = id;

void display() {

System.out.println("Name: " + this.name + ", ID: " + this.id);

public class ThisKeywordExample {

public static void main(String[] args) {

Employee emp = new Employee("Alice", 101);

emp.display();

Output:
class Animal {

void eat() {

System.out.println("Animal is eating.");

}
}

class Dog extends Animal {

@Override

void eat() {

super.eat(); // Calls the superclass's method

System.out.println("Dog is eating.");
}
}

public class SuperKeywordExample {

public static void main(String[] args) {

Dog dog = new Dog();

dog.eat();

}
}

Output:

Write a java program for the use of final keyword

-FINAL KEYWORD

class Vehicle {

final void start() { // Cannot be overridden

System.out.println("Vehicle is starting.");
}
}

class Car extends Vehicle {

// Attempting to override start() here would result in a compilation error

void drive() {

System.out.println("Car is driving.");

public class FinalKeywordExample {

public static void main(String[] args) {

Car car = new Car();
car.start();

car.drive();

-FINAL VARIABLE

public class FinalVariableExample {

public static void main(String[] args) {

final int speedLimit = 120;

// speedLimit = 140; // Error: Cannot assign a value to final variable

System.out.println("Speed limit: " + speedLimit);

-FINAL CLASS

final class Shape {

void draw() {

System.out.println("Drawing a shape.");
}
}

// class Circle extends Shape { // Error: Cannot inherit from final class

// }

public class FinalClassExample {

public static void main(String[] args) {

Shape shape = new Shape();

shape.draw();

EXP5: POLYMORPHISM: STUDY AND IMPLEMENT VARIOUS TYPES OF

POLYMORPHISM IN JAVA.

Write a program that implements simple example of Runtime Polymorphism with multilevel
inheritance. (e.g., Animal or Shape)

class Animal {

void sound() {

System.out.println("Some generic animal sound");

class Mammal extends Animal {

@Override

void sound() {

System.out.println("Some generic mammal sound");

}
class Dog extends Mammal {

@Override

void sound() {

System.out.println("The dog barks");

}

public class RuntimePolymorphism {

public static void main(String[] args) {

Animal animal; // Reference of parent type

animal = new Animal();

animal.sound(); // Calls Animal's method

animal = new Mammal();

animal.sound(); // Calls Mammal's overridden method

animal = new Dog();

animal.sound(); // Calls Dog's overridden method

}

Output:

Write a program to compute if one string is a rotation of another. For example, pit is rotation
of tip as pit has same character as tip

public class StringRotation {

static boolean isRotation(String s1, String s2) {

// Check if lengths match and s2 is a substring of s1 concatenated with itself
 return s1.length() == s2.length() && (s1 + s1).contains(s2);

public static void main(String[] args) {

String str1 = "tip";

String str2 = "pit";

if (isRotation(str1, str2)) {

System.out.println(str2 + " is a rotation of " + str1);

} else {

System.out.println(str2 + " is not a rotation of " + str1);

}
}

Output:

EXP6: STUDY AND IMPLEMENT ABSTRACT CLASS AND INTERFACES IN JAVA

Describe abstract class called Shape which has three subclasses say Triangle, Rectangle,
Circle. Define one method area() in the abstract class and override this area() in these three
subclasses to calculate for specific object i.e. area() of Triangle subclass should calculate area
of triangle etc. Same for Rectangle and Circle.
Write a Java program to create an abstract class Employee with abstract methods
calculateSalary() and displayInfo(). Create subclasses Manager and Programmer that extend
the Employee class and implement the respective methods to calculate salary and display
information for each role.

// Abstract class Employee

abstract class Employee {

protected String name;

protected int id;

protected double baseSalary;

// Constructor
public Employee(String name, int id, double baseSalary) {

this.name = name;

this.id = id;

this.baseSalary = baseSalary;

// Abstract methods
abstract double calculateSalary();

abstract void displayInfo();

// Subclass Manager

class Manager extends Employee {

private double bonus;

// Constructor

public Manager(String name, int id, double baseSalary, double bonus) {

super(name, id, baseSalary);
 this.bonus = bonus;

// Implement calculateSalary
@Override

double calculateSalary() {

return baseSalary + bonus;

// Implement displayInfo

@Override
void displayInfo() {
System.out.println("Manager Info:");

System.out.println("Name: " + name + ", ID: " + id + ", Salary: " + calculateSalary());

// Subclass Programmer

class Programmer extends Employee {

private double overtimePay;

// Constructor

public Programmer(String name, int id, double baseSalary, double overtimePay) {

super(name, id, baseSalary);

this.overtimePay = overtimePay;

// Implement calculateSalary
@Override
 double calculateSalary() {

return baseSalary + overtimePay;

// Implement displayInfo

@Override

void displayInfo() {

System.out.println("Programmer Info:");

System.out.println("Name: " + name + ", ID: " + id + ", Salary: " + calculateSalary());

// Main class to demonstrate functionality

public class EmployeeExample {

public static void main(String[] args) {

// Create Manager and Programmer objects

Employee manager = new Manager("Alice", 101, 50000, 10000);

Employee programmer = new Programmer("Bob", 102, 40000, 5000);

// Display information and calculate salaries

manager.displayInfo();

programmer.displayInfo();

Output:
EXP7: STUDY AND IMPLEMENT EXCEPTION HANDLING IN JAVA

Write a Java program for try-catch block in exception handling

import java.util.Scanner;

public class ExceptionHandlingExample {

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);

try {

// Input two numbers

System.out.print("Enter the numerator: ");
int numerator = scanner.nextInt();

System.out.print("Enter the denominator: ");

int denominator = scanner.nextInt();

// Perform division

int result = numerator / denominator;

// Display the result

System.out.println("Result: " + result);

} catch (ArithmeticException e) {

// Handle division by zero

System.out.println("Error: Division by zero is not allowed.");

} catch (Exception e) {

// Handle other unexpected exceptions

System.out.println("Error: An unexpected error occurred - " + e.getMessage());
 } finally {

// Always executed

System.out.println("Execution completed.");

scanner.close(); // Close the scanner

}

OUTPUTS:

EXP8: STUDY AND IMPLEMENT FILE HANDLING IN JAVA

Refine the student manager program to manipulate the student information from files by
using the BufferedReader and BufferedWriter CO4 vi. Write a program to manipulate the
information from files by using the Reader and Writer class. Assume suitable data.

import java.io.*;

import java.util.*;

class Student {

private String name;

private int age;

private int rollNumber;
 // Constructor

public Student(String name, int age, int rollNumber) {

this.name = name;
this.age = age;

this.rollNumber = rollNumber;

// Getter methods

public String getName() {

return name;
}

public int getAge() {

return age;

public int getRollNumber() {

return rollNumber;
}

// Method to display student information

public void displayInfo() {

System.out.println("Name: " + name + ", Age: " + age + ", Roll Number: " +
rollNumber);

// Method to save student information to file

public void saveToFile(BufferedWriter writer) throws IOException {
 writer.write("Name: " + name + ", Age: " + age + ", Roll Number: " + rollNumber);

writer.newLine();

public class StudentManager {

// Method to add student data to a file

public static void addStudentDataToFile(String fileName, List<Student> students) {

try (BufferedWriter writer = new BufferedWriter(new FileWriter(fileName, true))) {

for (Student student : students) {

student.saveToFile(writer);
}
System.out.println("Student data has been added to the file.");

} catch (IOException e) {

System.out.println("An error occurred while writing to the file.");

e.printStackTrace();

// Method to read and display student data from a file

public static void displayStudentDataFromFile(String fileName) {

try (BufferedReader reader = new BufferedReader(new FileReader(fileName))) {

String line;

while ((line = reader.readLine()) != null) {

System.out.println(line);

}
} catch (IOException e) {

System.out.println("An error occurred while reading from the file.");

e.printStackTrace();
 }

public static void main(String[] args) {

List<Student> students = new ArrayList<>();

students.add(new Student("John Doe", 20, 101));

students.add(new Student("Jane Smith", 22, 102));

students.add(new Student("Emily Davis", 21, 103));

String fileName = "students.txt";

// Add student data to file

addStudentDataToFile(fileName, students);

// Display student data from file

System.out.println("\nDisplaying student data from file:");

displayStudentDataFromFile(fileName);

}
OUTPUT:

File :
EXP9: STUDY AND IMPLEMENT MULTI-THREADED APPLICATION IN JAVA

Write a Java program to demonstrate how to create and start a thread using both theThread
class and the Runnable interface.

// Using Thread class to create a thread

class MyThread extends Thread {

public void run() {

System.out.println("Thread using Thread class is running");

// Using Runnable interface to create a thread

class MyRunnable implements Runnable {

public void run() {

System.out.println("Thread using Runnable interface is running");

}
}

public class ThreadDemo {

public static void main(String[] args) {

// Creating a thread using Thread class

MyThread thread1 = new MyThread();

thread1.start(); // Start the thread

// Creating a thread using Runnable interface

MyRunnable myRunnable = new MyRunnable();

Thread thread2 = new Thread(myRunnable);

thread2.start(); // Start the thread
}

Output:

Write a Java program that illustrates thread synchronization by ensuring multiple threads can
safely access a shared resource without causing data inconsistency.
class Counter {

private int count = 0;

// Synchronized method to ensure thread-safe increment of count

public synchronized void increment() {

count++;

public int getCount() {

 return count;

class MyThread extends Thread {

Counter counter;

MyThread(Counter counter) {

this.counter = counter;

public void run() {

// Increment the counter 1000 times

for (int i = 0; i < 1000; i++) {

counter.increment();

public class ThreadSynchronizationDemo {

public static void main(String[] args) {

Counter counter = new Counter();

// Create multiple threads that will increment the counter

MyThread thread1 = new MyThread(counter);

MyThread thread2 = new MyThread(counter);

thread1.start();
thread2.start();
 try {

// Wait for both threads to finish

thread1.join();
thread2.join();

} catch (InterruptedException e) {

e.printStackTrace();

// Display the final value of count

System.out.println("Final count value: " + counter.getCount());

}
}

Output:

EXP10: GUI PROGRAMMING USING JAVA APPLET/SWINGS COMPONENTS AND

EVENT HANDLING

import javax.swing.*;

import java.awt.event.*;

public class WindowEventDemo extends JFrame implements WindowListener {

// Constructor to set up the window and add listener

public WindowEventDemo() {

// Set the window title

setTitle("Window Event Handling Demo");

 // Set the size of the window

setSize(400, 300);

// Add a window listener to handle window events

addWindowListener(this);

// Set default close operation

setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);

// Set window visible

setVisible(true);
}

// Implement the required methods from WindowListener interface

@Override

public void windowOpened(WindowEvent e) {

System.out.println("Window opened.");

@Override

public void windowClosing(WindowEvent e) {

System.out.println("Window is closing.");

// To close the window programmatically, you can use:

// System.exit(0);

dispose(); // or close the window

}

@Override
 public void windowClosed(WindowEvent e) {

System.out.println("Window closed.");

@Override

public void windowIconified(WindowEvent e) {

System.out.println("Window minimized.");

@Override

public void windowDeiconified(WindowEvent e) {

System.out.println("Window restored.");
}

@Override

public void windowActivated(WindowEvent e) {

System.out.println("Window activated.");

@Override

public void windowDeactivated(WindowEvent e) {

System.out.println("Window deactivated.");

public static void main(String[] args) {

// Create an instance of WindowEventDemo

new WindowEventDemo();

}
}
OUTPUT:

WINDOWS: