20EC5S12` JAVA PROGRAMMING

(Skill Oriented Course)

List of Experiments:
Exercise - 1 (Basics)
a) Write a JAVA program to display default value of all primitive data type of JAVA
b) Write a java program that display the roots of a quadratic equation ax2+bx=0.
Calculate the discriminate D and basing on value of D, describe the nature of root.
Exercise - 2 (Operations, Expressions, Control-flow, Strings)
a) Write a JAVA program to search for an element in a given list of elements using binary search
mechanism.
b) Write a JAVA program to sort for an element in a given list of elements using bubble sort
c) Write a JAVA program to sort for an element in a given list of elements using merge sort.
d) Write a JAVA program using String Buffer to delete, remove character.
Exercise - 3 (Class, Objects)
Implement java programs using the concept of
a) Class mechanism. Create a class, methods and invoke them inside main method.
b) Constructor.
c) Constructor overloading.
d) Method overloading.
Exercise -4 (Inheritance)
Implement java programs using the concept of
a) Single Inheritance
b) Multilevel Inheritance
c) Abstract class
Exercise - 5 (Inheritance - Continued)
Implement java programs using the concept of
a)“super” keyword. b) Interfaces
Exercise – 6 (Runtime Polymorphism)
a) Write a JAVA program that implements Runtime polymorphism
Exercise – 7 (Exception)
Implement the programs by using the concepts of

1|Page
a. Exception handling mechanism
b. Multiple catch clauses
c. Finally
d. Creating user defined exceptions
Exercise – 8 (Threads)
a) Write a JAVA program that creates threads by extending Thread class. First thread displays
“Good Morning” every 1 sec, the second thread displays “Hello” every 2 seconds and the third
display “Welcome” every 3 seconds,(Repeat the same by implementing Runnable)
b) Write a program illustrating isAlive and join ()
c) Write a Program illustrating Daemon Threads.
Exercise – 9 (Packages)
a) Create a user defined package and demonstrate different ways of importing packages
Exercise - 10 (Applet)
a) Write a JAVA program to paint like paint brush in applet.
b) Write a JAVA program to create different shapes and fill colors using Applet.

2|Page
Exercise 1 (Basics)
a) Display default values of all primitive data types in Java:

public class DefaultValues {

public static void main(String[] args) {
byte byteDefault = 0;
short shortDefault = 0;
int intDefault = 0;
long longDefault = 0L;
float floatDefault = 0.0f;
double doubleDefault = 0.0;
char charDefault = '\u0000';
boolean booleanDefault = false;

System.out.println("Default values:");
System.out.println("byte: " + byteDefault);
System.out.println("short: " + shortDefault);
System.out.println("int: " + intDefault);
System.out.println("long: " + longDefault);
System.out.println("float: " + floatDefault);
System.out.println("double: " + doubleDefault);
System.out.println("char: " + charDefault);
System.out.println("boolean: " + booleanDefault);
}
}

Output:
Default values:
byte: 0
short: 0
int: 0
long: 0
float: 0.0
double: 0.0
char:
boolean: false

3|Page
b) Display roots of a quadratic equation and describe their nature:
import java.util.Scanner;

public class QuadraticEquation {

public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print("Enter the values of a, b, and c: ");
double a = input.nextDouble();
double b = input.nextDouble();
double c = input.nextDouble();

double discriminant = b * b - 4 * a * c;

if (discriminant > 0) {
double root1 = (-b + Math.sqrt(discriminant)) / (2 * a);
double root2 = (-b - Math.sqrt(discriminant)) / (2 * a);
System.out.println("Two distinct real roots: " + root1 + " and " + root2);
} else if (discriminant == 0) {
double root = -b / (2 * a);
System.out.println("One real root: " + root);
} else {
System.out.println("No real roots (complex roots).");
}
}
}

Output:
Enter the values of a, b, and c: 1 2 3
No real roots (complex roots).

--------------------------------------------------------------------------------------------------------------

4|Page
Exercise 2 (Operations, Expressions, Control-flow, Strings)
a) Search for an element in a list using binary search:
import java.util.Arrays;

public class BinarySearch {

public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9};
int target = 6;

int result = Arrays.binarySearch(arr, target);

if (result >= 0) {
System.out.println("Element " + target + " found at index " + result);
} else {
System.out.println("Element " + target + " not found in the array.");
}
}
}

Output:
Element 6 found at index 5

b) Sort a list of elements using bubble sort:

public class BubbleSort {
public static void main(String[] args) {
int[] arr = {5, 2, 9, 3, 6, 1};

for (int i = 0; i < arr.length - 1; i++) {

for (int j = 0; j < arr.length - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}

System.out.println("Sorted array using Bubble Sort:");

for (int num : arr) {
System.out.print(num + " ");
}
}
}

5|Page
Output:
Sorted array using Bubble Sort:
123569

c) Sort a list of elements using merge sort (recursive):

import java.util.Arrays;

public class MergeSort {

public static void main(String[] args) {
int[] arr = {5, 2, 9, 3, 6, 1};

mergeSort(arr, 0, arr.length - 1);

System.out.println("Sorted array using Merge Sort:");

for (int num : arr) {
System.out.print(num + " ");
}
}

public static void mergeSort(int[] arr, int left, int right) {

if (left < right) {
int middle = (left + right) / 2;
mergeSort(arr, left, middle);
mergeSort(arr, middle + 1, right);
merge(arr, left, middle, right);
}
}

public static void merge(int[] arr, int left, int middle, int right) {
int n1 = middle - left + 1;
int n2 = right - middle;

int[] L = Arrays.copyOfRange(arr, left, left + n1);

int[] R = Arrays.copyOfRange(arr, middle + 1, middle + 1 + n2);

int i = 0, j = 0, k = left;
while (i < n1 && j < n2) {
if (L[i] <= R[j]) {
arr[k] = L[i];
i++;
} else {
arr[k] = R[j];

6|Page
 j++;
}
k++;
}

while (i < n1) {

arr[k] = L[i];
i++;
k++;
}

while (j < n2) {

arr[k] = R[j];
j++;
k++;
}
}
}

Output:
Sorted array using Merge Sort:
123569

d) Use StringBuffer to delete or remove characters:

public class StringBufferExample {
public static void main(String[] args) {
StringBuffer str = new StringBuffer("Hello, World!");

// Delete a character at a specific index

str.deleteCharAt(5); // Deletes ','

// Remove a range of characters

str.delete(0, 5); // Removes "Hello"

System.out.println(str); // Output: " World!"

}
}

Output:
World!

----------------------------------------------------------------------------------------------------------------

7|Page
Exercise 3 (Class, Objects)
a) Implement a Java program using the class mechanism:
public class MyClass {
public static void main(String[] args) {
MyObject myObj = new MyObject();
myObj.displayMessage();
}
}

class MyObject {
public void displayMessage() {
System.out.println("Hello from MyObject class!");
}
}

Output:
Hello from MyObject class!

b) Implement a Java program using constructors:

public class ConstructorExample {
public static void main(String[] args) {
MyObject obj = new MyObject("Hello, Constructor!");
obj.displayMessage();
}
}

class MyObject {
private String message;

public MyObject(String msg) {

message = msg;
}

public void displayMessage() {

System.out.println(message);
}
}

Output:
Hello, Constructor

8|Page
c) Implement a Java program using constructor overloading:
public class ConstructorOverloadingExample {
public static void main(String[] args) {
MyObject obj1 = new MyObject();
MyObject obj2 = new MyObject("Hello, Constructor!");

obj1.displayMessage();
obj2.displayMessage();
}
}

class MyObject {
private String message;

// Default constructor
public MyObject() {
message = "Default Message";
}

// Parameterized constructor
public MyObject(String msg) {
message = msg;
}

public void displayMessage() {

System.out.println(message);
}
}

Output:
Default Message
Hello, Constructor!
d) Implement a Java program using method overloading:
public class MethodOverloadingExample {
public static void main(String[] args) {
MyObject obj = new MyObject();
obj.displayMessage("Hello, Method Overloading!");
obj.displayMessage(42);
}
}

class MyObject {
public void displayMessage(String message) {

9|Page
 System.out.println("String message: " + message);
}

public void displayMessage(int number) {

System.out.println("Integer number: " + number);
}
}
Output:
String message: Hello, Method Overloading! Integer number: 42

----------------------------------------------------------------------------------------------------------

Exercise 4 (Inheritance)
a) Implement a Java program using single inheritance:
class Parent {
void displayParent() {
System.out.println("This is the parent class.");
}
}

class Child extends Parent {

void displayChild() {
System.out.println("This is the child class.");
}

public static void main(String[] args) {

Child childObj = new Child();
childObj.displayParent();
childObj.displayChild();
}
}
Output:
This is the parent class.
This is the child class.

b) Implement a Java program using multilevel inheritance:

class Grandparent {
void displayGrandparent() {
System.out.println("This is the grandparent class.");
}
}

class Parent extends Grandparent {

10 | P a g e
 void displayParent() {
System.out.println("This is the parent class.");
}
}

class Child extends Parent {

void displayChild() {
System.out.println("This is the child class.");
}

public static void main(String[] args) {

Child childObj = new Child();
childObj.displayGrandparent();
childObj.displayParent();
childObj.displayChild();
}
}
Output:
This is the parent class.
This is the child class.

c) Implement a Java program using an abstract class:

abstract class Shape {
abstract void draw();
}

class Circle extends Shape {

void draw() {
System.out.println("Drawing a Circle");
}
}

class Square extends Shape {

void draw() {
System.out.println("Drawing a Square");
}
}

public class AbstractExample {

public static void main(String[] args) {
Shape circle = new Circle();
Shape square = new Square();

circle.draw();

11 | P a g e
 square.draw();
}
}
Output:
Drawing a Circle
Drawing a Square

----------------------------------------------------------------------------------------------------------------

Exercise 5 (Inheritance - Continued)

a) Implement a Java program using the "super" keyword:
class Parent {
String message = "Hello from Parent";

void display() {
System.out.println(message);
}
}

class Child extends Parent {

String message = "Hello from Child";

void display() {
super.display(); // Using "super" to call the parent class method
System.out.println(message);
}

public static void main(String[] args) {

Child childObj = new Child();
childObj.display();
}
}

Output:
Hello from Parent
Hello from Child

12 | P a g e
b) Implement a Java program using interfaces:
interface Shape {
void draw();
}

class Circle implements Shape {

public void draw() {
System.out.println("Drawing a Circle");
}
}

class Rectangle implements Shape {

public void draw() {
System.out.println("Drawing a Rectangle");
}
}

public class InterfaceExample {

public static void main(String[] args) {
Shape circle = new Circle();
Shape rectangle = new Rectangle();

circle.draw();
rectangle.draw();
}
}

Output:
Drawing a Circle
Drawing a Rectangle

----------------------------------------------------------------------------------------------------------------

13 | P a g e
Exercise 6 (Runtime Polymorphism)
a) Write a Java program that implements runtime polymorphism (method overriding):
class Animal {
void makeSound() {
System.out.println("Some sound");
}
}

class Dog extends Animal {

void makeSound() {
System.out.println("Woof! Woof!");
}
}

class Cat extends Animal {

void makeSound() {
System.out.println("Meow!");
}
}

public class PolymorphismExample {

public static void main(String[] args) {
Animal dog = new Dog();
Animal cat = new Cat();

dog.makeSound(); // Calls Dog's makeSound method

cat.makeSound(); // Calls Cat's makeSound method
}
}

Output:
Woof! Woof!
Meow!

----------------------------------------------------------------------------------------------------------------

14 | P a g e
Exercise 7 (Exception)
a) Implement a Java program using exception handling:
public class ExceptionHandlingExample {
public static void main(String[] args) {
try {
int result = 10 / 0; // Attempt to divide by zero
System.out.println("Result: " + result);
} catch (ArithmeticException e) {
System.out.println("Exception caught: " + e.getMessage());
}
}
}
Output:
Exception caught: / by zero

b) Implement a Java program using multiple catch clauses:

public class MultipleCatchExample {
public static void main(String[] args) {
try {
int[] arr = new int[5];
int result = arr[7]; // Accessing an out-of-bounds index
System.out.println("Result: " + result);
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("Array index out of bounds: " + e.getMessage());
} catch (ArithmeticException e) {
System.out.println("Arithmetic exception: " + e.getMessage());
}
}
}

Output:
Array index out of bounds: Index 7 out of bounds for length 5

c) Implement a Java program using the "finally" block:

public class FinallyBlockExample {
public static void main(String[] args) {
try {
int result = 10 / 0; // Attempt to divide by zero
System.out.println("Result: " + result);
} catch (ArithmeticException e) {
System.out.println("Arithmetic exception: " + e.getMessage());

15 | P a g e
 } finally {
System.out.println("Finally block executed.");
}
}
}

Output:
Arithmetic exception: / by zero
Finally block executed.

d) Create a user-defined exception:

class CustomException extends Exception {
public CustomException(String message) {
super(message);
}
}

public class UserDefinedExceptionExample {

public static void main(String[] args) {
try {
int age = 17;
if (age < 18) {
throw new CustomException("Age is below 18.");
}
System.out.println("Age is valid.");
} catch (CustomException e) {
System.out.println("Custom Exception: " + e.getMessage());
}
}
}

Output:
Custom Exception: Age is below 18.

-------------------------------------------------------------------------------------------------------------

16 | P a g e
Exercise 8 (Threads)
a) Create threads by extending the Thread class to display messages at different
intervals:
class DisplayThread extends Thread {
private String message;
private int interval;

public DisplayThread(String message, int interval) {

this.message = message;
this.interval = interval;
}

public void run() {

while (true) {
System.out.println(message);
try {
Thread.sleep(interval * 1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}

public class ThreadExample {

public static void main(String[] args) {
DisplayThread thread1 = new DisplayThread("Good Morning", 1);
DisplayThread thread2 = new DisplayThread("Hello", 2);
DisplayThread thread3 = new DisplayThread("Welcome", 3);

thread1.start();
thread2.start();
thread3.start();
}
}

Output:
Welcome
Good Morning
Hello
Good Morning
Hello

17 | P a g e
Good Morning
Welcome
Good Morning
Hello
Good Morning
Good Morning
^C

b) Write a program illustrating isAlive() and join():

public class ThreadJoinExample {
public static void main(String[] args) {
Thread thread1 = new Thread(() -> {
System.out.println("Thread 1 is running.");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
});

Thread thread2 = new Thread(() -> {

System.out.println("Thread 2 is running.");
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
});

thread1.start();
thread2.start();

try {
thread1.join();
thread2.join();
} catch (InterruptedException e) {
e.printStackTrace();
}

System.out.println("Both threads have completed their execution.");

}
}

18 | P a g e
Output:
Thread 1 is running.
Thread 2 is running.
Both threads have completed their execution.

c) Write a program illustrating Daemon Threads:

public class DaemonThreadExample {
public static void main(String[] args) {
Thread daemonThread = new Thread(() -> {
while (true) {
System.out.println("Daemon thread is running.");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});

daemonThread.setDaemon(true);
daemonThread.start();

try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}

System.out.println("Main thread exiting.");

}
}
Output:
Daemon thread is running.
Daemon thread is running.
Daemon thread is running.
Daemon thread is running.
Daemon thread is running.
Main thread exiting.

------------------------------------------------------------------------------------------------------------

19 | P a g e
 Exercise 9 (Packages)
a) Create a user-defined package and demonstrate different ways of importing
packages:

Create a package named myPackage with a class MyClass inside it:

package myPackage;

public class MyClass {

public void display() {
System.out.println("Hello from MyClass in myPackage.");
}
}

Import the package and use the class in another Java file:

import myPackage.MyClass;

public class PackageExample {

public static void main(String[] args) {
MyClass obj = new MyClass();
obj.display();
}
}

Another way to import the class using a wildcard import:

import myPackage.*;

public class PackageExample {

public static void main(String[] args) {
MyClass obj = new MyClass();
obj.display();
}
}

Output:
Hello from MyClass in myPackage.

----------------------------------------------------------------------------------------------------------------

20 | P a g e
Exercise 10 (Applet)
a) Write a Java program to paint like a paintbrush in an applet:
import java.applet.Applet;
import java.awt.Graphics;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;

public class PaintBrushApplet extends Applet {

int x, y;

public void init() {

x = -1;
y = -1;

addMouseListener(new MouseAdapter() {
public void mousePressed(MouseEvent e) {
x = e.getX();
y = e.getY();
}
});
}

public void paint(Graphics g) {

if (x != -1 && y != -1) {
g.fillOval(x, y, 5, 5);
}
}
}

Output:

Applet

21 | P a g e
b) Write a Java program to create different shapes and fill colors using an applet:
import java.applet.Applet;
import java.awt.Color;
import java.awt.Graphics;

public class ShapesAndColorsApplet extends Applet {

public void paint(Graphics g) {
// Draw a red rectangle
g.setColor(Color.RED);
g.fillRect(20, 20, 80, 40);

// Draw a blue oval

g.setColor(Color.BLUE);
g.fillOval(120, 20, 80, 40);

// Draw a green rounded rectangle

g.setColor(Color.GREEN);
g.fillRoundRect(220, 20, 80, 40, 10, 10);

// Draw a yellow arc

g.setColor(Color.YELLOW);
g.fillArc(320, 20, 80, 40, 45, 180);
}
}

Output:

----------------------------------------------------------------------------------------------------------------

22 | P a g e