JAVA PRACTICALS CODE AND OUTPUT

Practical No.3 :

Write any program to check multiple Conditions using if statement.

public class MultipleConditionCheck {

public static void main(String[] args) {

int x = 10;

int y = 5;

// Checking multiple conditions

if (x > y) {

System.out.println("x is greater than y");

if (x < 15) {

System.out.println("x is less than 15");

if (y != 0) {
 System.out.println("y is not equal to zero");

if (x % 2 == 0) {

System.out.println("x is even");

OUTPUT :

x is greater than y

x is less than 15

y is not equal to zero

x is even

Practical No.4 :

Write any program using switch case statement.

import java.util.Scanner;

public class DayOfWeek {

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);

System.out.print("Enter a day number (1-7): ");

int dayNumber = scanner.nextInt();

String dayName;

switch (dayNumber) {

case 1:

dayName = "Sunday";

break;

case 2:

dayName = "Monday";

break;

case 3:

dayName = "Tuesday";

break;

case 4:
 dayName = "Wednesday";

break;

case 5:

dayName = "Thursday";

break;

case 6:

dayName = "Friday";

break;

case 7:

dayName = "Saturday";

break;

default:

dayName = "Invalid day number";

break;

System.out.println("The day is: " + dayName);

scanner.close();

}
OUTPUT :

Enter a day number (1-7): 3

The day is: Tuesday

Practical No.5 :

Develop a program to print command line argument using for loop.

public class CommandLineArguments {

public static void main(String[] args) {

System.out.println("Command Line Arguments:");

// Loop through each command-line argument

for (int i = 0; i < args.length; i++) {

System.out.println("Argument " + (i + 1) + ": " + args[i]);

 }

OUTPUT :

java CommandLineArguments arg1 arg2 arg3

Command Line Arguments:

Argument 1: arg1

Argument 2: arg2

Argument 3: arg3

PRACTICAL NO.6 :

Develop a program to use logical operators in do-while loop.

import java.util.Scanner;

public class DoWhileWithLogicalOperators {

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);

char choice;

do {

System.out.println("Enter two numbers:");

int num1 = scanner.nextInt();

int num2 = scanner.nextInt();

System.out.println("Select operation (+, -, *, /):");

char operator = scanner.next().charAt(0);

double result;

// Perform calculation based on operator

switch (operator) {

case '+':

result = num1 + num2;

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

break;

case '-':

result = num1 - num2;

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

break;

case '*':

result = num1 * num2;

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

break;

case '/':

if (num2 != 0) {

result = (double) num1 / num2;

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

} else {

System.out.println("Cannot divide by zero!");

break;

default:

System.out.println("Invalid operator!");

break;

}
 // Prompt the user to continue or not

System.out.println("Do you want to perform another operation? (y/n)");

choice = scanner.next().charAt(0);

} while (choice == 'y' || choice == 'Y');

scanner.close();

OUTPUT :

Enter two numbers:

Select operation (+, -, *, /):

Result: 8.0

Do you want to perform another operation? (y/n)

y

Enter two numbers:

10

Select operation (+, -, *, /):

Result: 5.0

Do you want to perform another operation? (y/n)

PRACTICAL NO. 7 & 8 :

Develop a program to show the use of implicit typecasting.

public class ImplicitTypeCasting {

public static void main(String[] args) {

// Implicit typecasting from int to double

int intValue = 10;

 double doubleValue = intValue; // int promoted to double

System.out.println("int value: " + intValue);

System.out.println("double value: " + doubleValue);

// Implicit typecasting from float to double

float floatValue = 20.5f;

double doubleValue2 = floatValue; // float promoted to double

System.out.println("float value: " + floatValue);

System.out.println("double value: " + doubleValue2);

OUTPUT :

int value: 10

double value: 10.0

float value: 20.5

double value: 20.5

PRACTICAL NO.9 :

Develop a program to show the use of explicit type casting.

public class ExplicitTypeCasting {

public static void main(String[] args) {

// Explicit type casting from double to int

double doubleValue = 10.5;

int intValue = (int) doubleValue; // double explicitly casted to int

System.out.println("double value: " + doubleValue);

System.out.println("int value: " + intValue);

// Explicit type casting from double to float

double doubleValue2 = 20.7;

float floatValue = (float) doubleValue2; // double explicitly casted to float

System.out.println("double value: " + doubleValue2);

System.out.println("float value: " + floatValue);

}
OUTPUT :

double value: 10.5

int value: 10

double value: 20.7

float value: 20.7

PRACTICAL NO.10 :

Demonstrate the use of at least two types of constructors.

public class Car {

private String make;

private String model;

private int year;

// Default constructor

public Car() {

make = "Unknown";

model = "Unknown";

year = 0;

// Parameterized constructor

public Car(String make, String model, int year) {

this.make = make;

this.model = model;

this.year = year;

// Method to display car details

public void displayDetails() {

System.out.println("Make: " + make);

System.out.println("Model: " + model);

System.out.println("Year: " + year);

}
 public static void main(String[] args) {

// Creating objects using both constructors

Car car1 = new Car(); // Using default constructor

Car car2 = new Car("Toyota", "Camry", 2022); // Using parameterized

constructor

// Displaying details of both cars

System.out.println("Details of Car 1:");

car1.displayDetails();

System.out.println();

System.out.println("Details of Car 2:");

car2.displayDetails();

OUTPUT :

Details of Car 1:

Make: Unknown
Model: Unknown

Year: 0

Details of Car 2:

Make: Toyota

Model: Camry

Year: 2022

PRACTICAL NO.11 & 12 :

Write a program to show the use of all methods of string class.

public class StringMethodsExample {

public static void main(String[] args) {

// Declaring a string

String str = "Hello, World!";

// 1. length(): returns the length of the string

 System.out.println("Length of the string: " + str.length());

// Output: Length of the string: 13

// 2. charAt(int index): returns the character at the specified index

System.out.println("Character at index 7: " + str.charAt(7));

// Output: Character at index 7: W

// 3. substring(int beginIndex): returns a substring starting from the specified

index

System.out.println("Substring from index 7: " + str.substring(7));

// Output: Substring from index 7: World!

// 4. substring(int beginIndex, int endIndex): returns a substring within the

specified range

System.out.println("Substring from index 7 to 12: " + str.substring(7, 12));

// Output: Substring from index 7 to 12: World

// 5. contains(CharSequence s): checks if the string contains the specified

sequence

System.out.println("Does the string contain 'World'? " +

str.contains("World"));

// Output: Does the string contain 'World'? true

 // 6. equals(Object another): checks if two strings are equal

String str2 = "Hello, World!";

System.out.println("Are the strings equal? " + str.equals(str2));

// Output: Are the strings equal? true

// 7. toLowerCase(): converts the string to lowercase

System.out.println("Lowercase string: " + str.toLowerCase());

// Output: Lowercase string: hello, world!

// 8. toUpperCase(): converts the string to uppercase

System.out.println("Uppercase string: " + str.toUpperCase());

// Output: Uppercase string: HELLO, WORLD!

// 9. trim(): removes leading and trailing whitespaces

String str3 = " Hello, World! ";

System.out.println("Trimmed string: '" + str3.trim() + "'");

// Output: Trimmed string: 'Hello, World!'

// 10. indexOf(int ch): returns the index of the first occurrence of the
specified character

System.out.println("Index of 'o': " + str.indexOf('o'));

// Output: Index of 'o': 4

 // 11. lastIndexOf(int ch): returns the index of the last occurrence of the
specified character

System.out.println("Last index of 'o': " + str.lastIndexOf('o'));

// Output: Last index of 'o': 8

// 12. replace(CharSequence target, CharSequence replacement): replaces

occurrences of the target sequence with the replacement sequence

System.out.println("Replace 'World' with 'Java': " + str.replace("World",

"Java"));

// Output: Replace 'World' with 'Java': Hello, Java!

// 13. split(String regex): splits the string using the specified regular
expression

String[] parts = str.split(",");

System.out.println("Splitting the string: ");

for (String part : parts) {

System.out.println(part.trim());

/* Output:

Splitting the string:

Hello

World!
 */

// 14. startsWith(String prefix): checks if the string starts with the specified
prefix

System.out.println("Does the string start with 'Hello'? " +

str.startsWith("Hello"));

// Output: Does the string start with 'Hello'? true

// 15. endsWith(String suffix): checks if the string ends with the specified
suffix

System.out.println("Does the string end with 'World'? " +

str.endsWith("World"));

// Output: Does the string end with 'World'? false

// 16. isEmpty(): checks if the string is empty

System.out.println("Is the string empty? " + str.isEmpty());

// Output: Is the string empty? false

OUTPUT :
//Output is provided in the code itself in the form of comments.

PRACTICAL NO.13 :

Write a program to implement multidimensional array.

public class MultiDimensionalArrayExample {

public static void main(String[] args) {

// Declaring and initializing a 2D array

int[][] matrix = {

{1, 2, 3},

{4, 5, 6},

{7, 8, 9}

};

// Accessing elements of the 2D array using nested loops

System.out.println("Elements of the 2D array:");

 for (int i = 0; i < matrix.length; i++) {

for (int j = 0; j < matrix[i].length; j++) {

System.out.print(matrix[i][j] + " ");

System.out.println(); // Move to the next line after printing each row

OUTPUT :

Elements of the 2D array:

123

456

789

PRACTICAL NO.14 :
Write a program to insert different elements in the Vector and display
them.

import java.util.Vector;

public class VectorExample {

public static void main(String[] args) {

// Creating a Vector

Vector<Object> vector = new Vector<>();

// Inserting elements into the Vector

vector.add("Hello");

vector.add(123);

vector.add(3.14);

vector.add(true);

// Displaying elements of the Vector

System.out.println("Elements of the Vector:");

for (Object element : vector) {

System.out.println(element);

}
 }

OUTPUT :

Elements of the Vector:

Hello

123

3.14

true

PRACTICAL NO.15 & 16 :

Write a Program to show the use of Integer Wrapper class Methods.

public class IntegerWrapperExample {

 public static void main(String[] args) {

// Creating Integer objects

Integer num1 = 10;

Integer num2 = 20;

// intValue(): returns the value of the Integer object as an int

int value1 = num1.intValue();

System.out.println("Value of num1: " + value1);

// compareTo(Integer anotherInteger): compares two Integer objects

numerically

int comparison = num1.compareTo(num2);

System.out.println("Comparison result: " + comparison);

// max(Integer a, Integer b): returns the greater of two Integer objects

Integer max = Integer.max(num1, num2);

System.out.println("Max value: " + max);

// min(Integer a, Integer b): returns the smaller of two Integer objects

Integer min = Integer.min(num1, num2);

System.out.println("Min value: " + min);

 // parseInt(String s): parses the string argument as a signed decimal integer

String str = "123";

int parsedValue = Integer.parseInt(str);

System.out.println("Parsed value: " + parsedValue);

// toString(int i): returns a String object representing the specified integer

String strValue = Integer.toString(parsedValue);

System.out.println("String representation: " + strValue);

// valueOf(int i): returns an Integer instance representing the specified int

value

Integer integerValue = Integer.valueOf(parsedValue);

System.out.println("Integer value: " + integerValue);

// hashCode(): returns the hash code value for this Integer object

int hashCode = integerValue.hashCode();

System.out.println("Hash code: " + hashCode);

// equals(Object obj): compares this Integer object to the specified object

boolean isEqual = num1.equals(num2);

System.out.println("Are num1 and num2 equal? " + isEqual);

}
}

OUTPUT :

Value of num1: 10

Comparison result: -1

Max value: 20

Min value: 10

Parsed value: 123

String representation: 123

Integer value: 123

Hash code: 123

Are num1 and num2 equal? false

PRACTICAL NO.17 :

Demonstrate the use of Overriding method display( ) using Super and

Sub classes.
// Superclass

class SuperClass {

// Method to display message

public void display() {

System.out.println("This is the display method of the superclass");

// Subclass extending SuperClass

class SubClass extends SuperClass {

// Overriding the display method

@Override

public void display() {

// Calling the superclass display method using super

super.display();

System.out.println("This is the display method of the subclass");

public class MethodOverrideExample {

 public static void main(String[] args) {

// Creating an object of the subclass

SubClass subObj = new SubClass();

// Calling the display method of the subclass

subObj.display();

OUTPUT :

This is the display method of the superclass

This is the display method of the subclass

PRACTICAL NO.18 :

Write a program to implement single and multilevel inheritance.

// Superclass

class Animal {

// Method to print a message

public void eat() {

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

// Subclass inheriting from Animal (Single Inheritance)

class Dog extends Animal {

// Method to print a message

public void bark() {

System.out.println("Dog is barking");

// Subclass inheriting from Dog (Multilevel Inheritance)

class Labrador extends Dog {

// Method to print a message

public void color() {

 System.out.println("Labrador is brown in color");

public class InheritanceExample {

public static void main(String[] args) {

// Single Inheritance

Dog dog = new Dog();

dog.eat(); // Accessing method from Animal class

dog.bark(); // Accessing method from Dog class

System.out.println();

// Multilevel Inheritance

Labrador labrador = new Labrador();

labrador.eat(); // Accessing method from Animal class

labrador.bark(); // Accessing method from Dog class

labrador.color(); // Accessing method from Labrador class

}
OUTPUT :

Animal is eating

Dog is barking

Animal is eating

Dog is barking

Labrador is brown in color

PRACTICAL NO.19 :

Demonstrate the use of interfaces to implemnet the concept of multiple

inheritance.

// First interface

interface Animal {

void eat(); // Abstract method

}

// Second interface

interface Vehicle {

void drive(); // Abstract method

// Class implementing both interfaces

class AnimalVehicle implements Animal, Vehicle {

// Implementation of eat() method from Animal interface

@Override

public void eat() {

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

// Implementation of drive() method from Vehicle interface

@Override

public void drive() {

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

}
public class MultipleInheritanceExample {

public static void main(String[] args) {

// Creating an object of class AnimalVehicle

AnimalVehicle animalVehicle = new AnimalVehicle();

// Calling methods from both interfaces

animalVehicle.eat();

animalVehicle.drive();

OUTPUT :

AnimalVehicle is eating

AnimalVehicle is driving

PRACTICAL NO.20 :
Write a program to implement user defined packages in terms of
creating a new package and importing the same.

package mypackage;

public class MyClass {

public void display() {

System.out.println("This is MyClass in mypackage");

/*Now, let's create another Java file outside the mypackage directory to
demonstrate how to use this package.*/

import mypackage.MyClass;

public class PackageDemo {

public static void main(String[] args) {

// Create an object of MyClass from the mypackage package

MyClass obj = new MyClass();

 // Call the display method of MyClass

obj.display();

/*To compile and run these files:

Open terminal/command prompt.

Navigate to the directory containing both files.

Compile the files using the following commands:*/

javac mypackage/MyClass.java

javac PackageDemo.java

//Run the program using the command://

java PackageDemo

OUTPUT :
This is MyClass in mypackage

PRACTICAL NO.21 & 22 :

Develop a simple real-life application program to illustrate the use of

multithreads.

import java.util.concurrent.*;

// Class representing a cafe order

class Order {

private String itemName;

public Order(String itemName) {

this.itemName = itemName;

// Method to prepare the order

 public void prepareOrder() {

System.out.println("Preparing order for: " + itemName);

try {

// Simulate order preparation time

Thread.sleep(2000);

} catch (InterruptedException e) {

e.printStackTrace();

System.out.println("Order for: " + itemName + " is ready");

// Class representing a cafe staff member who processes orders

class CafeStaff implements Runnable {

private Order order;

public CafeStaff(Order order) {

this.order = order;

@Override

public void run() {

 order.prepareOrder();

public class CafeSimulation {

public static void main(String[] args) {

// Create a thread pool with 3 threads

ExecutorService executor = Executors.newFixedThreadPool(3);

// Create some cafe orders

Order order1 = new Order("Coffee");

Order order2 = new Order("Sandwich");

Order order3 = new Order("Cake");

// Assign orders to cafe staff members

CafeStaff staff1 = new CafeStaff(order1);

CafeStaff staff2 = new CafeStaff(order2);

CafeStaff staff3 = new CafeStaff(order3);

// Submit orders to the thread pool

executor.submit(staff1);

executor.submit(staff2);
 executor.submit(staff3);

// Shut down the executor after all tasks are completed

executor.shutdown();

OUTPUT :

Preparing order for: Coffee

Preparing order for: Sandwich

Preparing order for: Cake

Order for: Coffee is ready

Order for: Sandwich is ready

Order for: Cake is ready

PRACTICAL NO.23, 24 & 25 :

Demonstrates exception handling using try,catch and finally block.

import java.util.Scanner;

public class ExceptionHandlingExample {

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);

try {

// Prompt the user to enter two numbers

System.out.print("Enter the first number: ");

int num1 = scanner.nextInt();

System.out.print("Enter the second number: ");

int num2 = scanner.nextInt();

// Perform division operation

int result = num1 / num2;

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

} catch (ArithmeticException e) {

// Catch block to handle ArithmeticException

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

} catch (Exception e) {

// Catch block to handle other exceptions

System.out.println("An error occurred: " + e.getMessage());

} finally {

// Finally block to close the scanner and perform cleanup

scanner.close();

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

OUTPUT :

Enter the first number: 10

Enter the second number: 2

Result of division: 5

Scanner closed.
PRACTICAL NO.26 & 27 :

Demonstrate use of throw and throws clause.

USING THROW :

class AgeValidationException extends Exception {

public AgeValidationException(String message) {

super(message);

class Voter {

public void validateAge(int age) throws AgeValidationException {

if (age < 18) {

throw new AgeValidationException("Age must be 18 or above to vote.");

System.out.println("Age validated successfully. You are eligible to vote.");

 }

public class ThrowAndThrowsExample {

public static void main(String[] args) {

Voter voter = new Voter();

try {

voter.validateAge(17);

} catch (AgeValidationException e) {

System.out.println("Error: " + e.getMessage());

OUTPUT :

Error: Age must be 18 or above to vote.

USING THROWS :
import java.io.FileNotFoundException;

import java.io.FileReader;

public class ThrowsExample {

public static void readFile(String filename) throws FileNotFoundException {

FileReader fileReader = new FileReader(filename);

System.out.println("File " + filename + " opened successfully.");

public static void main(String[] args) {

try {

readFile("example.txt");

} catch (FileNotFoundException e) {

System.out.println("Error: File not found.");

}
OUTPUT :

Error: File not found.

PRACTICAL NO.28 :

Create two applets by using different ways in java.

Approach 1: Extending the java.applet.Applet class

import java.applet.Applet;

import java.awt.Graphics;

public class SimpleApplet extends Applet {

public void paint(Graphics g) {

g.drawString("Hello, World!", 20, 20);

 }

OUTPUT :

typically need to embed them in an HTML file

Approach 2: Implementing the java.applet.Applet interface

import java.applet.Applet;

import java.awt.Graphics;

public class AnotherApplet implements Applet {

public void init() {

// Initialization code

public void start() {

 // Start code

public void stop() {

// Stop code

public void destroy() {

// Cleanup code

public void paint(Graphics g) {

g.drawString("Hello from Another Applet!", 20, 20);

OUTPUT :

typically need to embed them in an HTML file

PRACTICAL NO.29 :

Write a program to implement an applet to draw basic animated

shapes.

import java.applet.Applet;

import java.awt.Color;

import java.awt.Graphics;

public class AnimatedShapesApplet extends Applet implements Runnable {

private int x = 0; // Initial x-coordinate of the circle

private int y = 50; // y-coordinate of the circle

public void init() {

setBackground(Color.white);

}
public void start() {

Thread t = new Thread(this);

t.start(); // Start the thread

public void run() {

try {

while (true) {

// Move the circle to the right

x += 5;

// Repaint the applet window

repaint();

// Pause for a moment

Thread.sleep(100);

} catch (InterruptedException e) {

e.printStackTrace();

}
 public void paint(Graphics g) {

// Draw the circle at (x, y)

g.setColor(Color.blue);

g.fillOval(x, y, 30, 30);

OUTPUT :

need to embed it in an HTML file and open it in a browser.

PRACTICAL NO.30 :

Demonstrate the use of basic applet,which includes different shapes

like cone,cube,cylinders,etc.

import java.applet.Applet;
import java.awt.Color;

import java.awt.Graphics;

public class BasicShapesApplet extends Applet {

public void paint(Graphics g) {

// Draw cone

g.setColor(Color.red);

g.fillArc(50, 50, 100, 100, 0, 180);

g.drawLine(50, 100, 100, 200);

g.drawLine(150, 100, 100, 200);

// Draw cube

g.setColor(Color.green);

g.fillRect(200, 50, 100, 100);

g.fillRect(250, 100, 100, 100);

g.drawLine(200, 50, 250, 100);

g.drawLine(300, 50, 350, 100);

g.drawLine(200, 150, 250, 200);

g.drawLine(300, 150, 350, 200);

// Draw cylinder

g.setColor(Color.blue);
 g.fillOval(400, 50, 100, 50);

g.fillOval(400, 150, 100, 50);

g.fillRect(400, 75, 100, 75);

g.fillRect(400, 50, 100, 50);

g.fillRect(400, 150, 100, 50);

g.setColor(Color.white);

g.drawLine(400, 75, 400, 150);

g.drawLine(500, 75, 500, 150);

OUTPUT :

embed this applet in an HTML file to view Output.

PRACTICAL NO.31 & 32 :

Demonstrate the use of stream classes for reading and writing
bytes/characters.

Reading and Writing Bytes:

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

public class ByteStreamExample {

public static void main(String[] args) {

try {

// Writing bytes to a file

FileOutputStream outputStream = new FileOutputStream("output.txt");

outputStream.write("Hello, World!".getBytes());

outputStream.close();

// Reading bytes from a file

FileInputStream inputStream = new FileInputStream("output.txt");

int data;
 while ((data = inputStream.read()) != -1) {

System.out.print((char) data);

inputStream.close();

} catch (IOException e) {

e.printStackTrace();

OUTPUT :

Hello, World!

Reading and Writing Characters:

import java.io.FileReader;

import java.io.FileWriter;
import java.io.IOException;

public class CharacterStreamExample {

public static void main(String[] args) {

try {

// Writing characters to a file

FileWriter writer = new FileWriter("output.txt");

writer.write("Hello, World!");

writer.close();

// Reading characters from a file

FileReader reader = new FileReader("output.txt");

int data;

while ((data = reader.read()) != -1) {

System.out.print((char) data);

reader.close();

} catch (IOException e) {

e.printStackTrace();

}
OUTPUT :

Hello, World!