3.

i)Read input data from keyboard

import java.util.Scanner; // Needed for Scanner class

/**
* This program demonstrates keyboard input.
*/
public class RectangleArea
{
public static void main(String[] args)
{
int length; // To hold rectangle's length.
int width; // To hold rectangle's width.
int area; // To hold rectangle's area

// Create a Scanner object to read input.

Scanner console = new Scanner(System.in);

// Get length from the user.

System.out.print("Enter length ");
length = console.nextInt();

// Get width from the user.

System.out.print("Enter width ");
width = console.nextInt();

// Calculate area.
area = length * width;

// Display area.
System.out.println("The area of rectangle is " + area);
}
}

ii)

// Java Program to Demonstrate DataOutputStream

// Importing required classes

import java.io.*;

// Main class
// DataOutputStreamDemo
class GFG {
// Main driver method
public static void main(String args[]) throws IOException {
// Try block to check for exceptions
// Writing the data using DataOutputStream
try ( DataOutputStream dout =
new DataOutputStream(new
FileOutputStream("file.dat")) ) {
dout.writeDouble(1.1);
dout.writeInt(55);
dout.writeBoolean(true);
dout.writeChar('4');
}

catch (FileNotFoundException ex) {

System.out.println("Cannot Open the Output File");
 return;
}

// Reading the data back using DataInputStream

try ( DataInputStream din =
new DataInputStream(new
FileInputStream("file.dat")) ) {
double a = din.readDouble();
int b = din.readInt();

boolean c = din.readBoolean();
char d = din.readChar();

System.out.println("Values: " + a + " " + b + " " + c + " "

+ d);
}

// Catch block to handle FileNotFoundException

catch (FileNotFoundException e) {
System.out.println("Cannot Open the Input File");
return;
}
}
}

// Java program to Demonstrate DataInputStream Class

// Importing I/O classes

import java.io.*;

// Main class
class DataInputStreamDemo {

// Main driver method

public static void main(String args[]) throws IOException {

// Writing the data

// Try block to check for exceptions

try ( DataOutputStream dout =
new DataOutputStream(new FileOutputStream("file.dat")) ) {

dout.writeDouble(1.1);
dout.writeInt(55);
dout.writeBoolean(true);
dout.writeChar('4');
}

// Catch block to handle the exceptions

catch (FileNotFoundException ex) {

// Display message when FileNotFoundException occurs

System.out.println("Cannot Open the Output File");
return;
}

// Reading the data back.

 // Try block to check for exceptions
try ( DataInputStream din =
new DataInputStream(new FileInputStream("file.dat")) ) {

// Illustrating readDouble() method

double a = din.readDouble();

// Illustrating readInt() method

int b = din.readInt();

// Illustrating readBoolean() method

boolean c = din.readBoolean();

// Illustrating readChar() method

char d = din.readChar();

// Print the values

System.out.println("Values: " + a + " " + b + " " + c + " " + d);
}

// Catch block to handle the exceptions

catch (FileNotFoundException e) {

// Display message when FileNotFoundException occurs

System.out.println("Cannot Open the Input File");
return;
}
}
}

iii)

import java.io.File;
import java.io.FileReader;
import java.io.IOException;

public class ReadFromFile {

public static void main(String[] args) throws IOException {
File file = new File("filename.txt");
FileReader fr = new FileReader(file);
int ch;
while ((ch=fr.read()) != -1) {
System.out.print((char)ch);
}
fr.close();
}
}

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

public class WriteToFile {

public static void main(String[] args) throws IOException {
File file = new File("filename.txt");
FileWriter fw = new FileWriter(file);
 fw.write("Hello World!");
fw.close();
}
}

4.Exercise programs on strings

i)strings compre by equals

public class StringCompareequl{

public static void main(String []args){
String s1 = "tutorialspoint";
String s2 = "tutorialspoint";
String s3 = new String ("Tutorials Point");
System.out.println(s1.equals(s2));
System.out.println(s2.equals(s3));
}
}

