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
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.
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);
}
}

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).");
}
}
}

--------------------------------------------------------------------------------------------------------------
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.");
}
}
}

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 + " ");
}
}
}

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];
 j++;
}
k++;
}

while (i < n1) {

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

while (j < n2) {

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

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!"

}
}

----------------------------------------------------------------------------------------------------------------
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!");
}
}

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);
}
}

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);
}
}

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) {
System.out.println("String message: " + message);
}

public void displayMessage(int number) {

System.out.println("Integer number: " + number);
}
}

---------------------------------------------------------------------------------------------------------------
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();
}
}

b) Implement a Java program using multilevel inheritance:

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

class Parent extends Grandparent {

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();
}
}

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();
square.draw();
}
}

----------------------------------------------------------------------------------------------------------------
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();
}
}

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();
}
}

----------------------------------------------------------------------------------------------------------------
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
}
}

----------------------------------------------------------------------------------------------------------------
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());
}
}
}

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());
}
}
}

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());
} finally {
System.out.println("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());
}
}
}

-------------------------------------------------------------------------------------------------------------
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();
}
}

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.");

}
}

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.");

}
}

------------------------------------------------------------------------------------------------------------
 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();
}
}

----------------------------------------------------------------------------------------------------------------
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);
}
}
}

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);
}
}

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