OBJECT ORIENTED PROGRAMMING WITH JAVA-BCS306A

Module 3-bcs306A

1.Write a Java program to implement multilevel inheritance with 3 levels of hierarchy.

Answer:class Box {

Private double width;

Private double height;

Private double depth;

Box(double w, double h, double d) {

Width = w;

Height = h;

Depth = d;

Double volume() {

Return width * height * depth;

Class BoxWeight extends Box {

Double weight;

BoxWeight(double w, double h, double d, double m) {

Super(w, h, d);

Weight = m;

Class Shipment extends BoxWeight {

Double cost;

Shipment(double w, double h, double d,double m, double c) {

Super(w, h, d, m);

Cost = c;

Class Mainclass{
Public static void main(String args[]){

Shipment shipment1 = new Shipment(10, 20, 15, 10, 3.41);

Shipment shipment2 = new Shipment(2, 3, 4, 0.76, 1.28);

Double vol;

Vol = shipment1.volume();

System.out.println(“Volume of shipment1 is “ + vol);

System.out.println(“Weight of shipment1 is “+ shipment1.weight);

System.out.println(“Shipping cost: $” + shipment1.cost);

System.out.println();

2. What is the importance of the super keyword in inheritance? Illustrate with a suitable example.

Ans: Using super: The super keyword in java is a reference variable which is used to refer Immediate
parent class object. Whenever you create the instance of subclass, an instance of Parent class is
created implicitly which is referred by super reference variable.

Usage of java super Keyword

1. Super can be used to refer immediate parent class instance variable.

2. Super can be used to invoke immediate parent class method.
3. Super() can be used to invoke immediate parent class constructor.
1. Super is used to refer immediate parent class instance variable. We can use super Keyword
to access the data member or field of parent class. It is used if parent class and child Class
have same fields. Sub-class variable hides the super-class variable in class sub-class.

Class Animal{

String color=”white”;

Class Dog extends Animal{

String color=”black”; //this hides color in Animal

Void printColor(){

System.out.println(color); //prints color of Dog class

System.out.println(super.color); //prints color ofAnimal class

Class Mainclass{

Public static void main(String[ ] args){

Dog d=new Dog();

d.printColor();

Output: black

White

2. Super is used to invoke super-class(parent class) constructor.. The super keyword

Can also be used to invoke the parent class constructor. Let’s see a simple example:

Class A {

Int I;

Private int j;

A(int a, int b) {

I=a;

J=b;

Void addij(){

Int k=i+j;

System.out.println(“(i+j=)”+k);

Class B extends A {

Int k;

B(int a, int b, int c){

Super(a,b);

K=c;

}void addik() {

System.out.println(“i: “ + i);

//System.out.println(“j: “ + j); //Error j is private cannot access j in B

System.out.println(“k: “ + k);

Int c=i+k;

System.out.println(“i+k=”+c);
}

Class Mainclass{

Public static void main(String[ ] args){

B b=new B(1,2,3);

b.addij();

b.addik();

Output: (i+j=)3

I: 1

K: 3

I+k=4

3. Super is used to invoke super-class(parent class) method.. The super keyword can

Also be used to invoke the parent class method when parent class method and child class Method
names are same in other words method is overridden.

Let’s see a simple example:

Class Animal{

Void eat(){

System.out.println(“All Animals can eat…”);

Class Dog extends Animal{

Void eat(){

System.out.println(“eating bread…”);

Void bark(){

System.out.println(“barking…”);

Void work(){

Super.eat();

Bark();
}

Class Mainclass{

Public static void main(String args[]){

Dog d=new Dog();

d.work();

3.What is abstract class and abstract method? Explain with an example.

Answer:Abstract Classes: There are situations in which you will want to define a super-class that
declares

The structure of a given abstraction without providing a complete implementation of every

method.

That is, sometimes you will want to create a super-class that only defines a generalized form that
Will be shared by all of its subclasses, leaving it to each subclass to fill in the details.To declare an
Abstract method, use this general form:

Abstract type name(parameter-list);

As you can see,

no method body is present.

Any class that contains one or more abstract methods must also be declared abstract. To
Declare a class abstract, you simply use the abstract keyword in front of the class Keyword at the
beginning of the class declaration.

There can be no objects of an abstract class. That is, an abstract class cannot be directly Instantiated
with the new operator. Such objects would be useless, because an abstract Class is not fully defined.

// Using abstract methods and classes.

Abstract class Figure {

Double dim1;

Double dim2;

Figure(double a, double b) {

Dim1 = a;

Dim2 = b;

Abstract double area(); // area is now an abstract method

}
Class Rectangle extends Figure {

Rectangle(double a, double b) {

Super(a, b);

// override area for rectangle

Double area() {

System.out.println(“Inside Area for Rectangle.”);

Return dim1 * dim2;

Class Triangle extends Figure {

Triangle(double a, double b) {

Super(a, b);

Double area() {

System.out.println(“Inside Area for Triangle.”);

Return dim1 * dim2 / 2;

Class AbstractAreas {

Public static void main(String args[]) {

// Figure f = new Figure(10, 10); // illegal now

Rectangle r = new Rectangle(9, 5);

Triangle t = new Triangle(10, 8);

Figure figref; // this is OK, no object is created

Figref = r;

System.out.println(“Area is “ + figref.area());

Figref = t;

System.out.println(“Area is “ + figref.area());

}
4.What is dynamic method dispatch? Write a simple example that illustrates dynamic method
dispatch.

Ans:Dynamic Method Dispatch: Dynamic method dispatch is the mechanism by which a call to an
Overridden method is resolved at run time, rather than compile time. Dynamic method dispatch is
Important because this is how Java implements run-time polymorphism.

// Dynamic Method Dispatch

Class A {

Void callme() {

System.out.println(“Inside A’s callme method”);

Class B extends A {

// override callme()

Void callme() {

System.out.println(“Inside B’s callme method”);

Class C extends A {

// override callme()

Void callme() {

System.out.println(“Inside C’s callme method”);

Class Dispatch {

Public static void main(String args[]) {

A a = new A(); // object of type A

B b = new B(); // object of type B

C c = new C(); // object of type C

A r;

R = a; // r refers to an A object

r.callme(); // calls A’s version of callme

r = b; // r refers to a B object
r.callme(); // calls B’s version of callme

r = c; // r refers to a C object

r.callme(); // calls C’s version of callme

5.What is meant by interface? State its need and write syntax and features of interface.

Answer: What is an Interface in Java?

An interface in Java is a reference type, similar to a class, that can contain only constants, method
signatures, default methods, static methods, and nested types. Interfaces do not contain any
method implementation (prior to Java 8, except for default and static methods).

An interface is a blueprint of a class that specifies a set of methods that a class must implement.

Need for Interfaces

1. Achieving Multiple Inheritance: Java does not support multiple inheritance with classes, but it
supports it through interfaces, allowing a class to implement multiple interfaces.

2. Abstraction: Interfaces provide complete abstraction by declaring what a class must do but not
how it does it.

3. Decoupling: Interfaces help in achieving loose coupling by specifying behaviors independently of

the implementing classes.

4. Polymorphism: They enable polymorphic behavior as a class can implement multiple interfaces.

Syntax of an Interface

interface InterfaceName {

// Constant fields (implicitly public, static, and final)

int CONSTANT = 10;

// Abstract methods (implicitly public and abstract)

void method1();

void method2();

// Default method (Java 8+)

default void defaultMethod() {

System.out.println("Default method in interface.");

// Static method (Java 8+)

static void staticMethod() {

System.out.println("Static method in interface.");

 }

Features of Interfaces

1. Complete Abstraction: Interfaces allow only method declarations, not implementations (except
default and static methods in Java 8+).

2. Implicit Modifiers:

All fields are public, static, and final by default.All methods are public and abstract by default (except
default and static methods).

3. Multiple Implementation: A class can implement multiple interfaces.

4. Inheritance in Interfaces: An interface can inherit from another interface using the extends
keyword.

5. No Constructor: Interfaces cannot have constructors, as they cannot be instantiated directly.

6. Java 8 Enhancements: Default and static methods were introduced to provide a mechanism for
method implementation in interfaces.

6.Explain method overriding with suitable examples.

Answer:Method Overriding in Java: If subclass (child class) has the same method as declared in the

Parent class, it is known as method overriding in java. In other words, If subclass provides

The specific implementation of the method that has been provided by one of its parent class, It is
known as method overriding.

Usage of Java Method Overriding

Method overriding is used to provide specific implementation of a method that

Is already provided by its super class.

Method overriding is used for runtime polymorphism

Rules for Java Method Overriding

1. Method must have same name as in the parent class

2. Method must have same parameter as in the parent class.
3. Must be IS-A relationship (inheritance).

Class Bank{

Int getRateOfInterest(){

Return 0;

Class SBI extends Bank{

Int getRateOfInterest(){
Return 8;

Class ICICI extends Bank{

Int getRateOfInterest(){

Return 7;

Class AXIS extends Bank{

Int getRateOfInterest(){

Return 9;

Class Test2{

Public static void main(String args[]){

SBI s=new SBI();

ICICI i=new ICICI();

AXIS a=new AXIS();

System.out.println(“SBI Rate of Interest: “+s.getRateOfInterest());

System.out.println(“ICICI Rate of Interest: “+i.getRateOfInterest());

System.out.println(“AXIS Rate of Interest: “+a.getRateOfInterest());

7.Explain the concept of nesting of interfaces.

Answer:Nesting of Interfaces in Java:

Nesting of interfaces means defining an interface inside another interface or class. This is used to
logically group interfaces and associate them closely with the enclosing interface or class. Nested
interfaces are implicitly static.

Syntax:

Interface OuterInterface {

Void outerMethod();
 // Nested interface

Interface InnerInterface {

Void innerMethod();

Example

Interface OuterInterface {

Void displayOuter();

Interface InnerInterface {

Void displayInner();

Class InnerClass implements OuterInterface.InnerInterface {

Public void displayInner() {

System.out.println(“Inner interface method.”);

Class OuterClass implements OuterInterface {

Public void displayOuter() {

System.out.println(“Outer interface method.”);

Public class NestedInterfaceDemo {

Public static void main(String[] args) {

OuterClass outer = new OuterClass();

Outer.displayOuter();

InnerClass inner = new InnerClass();

Inner.displayInner();

Output:
Outer interface method.

Inner interface method.

8.Briefly explain the final keyword with inheritance.

Answer:Using final with Inheritance: The final keyword in java is used to restrict the user. The Java
final keyword can be used in many context. Final can be:

1. Variable
2. Method
3. Class

Final variable: There is a final variable speedlimit, we are going to change the value of this

Variable, but It can’t be changed because final variable once assigned a value can never be Changed.

Class Bike9{

Final int speedlimit=90; //final variable

Void run(){

Speedlimit=400;

Public static void main(String args[]){

Bike9 obj=new Bike9();

Obj.run();

} Output: Compile Time Error

Java final method: If you make any method as final, you cannot override it.

Class Bike{

Final void run(){

System.out.println(“running”);

Class Honda extends Bike{

Void run(){

System.out.println(“running safely with 100kmph”);

Class MainClass{
Public static void main(String args[]){

Honda honda= new Honda();

Honda.run();

} Output: Compile Time Error

Java final class: If you make any class as final, you cannot inherit it.

Final class Bike{

Int add(){

Return 10;

Class Honda1 extends Bike{

Void run(){

System.out.println(“running safely with 100kmph”);

Class MainClass{

Public static void main(String args[]){

Honda1 honda= new Honda1();

Honda.run();

Output: Compile Time Error

Module 4

9. Define package. Explain the steps involved in creating a user-defined package with an example.

Answer:

Definition of Package:

A package in Java is a namespace that organizes related classes and interfaces to avoid naming
conflicts and ensure modular programming. It provides access protection and easier code
management.

Steps to Create a User-Defined Package:

1. Create a Package:
Use the package keyword at the top of the file to specify the package name.

Example: package mypackage;

2. Save the File:

Save the file with the same name as the class and inside a directory with the package name.

Example: Save MyClass.java inside the mypackage folder.

3. Compile the Class:

Use the javac command to compile the file. Ensure you are outside the package directory.

Command: javac -d . MyClass.java

This creates the mypackage folder with the compiled .class file.

4. Use the Package in Another Program:

Import the package in another class using the import keyword.

Example: import mypackage.MyClass;

5. Run the Program:

Run the program from the location of the package folder.

Command: java mypackage.MyClass

Example:

Step 1: Create a Package (File: MyClass.java)

Package mypackage;

Public class MyClass {

Public void display() {

System.out.println(“This is a user-defined package!”);

Step 2: Compile the Package

Javac -d . MyClass.java

Step 3: Use the Package (File: TestPackage.java)

Import mypackage.MyClass;

Public class TestPackage {

Public static void main(String[] args) {

MyClass obj = new MyClass();

Obj.display();
 }

Step 4: Compile and Run

Javac TestPackage.java

Java TestPackage

Output:

This is a user-defined package!

10. Examine the various levels of access protections available for packages and their implications
with suitable examples.

Answer:Access Levels in Java and Their Implications Java provides four access levels for class
members (fields, methods, constructors) and their usage in packages:

1. Public

Accessible from anywhere (within the same class, package, or from another package).

Use for APIs or shared resources.

Example:

Package pkg1;

Public class PublicExample {

Public void display() {

System.out.println(“Public method”);

// From another package

Package pkg2;

Import pkg1.PublicExample;

Public class TestPublic {

Public static void main(String[] args) {

PublicExample obj = new PublicExample();

Obj.display(); // Works fine

2. Protected

Accessible within the same package and by subclasses in other packages.

Used when inheritance is involved.

Example:

Package pkg1;

Public class ProtectedExample {

Protected void show() {

System.out.println(“Protected method”);

// From another package

Package pkg2;

Import pkg1.ProtectedExample;

Public class TestProtected extends ProtectedExample {

Public static void main(String[] args) {

TestProtected obj = new TestProtected();

Obj.show(); // Accessible through inheritance

3. Default (no modifier)

Accessible only within the same package.

Used for internal package-level usage.

Example:

Package pkg1;

Class DefaultExample {

Void display() {

System.out.println(“Default method”);

// In the same package

Package pkg1;

Public class TestDefault {

Public static void main(String[] args) {

 DefaultExample obj = new DefaultExample();

Obj.display(); // Accessible within pkg1

4. Private

Accessible only within the same class.

Used for encapsulation and hiding implementation details.

Example:

Package pkg1;

Public class PrivateExample {

Private void display() {

System.out.println(“Private method”);

Public void show() {

Display(); // Accessible within the class

// Another class in the same package

Package pkg1;

Public class TestPrivate {

Public static void main(String[] args) {

PrivateExample obj = new PrivateExample();

Obj.show(); // Works

// obj.display(); // Error: Cannot access private member

11.Explain the concept of importing packages in Java and provide an example demonstrating the
usage of the import statement.

Answer: Importing Packages in Java

In Java, the import statement is used to access classes and interfaces from other packages. It allows
reusability of code and helps avoid fully qualifying class names.
Types of import Statements:

1. Specific Import:

Imports a single class or interface.

Example: import java.util.Scanner;

2. Wildcard Import:

Imports all classes and interfaces from a package.

Example: import java.util.*;

Example: Using the import Statement

Step 1: Create a Package (File: mypackage/MyClass.java)

Package mypackage;

Public class MyClass {

Public void greet() {

System.out.println(“Hello from MyClass in mypackage!”);

Step 2: Compile the Package

Javac -d . MyClass.java

Step 3: Use the Class in Another Program (File: TestImport.java)

Import mypackage.MyClass; // Specific import

Public class TestImport {

Public static void main(String[] args) {

MyClass obj = new MyClass();

Obj.greet();

Step 4: Compile and Run

Javac TestImport.java

Java TestImport

Output:

Hello from MyClass in mypackage!

Key Points:
 1. No Import Needed for Same Package: Classes in the same package can directly access each
other.
2. Fully Qualified Names: If the import statement is not used, fully qualified names must be
used (e.g., mypackage.MyClass obj = new mypackage.MyClass();)
3. Static Import: Use import static to access static members directly. Example: import static
java.lang.Math.PI;

The Import statement simplifies the usage of external classes and improves code readability.

12. Define an exception and explain the exception handling mechanism with an example.

Answer:An exception is an abnormal condition that arises in a code sequence at run

Time. In other words, an exception is a run time error.

Exception-Handling Fundamentals:

Java exception handling is managed via five keywords: try, catch,

Throw, throws, and finally.

Program statements that you want to monitor for exceptions are

Contained within a try block.

If an exception occurs within the try block, it is thrown.

Your code can catch this exception (using catch) and handle it in some

Rational manner.

System-generated exceptions are automatically thrown by the Java

Run time system.

To manually throw an exception, use the keyword throw. Any

Exception that is thrown out of a method must be specified as such by

A throws clause.

Any code that absolutely must be executed after a try block completes is

Put in a finally block.

13. Write a program which contains one method which will throw an Illegal Access

Exception and use proper exception handle so that exceptions should be printed.

Answer: public class IllegalAccessExceptionDemo {

// Method that throws an IllegalAccessException

Public static void throwIllegalAccess() throws IllegalAccessException {

Throw new IllegalAccessException(“Illegal access detected!”);

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

Try {

// Call the method that throws the exception

throwIllegalAccess();

} catch (IllegalAccessException e) {

// Handle the exception and print the details

System.out.println(“Caught Exception: “ + e.getMessage());

e.printStackTrace(); // Print stack trace for debugging

} finally {

System.out.println(“Finally block executed.”);

14. Enlist any 10 Java’s Built-in exceptions and explain

Answer: The 10 Java’s Built-in exceptions are:

1. Arithmetic Exception

Description: Thrown when an arithmetic operation attempts an invalid operation, such as division by
zero.

Example:

Int result = 10 / 0; // Throws ArithmeticException

2. NullPointerException

Description: Thrown when an application attempts to access a null object or calls a method on a null
reference.

Example:

String str = null;

System.out.println(str.length()); // Throws NullPointerException

3. ArrayIndexOutOfBoundsException

Description: Thrown when an attempt is made to access an array with an invalid index (negative or
beyond its length).

Example:
Int[] arr = {1, 2, 3};

System.out.println(arr[3]); // Throws ArrayIndexOutOfBoundsException

4. ClassCastException

Description: Thrown when an object is improperly cast to a subclass or incompatible type.

Example:

Object obj = new Integer(10);

String str = (String) obj; // Throws ClassCastException

5. IllegalArgumentException

Description: Thrown to indicate that a method has been passed an illegal or inappropriate argument.

Example:

Thread thread = new Thread();

Thread.setPriority(11); // Throws IllegalArgumentException

6. NumberFormatException

Description: Thrown when an attempt is made to convert a string to a numeric type, but the string is
not properly formatted.

Example:

Int num = Integer.parseInt(“abc”); // Throws NumberFormatException

7. IOException

Description: A general exception thrown when an I/O operation fails or is interrupted.

Example:

FileInputStream file = new FileInputStream(“nonexistent.txt”); // Throws IO Exception

8. FileNotFoundException

Description: A subclass of IOException, thrown when an attempt to open a file that does not exist is
made.

Example:

FileInputStream file = new FileInputStream(“missingfile.txt”); // Throws FileNotFoundException

9. InterruptedException

Description: Thrown when a thread is interrupted while it is waiting, sleeping, or otherwise paused.

Example:

Thread.sleep(1000);

Thread.currentThread().interrupt(); // May throw InterruptedException

 10. IllegalStateException

Description: Thrown when a method is invoked at an illegal or inappropriate time.

Example:

Iterator<String> iterator = new ArrayList<String>().iterator();

Iterator.remove(); // Throws IllegalStateException

15.How do you create your own exception class? Explain with a program.

Answe: The Exception class does not define any methods of its own.

It does, of course, inherit those methods provided by Throwable.

Thus, all exceptions, including those that you create, have the methods

Defined by Throwable available to them.

They are shown in Table 10-3. You may also wish to override one or

More of these methods in exception classes that you create.

Exception defines four public constructors.

Two support chained exceptions.

The other two are shown here:

The first form creates an exception that has no description.

The second form lets you specify a description of the exception.

In Java, you can create your own exception class by extending the Exception class (for checked
exceptions) or RuntimeException class (for unchecked exceptions). This allows you to define custom
behavior or add specific details to your exception.

Example Program:

// Custom Exception Class

Class InvalidAgeException extends Exception {

// Default constructor

Public InvalidAgeException() {

Super(“Invalid age provided!”);

// Parameterized constructor

Public InvalidAgeException(String message) {

Super(message);

}
// Main Class

Public class CustomExceptionDemo {

// Method to check age

Public static void checkAge(int age) throws InvalidAgeException {

If (age < 18 || age > 100) {

Throw new InvalidAgeException(“Age must be between 18 and 100.”);

System.out.println(“Age is valid: “ + age);

Public static void main(String[] args) {

Try {

// Test with invalid age

checkAge(15);

} catch (InvalidAgeException e) {

// Handle the custom exception

System.out.println(“Caught Exception: “ + e.getMessage());

} finally {

System.out.println(“Age validation completed.”);

Explanation:

1.Custom Exception Class:

InvalidAgeException extends Exception.

Includes a default constructor with a generic message and a parameterized constructor for custom
messages.

2Method that Throws Exception:

checkAge throws an InvalidAgeException if the age is not in the valid range (18 to 100).

1. Handling the Exception:

In the main method, checkAge is called within a try block.

The exception is caught in the catch block and the message is displayed.

2. Finally Block:
Ensures that cleanup or additional actions are performed regardless of whether an exception was
thrown.

16. Demonstrate the working of a nested try block with an example.

Answer: The try statement can be nested.

That is, a try statement can be inside the block of another try.

Each time a try statement is entered, the context of that exception is

Pushed on the stack.

If an inner try statement does not have a catch handler for a

Particular exception, the stack is unwound and the next try

Statement’s catch handlers are inspected for a match.

This continues until one of the catch statements succeeds, or until all

Of the nested try statements are exhausted.

If no catch statement matches, then the Java run-time system will

Handle the exception.

Here is an example that uses nested try statements:

Program:// An example of nested try statements.

Class NestTry {

Public static void main(String args[])

Try {

Inta args.length;

/* If no command-line args are present, the following statement will generate a divide-by-zero
exception. */

Int b = 42/a;

System.out.println(“a” + a);

Try { // nested try block

If one command-line arg is used, then a divide-by-zero exception will be generated by the following
code. */ if(a==1) a = a/(a-a); // division by zero

/* If two command-line args are used, then generate an out-of-bounds exception. */

If (a==2) (

Int c[]={1};

C [42] 99; // generate an out-of-bounds exception

}

catch (ArrayIndexOutOfBoundsException e)

System.out.println(“Array index out-of-bounds: “+ e);

} catch (ArithmeticException e)

System.out.println(“Divide by 0:”+e);

17.What is chained exception? Give an example that illustrates the mechanics of handling chained
exceptions.

Answer: Beginning with JDK 1.4, a feature was incorporated into the

exception subsystem: chained exceptions.

The chained exception feature allows you to associate another

exception with an exception.

This second exception describes the cause of the first exception.

For example, imagine a situation in which a method throws an

ArithmeticException because of an attempt to divide by zero.

However, the actual cause of the problem was that an I/O error occurred,

which caused the divisor to be set improperly.

Although the method must certainly throw an ArithmeticException,

since that is the error that occurred, you might also want to let the

calling code know that the underlying cause was an I/O error.

Chained exceptions let you handle this, and any other situation in

which layers of exceptions exist.

public class ChainedExceptionUsingInitCause {

public static void main(String[] args) {

try {

// Simulate a low-level exception

 NullPointerException lowLevelException = new NullPointerException("Low-level exception
occurred");

// Create a higher-level exception and set the cause

IllegalArgumentException highLevelException = new IllegalArgumentException("Higher-level

exception occurred");

highLevelException.initCause(lowLevelException); // Link the cause

// Throw the higher-level exception

throw highLevelException;

} catch (IllegalArgumentException e) {

// Print the stack trace to observe the chaining mechanism

e.printStackTrace();

// Retrieve and print the cause of the exception

Throwable cause = e.getCause();

if (cause != null) {

System.out.println("Cause of the exception: " + cause);

Explanation:

1. Low-Level Exception:

A NullPointerException is created to simulate a low-level error.

2. High-Level Exception:

An IllegalArgumentException is created to represent a more abstract error.

3. initCause Method:

The NullPointerException is associated as the cause of the IllegalArgumentException using initCause.

3. Chained Exception Handling:

4. The high-level exception is thrown, and both the exception and its cause can be accessed for
debugging.
This example demonstrates how exceptions can be layered with initCause to build more descriptive
error reporting.

Module 5

18.What do you mean by thread? Explain the different ways of creating threads.

Answer :

Thread and Its Definition

A thread is the smallest unit of execution in a program, often referred to as a lightweight sub-
process. Threads are part of a process and share the same memory and resources, but they execute
independently. They are widely used for multitasking within a single program, allowing multiple
tasks to run concurrently.

Key Features of Threads

1. Efficient Resource Sharing: Threads share the memory and resources of the parent process,
reducing overhead.
2. Faster Context Switching: Switching between threads is faster than between processes.
3. Parallel Execution: Threads enable concurrent execution, improving application
responsiveness and performance.

Ways to Create Threads in Java

There are two main ways to create threads in Java:

1. Extending the Thread Class

In this method, a class is created by extending the Thread class and overriding its run() method. The
run() method contains the code to be executed by the thread. To start the thread, the start()
method is invoked.

Example:

Class MyThread extends Thread {

@Override

Public void run() {

System.out.println(“Thread is running…”);

Public class Main {

Public static void main(String[] args) {

MyThread t1 = new MyThread();

T1.start(); // Starts the thread

}
}

Note: Extending the Thread class restricts the ability to extend other classes because Java does not
support multiple inheritance.

2. Implementing the Runnable Interface

This method involves creating a class that implements the Runnable interface and overrides the
run() method. The Runnable object is passed to a Thread instance, which then starts the thread.

Example:

Class MyRunnable implements Runnable {

@Override

Public void run() {

System.out.println(“Thread is running…”);

Public class Main {

Public static void main(String[] args) {

MyRunnable myRunnable = new MyRunnable();

Thread t1 = new Thread(myRunnable);

T1.start(); // Starts the thread

Advantages of Runnable over Thread:

A class can implement Runnable and extend another class, promoting better design and flexibility.

It separates the task (defined in Runnable) from the thread creation, making it reusable.

Using Lambda Expressions

From Java 8 onwards, threads can be created more concisely using lambda expressions.

Example:

Public class Main {

Public static void main(String[] args) {

Thread t1 = new Thread(() -> System.out.println(“Thread is running…”));

T1.start(); // Starts the thread

 }

19.What is multithreading? Write a program to create multiple threads in JAVA

Answer:

Multithreading is a technique in which multiple threads execute concurrently within a single process.
Each thread runs independently but shares the same memory and resources of the parent process.
This enables efficient multitasking, where different parts of a program can run simultaneously,
improving performance and responsiveness.

//Program to Create Multiple Threads in Java:

Class MyThread extends Thread {

Private String threadName;

Public MyThread(String name) {

This.threadName = name;

@Override

Public void run() {

System.out.println(threadName + “ is running…”);

Public class MultithreadingExample {

Public static void main(String[] args) {

MyThread t1 = new MyThread(“Thread 1”);

MyThread t2 = new MyThread(“Thread 2”);

MyThread t3 = new MyThread(“Thread 3”);

T1.start();

T2.start();

T3.start();

20.With syntax, explain the use of isAlive() and join() methods.

isAlive() and join() Methods in Java

1. isAlive() Method

The isAlive() method is used to check whether a thread is still active or has finished executing. It
returns true if the thread is currently running or in a runnable state, and false otherwise.

Syntax:

Public final boolean isAlive();

Example:

Class MyThread extends Thread {

@Override

Public void run() {

System.out.println(“Thread is running…”);

Public class Main {

Public static void main(String[] args) {

MyThread t1 = new MyThread();

T1.start();

System.out.println(“Is thread alive? “ + t1.isAlive());

2. join() Method

The join() method allows one thread to wait until another thread completes its execution. This is
useful for ensuring that a specific thread finishes before proceeding with the rest of the program.

Syntax:

Public final void join() throws InterruptedException;

Example:

Class MyThread extends Thread {

@Override

Public void run() {

For (int I = 0; I < 3; i++) {

System.out.println(Thread.currentThread().getName() + “ is running…”);

}
 }

Public class Main {

Public static void main(String[] args) {

MyThread t1 = new MyThread();

T1.start();

Try {

T1.join(); // Main thread waits for t1 to finish

} catch (InterruptedException e) {

System.out.println(e.getMessage());

System.out.println(“Main thread resumes after t1 completes.”);

21. What is the need of synchronization? Explain with an example how synchronization

is implemented in JAVA.

Answer:Need for Synchronization

Synchronization is required in Java to control access to shared resources by multiple threads. When
multiple threads access and modify a shared resource concurrently, it can lead to data inconsistency
and unpredictable behavior. Synchronization ensures that only one thread can access the critical
section (shared resource) at a time, preventing race conditions and maintaining data integrity.

Example: Why Synchronization is Needed

Consider a scenario where two threads increment a shared counter:

Class Counter {

Int count = 0;
 Void increment() {

Count++;

Public class Main {

Public static void main(String[] args) {

Counter counter = new Counter();

Thread t1 = new Thread(() -> {

For (int I = 0; I < 1000; i++) counter.increment();

});

Thread t2 = new Thread(() -> {

For (int I = 0; I < 1000; i++) counter.increment();

});

T1.start();

T2.start();

Try {

T1.join();

T2.join();

} catch (InterruptedException e) {

System.out.println(e.getMessage());

System.out.println(“Final count: “ + counter.count);

Output (without synchronization):

The output may vary, but it is often less than 2000 due to race conditions, where both threads
modify the value of count simultaneously.
Solution: Synchronization

To avoid race conditions, we synchronize the critical section using the synchronized keyword.

Implementing Synchronization in Java

Example:

Class Counter {

Int count = 0;

Synchronized void increment() { // Synchronized method

Count++;

Public class Main {

Public static void main(String[] args) {

Counter counter = new Counter();

Thread t1 = new Thread(() -> {

For (int I = 0; I < 1000; i++) counter.increment();

});

Thread t2 = new Thread(() -> {

For (int I = 0; I < 1000; i++) counter.increment();

});

T1.start();

T2.start();

Try {

T1.join();

T2.join();

} catch (InterruptedException e) {

System.out.println(e.getMessage());

System.out.println(“Final count: “ + counter.count);

 }

Key Points about Synchronization

1. Synchronized Method: Ensures only one thread executes the method at a time.
2. Synchronized Block: Limits synchronization to specific parts of a method for better
performance.
3. Locking Mechanism: A thread acquires a lock on the object before entering the synchronized
block or method and releases it after exiting.

Synchronized Block Syntax:

Synchronized (object) {

// Critical section

22. Discuss the significance of thread priorities in JAVA.

Answer:Thread Priorities

Java assigns to each thread a priority that determines

How that thread should be treated with respect to the Others.

Thread priorities are integers that specify the relative Priority of one thread to another.

a higher-priority thread doesn’t run any faster than a Lower-priority thread if it is the only thread
running.

Instead, a thread’s priority is used to decide when to Switch from one running thread to the next.
This is Called a context switch.

The rules that determine when a context switch takes

Place are simple:

A thread can voluntarily relinquish Control: This is done by explicitly

Yielding, sleeping, or blocking on pending I/O. In this scenario, all other threads are Examined, and
the highest-priority thread That is ready to run is given the CPU. A thread can be preempted by a
higher-Priority thread: In this case, a lower-Priority thread that does not yield the Processor is simply
preempted—no matter What it is doing— by a higher-priority Thread. Basically, as soon as a higher-

Priority thread wants to run, it does. This is called preemptive multitasking.

In cases where two threads with the same priority are Competing for CPU cycles, the situation is a
bit Complicated.

23. Explain how to achieve suspending, resuming and stopping threads with an example

program.
Answers,:In Java, threads can be suspended, resumed, and stopped using flags and control logic. A
thread is suspended by setting a flag and putting it in a wait() state, resumed by resetting the flag
and calling notify(), and stopped by using a termination flag in the run() method. Deprecated
methods like suspend(), resume(), and stop() should be avoided due to safety concerns. Example:

Class ControlledThread extends Thread {

Private boolean isSuspended = false, isStopped = false;

Synchronized void suspendThread() { isSuspended = true; }

Synchronized void resumeThread() { isSuspended = false; notify(); }

Void stopThread() { isStopped = true; }

Public void run() {

Try {

While (!isStopped) {

Synchronized (this) { while (isSuspended) wait(); }

System.out.println(“Running…”); Thread.sleep(1000);

} catch (InterruptedException e) {}

Create and control the thread using the above logic.

24. Discuss values() and value Of() methods in Enumerations with suitable examples.

Answer:values() and valueOf() Methods in Enumerations

Java enumerations (enums) are special classes that represent a group of constants. Two commonly
used methods in enums are values() and valueOf().

1. Values() Method

The values() method returns an array containing all the constants of the enum in the order they are
declared. It is automatically added to every enum by the compiler.

Syntax:

Public static enumType[] values();

Example:

Enum Days {

MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY;

}
Public class EnumExample {

Public static void main(String[] args) {

Days[] days = Days.values();

For (Days day : days) {

System.out.println(day);

2. valueOf() Method

The valueOf() method returns the enum constant of the specified name. The name must exactly
match an identifier used to declare the enum constant, and it is case-sensitive.

Syntax:

Public static enumType valueOf(String name);

Example:

Enum Days {

MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY;

Public class EnumExample {

Public static void main(String[] args) {

Days day = Days.valueOf(“FRIDAY”);

System.out.println(“Selected day: “ + day);

Key Points

Use values() to iterate through all constants of the enum.

Use value Of() to retrieve a specific enum constant by its name.

If the string passed to valueOf() does not match any enum constant, it throws an
IllegalArgumentException.