ii)reverse a string

public class StringReverseExample{

public static void main(String[] args) {
String string = "abcdef";
String reverse = new StringBuffer(string).reverse().toString();
System.out.println("\nString before reverse: "+string);
System.out.println("String after reverse: "+reverse);
}
}

iii)search a word in a string

public class HelloWorld {

public static void main(String[] args) {
String text = "The cat is on the table";
System.out.print(text.contains("the"));
}
}

5.create class and object and adding a method

class Lamp {

// stores the value for light

// true if light is on
// false if light is off
boolean isOn;

// method to turn on the light

void turnOn() {
isOn = true;
System.out.println("Light on? " + isOn);

// method to turnoff the light

void turnOff() {
isOn = false;
System.out.println("Light on? " + isOn);
}
}

class Main {
public static void main(String[] args) {

// create objects led and halogen

Lamp led = new Lamp();
Lamp halogen = new Lamp();

// turn on the light by

// calling method turnOn()
led.turnOn();

// turn off the light by

// calling method turnOff()
halogen.turnOff();
}
}

6.Exercise program on constructor and constructor overloading

i)constructor

class MyClass
{
MyClass()
{
System.out.println("No-argument constructor called");
}

public static void main(String[] args)

{
MyClass obj = new MyClass();
}
}

ii)constructor overloding

Source Code
class Box
{
double width, height, depth;

Box()
{
width = 1;
height = 1;
depth = 1;
}

Box(double w, double h, double d)

{
width = w;
height = h;
depth = d;
}

void myMethod()
{
 System.out.println("Width : " + width);
System.out.println("Height : " + height);
System.out.println("Depth : " + depth);
}

public static void main(String[] args)

{
Box box1 = new Box();
Box box2 = new Box(3, 8, 6);
box2.myMethod();

}
}

7.

i)

class Example2{
public static void main(String[] args){
int a = Integer.parseInt(args[0]);
int b = Integer.parseInt(args[1]);
int sum = a + b;
System.out.println("The sum is" +sum);
}
}

ii)

8.exercise progrms using concept of overloading method in java

class Adder{
static int add(int a,int b){
return a+b;
}
static int add(int a,int b,int c){
return a+b+c;
}
}
class TestOverloading1{
public static void main(String[] args){
System.out.println(Adder.add(11,11));
System.out.println(Adder.add(11,11,11));
}
}

9.Inheritnce
i) single

Source Code
public class SingleInheritance // Main class
{
public static void main(String[] args)
{
Dog dog = new Dog("Buddy"); // Create an instance of Dog

dog.eat(); // Call methods from Animal class

 dog.bark(); // Call methods from Dog class
}
}
class Animal // Parent class (Superclass)
{
protected String name;

public Animal(String name)

{
this.name = name;
}

public void eat()

{
System.out.println(name + " is Eating");
}
}
class Dog extends Animal // Child class (Subclass) inheriting from Animal
{
public Dog(String name)
{
super(name);
}

public void bark()

{
System.out.println(name + " is Barking");
}
}

ii)multilevel

Source Code
public class MultilevelInheritance // Main class
{
public static void main(String[] args)
{
Puppy puppy = new Puppy("Buddy"); // Create an instance of Puppy

puppy.eat(); // Call methods from Animal class

puppy.bark(); // Call methods from Dog class
puppy.play(); // Call methods from Puppy class
}
}
class Animal // Grandparent class
{
protected String name;

public Animal(String name)

{
this.name = name;
}

public void eat()

{
System.out.println(name + " is Eating");
}
}
class Dog extends Animal // Parent class inheriting from Animal
{
public Dog(String name)
{
super(name);
}

public void bark()

{
System.out.println(name + " is Barking");
}
}
class Puppy extends Dog // Child class inheriting from Dog
{
public Puppy(String name)
{
super(name);
}

public void play()

{
System.out.println(name + " is Playing");
}
}

iii)Hierarchical

public class HierarchicalInheritance // Main class

{
public static void main(String[] args)
{
Car car = new Car(); // Create objects of child classes
Motorcycle motorcycle = new Motorcycle();

car.display(); // Calling methods of parent class

motorcycle.display();

car.displayCar(); // Calling methods of child classes

motorcycle.displayMotorcycle();
}
}
class Vehicle // Parent class
{
void display()
{
System.out.println("This is a Vehicle");
}
}
class Car extends Vehicle // Child class 1
{
void displayCar()
{
System.out.println("This is a Car");
}
}
class Motorcycle extends Vehicle // Child class 2
{
void displayMotorcycle()
 {
System.out.println("This is a Motorcycle");
}
}

10)Method overriding

//Java Program to illustrate the use of Java Method Overriding

//Creating a parent class.
class Vehicle{
//defining a method
void run(){System.out.println("Vehicle is running");}
}
//Creating a child class
class Bike2 extends Vehicle{
//defining the same method as in the parent class
void run(){System.out.println("Bike is running safely");}

public static void main(String args[]){

Bike2 obj = new Bike2();//creating object
obj.run();//calling method
}
}

11)Packages

i)creation of package

package library;

import library.domain.Book;

public class Program {

public static void main(String[] args) {

Book book = new Book("the ABCs of packages!");
System.out.println("Hello packageworld: " + book.getName());
}
}

ii) importing packge from other packages

package myPackage;

import java.util.*;

public class ImportingExample {

public static void main(String[] args) {

Scanner read = new Scanner(System.in);

int i = read.nextInt();
 System.out.println("You have entered a number " + i);

Random rand = new Random();

int num = rand.nextInt(100);

System.out.println("Randomly generated number " + num);

}
}

12)Interfces

// Java program to demonstrate working of

// interface

import java.io.*;

// A simple interface
interface In1 {

// public, static and final

final int a = 10;

// public and abstract

void display();
}

// A class that implements the interface.

class TestClass implements In1 {

// Implementing the capabilities of

// interface.
public void display(){
System.out.println("Geek");
}

// Driver Code
public static void main(String[] args)
{
TestClass t = new TestClass();
t.display();
System.out.println(t.a);
}
}

13)Collections

i)search a student mark percentage based on pin using arraylist

import java.util.Scanner;
public class Student_Marks
{
public static void main(String[] args)
{
int n, total = 0, percentage;
Scanner s = new Scanner(System.in);
System.out.print("Enter no. of subject:");
n = s.nextInt();
 int marks[] = new int[n];
System.out.println("Enter marks out of 100:");
for(int i = 0; i < n; i++)
{
marks[i] = s.nextInt();
total = total + marks[i];
}
percentage = total / n;
System.out.println("Sum:"+total);
System.out.println("Percentage:"+percentage);
}
}

ii)Linked List

import java.util.LinkedList;

class Main {
public static void main(String[] args) {
LinkedList<String> languages = new LinkedList<>();

// add elements in LinkedList

languages.add("Java");
languages.add("Python");
languages.add("JavaScript");
languages.add("Kotlin");
System.out.println("LinkedList: " + languages);

// remove elements from index 1

String str = languages.remove(1);
System.out.println("Removed Element: " + str);

System.out.println("Updated LinkedList: " + languages);

}
}

iii)search an element from hash table

import java.util.HashMap;
public class Main {
static final int SIZE = 10; // Define the size of the hash table
static class DataItem {
int key;
}
static HashMap<Integer, DataItem> hashMap = new HashMap<>(); // Define the hash
table as a HashMap

static int hashCode(int key) {

// Return a hash value based on the key
return key % SIZE;
}
static DataItem search(int key) {
// get the hash
int hashIndex = hashCode(key);

// move in map until an empty slot is found or the key is found

while (hashMap.get(hashIndex) != null) {
 // If the key is found, return the corresponding DataItem
if (hashMap.get(hashIndex).key == key)
return hashMap.get(hashIndex);

// go to the next cell

++hashIndex;

// wrap around the table

hashIndex %= SIZE;
}

// If the key is not found, return null

return null;
}
public static void main(String[] args) {
// Initializing the hash table with some sample DataItems

DataItem item2 = new DataItem();

item2.key = 25; // Assuming the key is 25

DataItem item3 = new DataItem();

item3.key = 64; // Assuming the key is 64
DataItem item4 = new DataItem();
item4.key = 22; // Assuming the key is 22
// Calculate the hash index for each item and place them in the hash table

int hashIndex2 = hashCode(item2.key);

hashMap.put(hashIndex2, item2);

int hashIndex3 = hashCode(item3.key);

hashMap.put(hashIndex3, item3);

int hashIndex4 = hashCode(item4.key);

hashMap.put(hashIndex4, item4);

// Call the search function to test it

int keyToSearch = 64; // The key to search for in the hash table
DataItem result = search(keyToSearch);
System.out.print("The element to be searched: " + keyToSearch);
if (result != null) {
System.out.println("\nElement found");
} else {
System.out.println("\nElement not found");
}
}
}

iv)sorting employee details using hash map

// Java Code to sort Map by key value

import java.util.*;
class sortmapKey {

// This map stores unsorted values

static Map<String, Integer> map = new HashMap<>();

// Function to sort map by Key

public static void sortbykey()
{
 ArrayList<String> sortedKeys
= new ArrayList<String>(map.keySet());

Collections.sort(sortedKeys);

// Display the TreeMap which is naturally sorted

for (String x : sortedKeys)
System.out.println("Key = " + x
+ ", Value = " + map.get(x));
}

// Driver Code
public static void main(String args[])
{
// putting values in the Map
map.put("Jayant", 80);
map.put("Abhishek", 90);
map.put("Anushka", 80);
map.put("Amit", 75);
map.put("Danish", 40);

// Calling the function to sortbyKey

sortbykey();
}
}

14)exercises on exception handling

i)try, catch,finlly

public class Main {

public static void main(String[ ] args) {
try {
int[] myNumbers = {1, 2, 3};
System.out.println(myNumbers[10]);
} catch (Exception e) {
System.out.println("Something went wrong.");
}
}
}

finlly

public class Main {

public static void main(String[] args) {
try {
int[] myNumbers = {1, 2, 3};
System.out.println(myNumbers[10]);
} catch (Exception e) {
System.out.println("Something went wrong.");
} finally {
System.out.println("The 'try catch' is finished.");
}
}
}
ii)multiple catch sattement

public class MultipleCatchBlock1 {

public static void main(String[] args) {

try{
int a[]=new int[5];
a[5]=30/0;
}
catch(ArithmeticException e)
{
System.out.println("Arithmetic Exception occurs");
}
catch(ArrayIndexOutOfBoundsException e)
{
System.out.println("ArrayIndexOutOfBounds Exception occurs");
}
catch(Exception e)
{
System.out.println("Parent Exception occurs");
}
System.out.println("rest of the code");
}
}

iii)multiple try sttements

public class NestedTryBlock{

public static void main(String args[]){
//outer try block
try{
//inner try block 1
try{
System.out.println("going to divide by 0");
int b =39/0;
}
//catch block of inner try block 1
catch(ArithmeticException e)
{
System.out.println(e);
}

//inner try block 2

try{
int a[]=new int[5];

//assigning the value out of array bounds

a[5]=4;
}

//catch block of inner try block 2

catch(ArrayIndexOutOfBoundsException e)
{
System.out.println(e);
}
 System.out.println("other statement");
}
//catch block of outer try block
catch(Exception e)
{
System.out.println("handled the exception (outer catch)");
}

System.out.println("normal flow..");
}
}

15)Exercises on multithreading

i)creation of single and multile threads

//single thread

import java.io.*;
class GFG extends Thread {
public void run()
{
System.out.print("Welcome to GeeksforGeeks.");
}
public static void main(String[] args)
{
GFG g = new GFG(); // creating thread
g.start(); // starting thread
}
}

// Java Program to Run Multiple Threads

// class extends thread class

class Main extends Thread {

// run method implementation

public void run()
{
System.out.println("Geeks for Geeks");
}

// in the main method

public static void main(String args[])
{
// object creation
Main t1 = new Main();

// object creation
Main t2 = new Main();

// object creation
Main t3 = new Main();

// start the thread

t1.start();

// start the thread

t2.start();
 // start the thread
t3.start();
}
}

ii)adding priorities to multithreads

/ Java Program to Illustrate Priorities in Multithreading

// via help of getPriority() and setPriority() method

// Importing required classes

import java.lang.*;

// Main class
class ThreadDemo extends Thread {

// Method 1
// run() method for the thread that is called
// as soon as start() is invoked for thread in main()
public void run()
{
// Print statement
System.out.println("Inside run method");
}

// Main driver method

public static void main(String[] args)
{
// Creating random threads
// with the help of above class
ThreadDemo t1 = new ThreadDemo();
ThreadDemo t2 = new ThreadDemo();
ThreadDemo t3 = new ThreadDemo();

// Thread 1
// Display the priority of above thread
// using getPriority() method
System.out.println("t1 thread priority : "
+ t1.getPriority());

// Thread 1
// Display the priority of above thread
System.out.println("t2 thread priority : "
+ t2.getPriority());

// Thread 3
System.out.println("t3 thread priority : "
+ t3.getPriority());

// Setting priorities of above threads by

// passing integer arguments
t1.setPriority(2);
t2.setPriority(5);
t3.setPriority(8);

// t3.setPriority(21); will throw

// IllegalArgumentException
 // 2
System.out.println("t1 thread priority : "
+ t1.getPriority());

// 5
System.out.println("t2 thread priority : "
+ t2.getPriority());

// 8
System.out.println("t3 thread priority : "
+ t3.getPriority());

// Main thread

// Displays the name of

// currently executing Thread
System.out.println(
"Currently Executing Thread : "
+ Thread.currentThread().getName());

System.out.println(
"Main thread priority : "
+ Thread.currentThread().getPriority());

// Main thread priority is set to 10

Thread.currentThread().setPriority(10);

System.out.println(
"Main thread priority : "
+ Thread.currentThread().getPriority());
}
}

iii)Inter thread communication

// Java program to demonstrate inter-thread communication

// (wait(), join() and notify())

import java.util.Scanner;

public class threadexample

{
public static void main(String[] args) throws InterruptedException
{
final PC pc = new PC();

// Create a thread object that calls pc.produce()

Thread t1 = new Thread(new Runnable()
{
@Override
public void run()
{
try
{
pc.produce();
}
catch(InterruptedException e)
{
e.printStackTrace();
 }
}
});

// Create another thread object that calls

// pc.consume()
Thread t2 = new Thread(new Runnable()
{
@Override
public void run()
{
try
{
pc.consume();
}
catch(InterruptedException e)
{
e.printStackTrace();
}
}
});

// Start both threads

t1.start();
t2.start();

// t1 finishes before t2
t1.join();
t2.join();
}

// PC (Produce Consumer) class with produce() and

// consume() methods.
public static class PC
{
// Prints a string and waits for consume()
public void produce()throws InterruptedException
{
// synchronized block ensures only one thread
// running at a time.
synchronized(this)
{
System.out.println("producer thread running");

// releases the lock on shared resource

wait();

// and waits till some other method invokes notify().

System.out.println("Resumed");
}
}

// Sleeps for some time and waits for a key press. After key
// is pressed, it notifies produce().
public void consume()throws InterruptedException
{
// this makes the produce thread to run first.
Thread.sleep(1000);
Scanner s = new Scanner(System.in);
 // synchronized block ensures only one thread
// running at a time.
synchronized(this)
{
System.out.println("Waiting for return key.");
s.nextLine();
System.out.println("Return key pressed");

// notifies the produce thread that it

// can wake up.
notify();

// Sleep
Thread.sleep(2000);
}
}
}
}