Oop’s using java

Model paper 4

2 marks

1. Mention any four features of Java. (2 Marks)

Ans:

1. Simple – Java is easy to learn and use.

2. Object-Oriented – Java uses objects to organize code and data.

3. Platform Independent – Java programs can run on any computer using Java.

4. Secure – Java has built-in safety features to protect data and programs.

2. What is polymorphism? List the types of polymorphism.

Ans:

Polymorphism means one thing behaving in different ways. In Java, it allows the same
method to do different tasks.

Types of Polymorphism:

1. Compile-time Polymorphism (also called Method Overloading)

2. Run-time Polymorphism (also called Method Overriding)

3. What are instance variables? How are they different from class variables?

Ans:

Instance variables are variables that belong to an object. Each object has its own copy
of instance variables.

Class variables are variables that belong to the class. They are shared by all objects of
that class. Class variables are declared using the static keyword.

Difference:

Instance variables are unique to each object.

Class variables are common for all objects.

4. What is the purpose of the this and super keyword in Java?

Ans:

This keyword is used to refer to the current object of the class. It helps to access
instance variables or methods of the current object.
Super keyword is used to refer to the parent (super) class. It is used to call the parent
class’s constructor or methods.

5. What is compile-time and run-time polymorphism? (2 Marks)

Ans:

Compile-time polymorphism happens when the method to be called is decided during

compilation. It is also called method overloading.

Run-time polymorphism happens when the method to be called is decided while the
program is running. It is also called method overriding.

6. What is the difference between a class and an interface?

Ans:

A class is a blueprint to create objects. It can have both variables and method
definitions (with code).

An interface is like a contract. It only has method declarations (no code) and constants.
Classes use implements to use an interface.

Main Difference:

A class can have full code.

An interface only shows what methods a class must have (no code inside methods).

7. What is serialization and deserialization?

Ans:

Serialization is the process of converting an object into a file or byte stream so it can be
saved or sent over a network.

Deserialization is the process of converting the saved data (byte stream) back into an
object.

These are used to store or transfer objects in Java.

8. What is an Event and Event Handling in Java?

Ans:

An Event is an action done by the user, like clicking a button, typing a key, or moving the
mouse.

Event Handling is the process of responding to those actions. In Java, it means writing
code that runs when an event happens.

Java uses event listeners to handle events.

9. What is a Label and Button in AWT?

Ans:

A Label in AWT is a text display used to show a short message or description. It cannot
be clicked.

A Button in AWT is a clickable component that performs an action when the user clicks
on it.

Both are part of the AWT (Abstract Window Toolkit) used for creating GUI (Graphical
User Interface) in Java.

10. What is thread synchronization? How is it achieved in Java?

Ans:

Thread synchronization is a way to make sure that only one thread can access shared
data at a time. It helps avoid conflicts and keeps data safe.

In Java, synchronization is achieved using the synchronized keyword. It can be used

with methods or blocks to allow only one thread to execute at a time.

6 marks

11. Explain the scope of variables in Java. (8 Marks)

Ans:

In Java, the scope of a variable means where the variable can be used or accessed in
the program. There are four main types of variable scopes:

1. Local Variables:

These variables are declared inside a method, block, or constructor.

They are only available within that method or block.

They are created when the method starts and destroyed when it ends.

Example:

Void show() {

Int a = 10; // local variable

System.out.println(a);

2. Instance Variables:

These variables are declared inside a class but outside any method.
Each object of the class gets its own copy of instance variables.

They are created when the object is created and destroyed when the object is
destroyed.

Example:

Class Student {

Int age; // instance variable

3. Class Variables (Static Variables):

These variables are declared using the static keyword inside a class.

They are shared by all objects of the class.

They are created only once when the class is loaded.

Example:

Class Student {

Static String schoolName = “ABC School”; // class variable

4. Parameter Variables:

These are variables passed to methods as arguments.

They are treated like local variables inside the method.

Example:

Void display(String name) { // ‘name’ is a parameter variable

System.out.println(name);

Conclusion:

Understanding variable scope helps to use variables correctly and avoid errors in Java
programs. It controls where a variable is visible, how long it lives, and who can access it.

12. What is a labelled loop? Explain with an example.

Ans:
In Java, a labelled loop is a loop that has a name (label) before it. Labels are used to
control nested loops by allowing the program to break out of or continue specific loops
using break or continue with the label name.

This is especially useful when you have loops inside loops (nested loops), and you want
to exit or skip the outer loop based on a condition inside the inner loop.

Why use labelled loops?

In normal break, only the inner loop stops.

With labelled break, you can stop the outer loop directly.

With labelled continue, you can skip to the next iteration of the outer loop.

Syntax of Labelled Loop:

labelName:

for (initialization; condition; update) {

for (initialization; condition; update) {

// code

Break labelName;

Example 1: Using break with labelled loop

outerLoop:

for (int i = 1; i <= 3; i++) {

for (int j = 1; j <= 3; j++) {

if (j == 2) {

break outerLoop; // breaks out of outer loop

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

Output:

I = 1, j = 1
Explanation:

When j == 2, break outerLoop; stops the outer loop.

So only the first inner loop (when i = 1, j = 1) runs.

Example 2: Using continue with labelled loop

outerLoop:

for (int i = 1; i <= 3; i++) {

for (int j = 1; j <= 3; j++) {

if (j == 2) {

continue outerLoop; // skips to next outer loop iteration

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

Output:

I = 1, j = 1

I = 2, j = 1

I = 3, j = 1

Explanation:

When j == 2, continue outerLoop; skips the rest of the inner loop and moves to the next i
value in the outer loop.

Conclusion:

Labelled loops in Java give more control over nested loops. They help in writing clean
and readable code when you need to break or continue from outer loops based on inner
loop conditions.

13. Explain the different ways of creating wrapper objects in Java.

Ans: In Java, wrapper classes are used to convert primitive data types (like int, char,
float, etc.) into objects. This is useful when we want to store primitive values in
collections like ArrayList, which only work with objects.

Java provides wrapper classes like:

Primitive Type Wrapper Class

Int Integer

Char Character

Float Float

Double Double

Boolean Boolean

Ways to Create Wrapper Objects

There are three main ways to create wrapper objects:

1. Using Constructor (Old Way – Not Recommended Now)

Integer num = new Integer(10);

This creates an Integer object with the value 10.

This method is not recommended now because it is slow and deprecated in newer
versions of Java.

2. Using valueOf() Method (Recommended Way)

Integer num = Integer.valueOf(10);

Boolean flag = Boolean.valueOf(true);

This is the preferred way to create wrapper objects.

It is faster and uses object caching to save memory.

3. Autoboxing (Automatic Conversion)

Integer num = 10; // automatically converts int to Integer

Java automatically converts a primitive value into a wrapper object.

This feature is called autoboxing.

It is easy to use and makes code short and simple.

Unboxing (Opposite of Autoboxing)

Java can also automatically convert a wrapper object back into a primitive type.

Integer num = 20;

Int x = num; // unboxing

Example:
Public class WrapperExample {

Public static void main(String[] args) {

// Using valueOf()

Integer a = Integer.valueOf(100);

// Autoboxing

Double b = 10.5;

// Unboxing

Int c = a; System.out.println(“Integer: “ + a); System.out.println(“Double: “ + b);

System.out.println(“Unboxed int: “ + c);

Conclusion:

Wrapper objects allow primitive values to be used as objects in Java.

The most common and best way to create wrapper objects is by using valueOf() or
autoboxing. These are used in collections, method calls, and more.

14. What is Event Delegation Model? How does Event Delegation Model work in Java?

Ans:

What is Event Delegation Model?

The Event Delegation Model in Java is a way to handle events (like button clicks, key
presses, mouse movements) in GUI (Graphical User Interface) programs.

In this model, event handling is separated from the GUI components. When an event
happens, it is sent (delegated) to an object that is responsible for handling it.

Main Idea:

A source (like a button) generates an event.

A listener waits and handles that event.

The event is passed to the listener, not handled directly by the source.

This makes the code clean, simple, and easy to manage.

How Event Delegation Model Works:

There are three main parts:

Part Description

Event Source The object where the event occurs (e.g., button, text field).

Event Object Contains information about the event (like which button was clicked).

Event Listener Interface that contains methods to handle the event.

Steps in Event Handling:

1. User performs an action (like clicking a button).

2. The event source creates an event object.

3. The event is sent to the registered listener.

4. The listener’s method is called to handle the event.

Example in Simple Java:

Import java.awt.*;

Import java.awt.event.*;

Public class MyEventDemo {

Public static void main(String[] args) {

Frame f = new Frame(“Event Demo”);

Button b = new Button(“Click Me”);

b.setBounds(100, 100, 80, 30);

f.add(b);

f.setSize(300, 300);

f.setLayout(null);

f.setVisible(true);

// Event handling using Event Delegation Model

b.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

System.out.println(“Button was clicked!”);

});

}
}

Explanation of Example:

Button is the event source.

ActionEvent is the event object.

ActionListener is the listener interface.

When the button is clicked, the message “Button was clicked!” is printed.

Advantages of Event Delegation Model:

Simpler and cleaner code

Better performance (only one listener can handle many events)

Easy to separate design and logic

Conclusion:

The Event Delegation Model is the standard way of handling events in Java. It separates
the event-handling code from the user interface, making programs modular, readable,
and easier to manage.

15. Explain the steps involved in developing and executing an applet using HTML.

Ans:

An applet is a small Java program that runs inside a web browser. Applets are used to
create interactive web applications with graphics and user interface components.

To develop and run an applet, we need to follow several steps.

Steps to Develop and Execute an Applet Using HTML

Step 1: Create an Applet Program

Write a Java program that extends the Applet class.

Override its methods like init(), start(), paint(), etc.

Example:

Import java.applet.Applet;

Import java.awt.Graphics;

Public class MyApplet extends Applet {

Public void paint(Graphics g) {

 g.drawString(“Hello, Applet!”, 50, 50);

Step 2: Compile the Java File

Save the file as MyApplet.java.

Open the command prompt and compile it:

Javac MyApplet.java

This will generate a MyApplet.class file.

Step 3: Create an HTML File

Create an HTML file to load and run the applet in a browser or applet viewer.

Example:

<html>

<head><title>My Applet</title></head>

<body>

<applet code=”MyApplet.class” width=”300” height=”200”>

</applet>

</body>

</html>

Save it as MyApplet.html.

➢ Note: The <applet> tag is deprecated in modern browsers, so it works only with
applet viewers like the appletviewer tool.

Step 4: Run the Applet Using AppletViewer

In the command prompt, use the following command:

Appletviewer MyApplet.html

This will open a window and display the output of the applet.

Applet Lifecycle Methods (Optional for extra marks):

1. init() – Called once when the applet is started.

2. start() – Called every time the applet becomes active.

3. paint(Graphics g) – Used to draw on the screen.

4. stop() – Called when the applet is not visible.

5. destroy() – Called when the applet is removed from memory.

Conclusion:

To create and execute an applet using HTML:

1. Write the applet program.

2. Compile the Java file.

3. Create an HTML file with the <applet> tag.

4. Run it using appletviewer.

Applets are useful for making small Java-based applications inside web pages, though
they are now outdated in modern web browsers.

16. What are the types of threads? Explain with examples.

Ans:

In Java, a thread is a lightweight process that allows a program to perform multiple tasks
at the same time (called multithreading).

There are two main types of threads in Java:

1. User Threads

These are threads created by the programmer.

They perform the main tasks of the application.

The program keeps running as long as at least one user thread is active.

Example:

Public class MyThread extends Thread {

Public void run() {

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

Public static void main(String[] args) {

MyThread t = new MyThread(); // user thread

t.start();
 System.out.println(“Main Thread is running...”);

Output:

User Thread is running...

Main Thread is running...

2. Daemon Threads

These are background threads that support user threads.

They automatically stop when all user threads are finished.

Used for tasks like garbage collection, background saving, etc.

How to create a daemon thread:

Use setDaemon(true) before starting the thread.

Example:

Public class DaemonExample extends Thread {

Public void run() {

If (Thread.currentThread().isDaemon())

System.out.println(“This is a daemon thread”);

Else

System.out.println(“This is a user thread”);

Public static void main(String[] args) {

DaemonExample t1 = new DaemonExample(); // user thread

DaemonExample t2 = new DaemonExample(); // daemon thread

T2.setDaemon(true); // set t2 as daemon

T1.start();

T2.start();

}
Output:

This is a user thread

This is a daemon thread

Conclusion:

Java has two types of threads:

1. User threads – Do the main job.

2. Daemon threads – Support in the background.

Both are useful for running tasks simultaneously and improving the performance of Java
applications.

8marks

17 (a)Explain the difference between JDK, JRE and JVM.

(b) What is the conditional (ternary) operator (‘?:’)? Explain with a program

(a) Difference between JDK, JRE, and JVM:

1. JDK (Java Development Kit)

It is used to develop Java programs.

It includes JRE + development tools (like compiler javac, debugger, etc.).

Needed by programmers to write and run Java code.

2. JRE (Java Runtime Environment)

It is used to run Java programs.

It includes JVM + libraries + class files.

It does not have development tools like compiler.

3. JVM (Java Virtual Machine)

It is a part of JRE.

It executes the Java bytecode (.class file).

It makes Java platform-independent by running the same code on any system.

Summary:

JVM runs the code.

JRE provides environment to run the code.

JDK provides tools to write and run the code.

(b) Conditional (Ternary) Operator (?:): The ternary operator is a short form of if-else
statement. It is used to decide a value based on a condition.

Syntax: condition ? value_if_true : value_if_false;

Example Program:

Public class TernaryExample {

Public static void main(String[] args) {

Int a = 10, b = 20;

Int max = (a > b) ? a : b; // checks which is greater System.out.println(“Maximum

value is: “ + max);

Output:

Maximum value is: 20

18 (a) Explain if-else statement with an example

(b) Write a program to find the largest of three numbers using nested if else.

(a) if-else Statement:

The if-else statement is used to run one block of code if a condition is true, and another
block if it is false.

Syntax:

If (condition) {

// code if condition is true

} else {

// code if condition is false

Example:

Int number = 10;

If (number > 0) {
System.out.println(“Positive number”);

} else {

System.out.println(“Negative number or zero”);

(b) Program to Find the Largest of Three Numbers using Nested if-else:

Import java.util.Scanner;

Public class LargestNumber {

Public static void main(String[] args) {

Scanner input = new Scanner(System.in); System.out.print(“Enter first number: “);

Int a = input.nextInt(); System.out.print(“Enter second number: “);

Int b = input.nextInt(); System.out.print(“Enter third number: “);

Int c = input.nextInt();

Int largest;

If (a > b) {

If (a > c) {

Largest = a;

} else {

Largest = c;

} else {

If (b > c) {

Largest = b;

} else {

Largest = c;

} System.out.println(“The largest number is: “ + largest);

}
19 (a) Hiw to declare, initialize and access multiple dimensional arrays? With an
example.

(b) What are access control modifiers? Explain the role of each access modifer with an
example.

(a) A multidimensional array is an array of arrays. The most common is the 2D array (like
a matrix).

Declaration:

Int[][] arr;

Initialization:

Arr = new int[2][3]; // 2 rows and 3 columns

Assigning values:

Arr[0][0] = 10;

Arr[0][1] = 20;

Arr[1][2] = 30;

Accessing values:

System.out.println(arr[1][2]); // prints 30

Complete Example:

Public class MultiArrayExample {

Public static void main(String[] args) {

Int[][] arr = {

{1, 2, 3},

{4, 5, 6}

};

For (int i = 0; i < arr.length; i++) {

For (int j = 0; j < arr[i].length; j++) {

System.out.print(arr[i][j] + “ “);

} System.out.println();

}
}

(b) Access modifiers control the visibility of classes, variables, and methods in Java.

1. private

Accessible only within the same class.

Private int a = 10;

2. Default (no modifier)

Accessible within the same package.

Int b = 20; // default

3. Protected

Accessible within the same package and in subclasses (even in other packages).

Protected int c = 30;

4. Public

Accessible from anywhere in any class or package.

Public int d = 40;

Example:

Public class Demo {

Private int a = 1;

Int b = 2; // default

Protected int c=3;

Public int d = 4;

Public void display() {

System.out.println(a + “, “ + b + “, “ + c + “, “ + d);

These modifiers help with data hiding, security, and code organization in Java.

20 (a) What are different types of packages in java? Explain with an example.

(b) Write note on Java.awt Package

[07/06, 8:32 am] Romeo: (a) In Java, packages are used to group related classes and
interfaces together. They help in avoiding name conflicts and in controlling access.
There are two main types of packages:

1. Built-in Packages (Predefined Packages)

These packages are provided by Java and are available for use. Examples include:

Java.lang – Contains fundamental classes (automatically imported)

Java.util – Contains utility classes like ArrayList, HashMap

Java.io – Contains classes for input and output

Java.net – For networking operations

Java.sql – For database operations

Java.awt – For GUI development

2. User-defined Packages

These are packages created by the user to organize their own classes and interfaces.

Example of a user-defined package:

// Save this as MyClass.java inside the “mypackage” folder

Package mypackage;

Public class MyClass {

Public void display() { System.out.println(“Hello from MyClass in mypackage!”);

// Another file in a different location

Import mypackage.MyClass;

Public class TestPackage {

Public static void main(String[] args) {

MyClass obj = new MyClass();

Obj.display();

(b)
The java.awt (Abstract Window Toolkit) package is a part of Java’s standard library used
for creating Graphical User Interfaces (GUIs).

Key Points:

It provides components like buttons, labels, text fields, windows, and more.

It is platform-dependent, meaning its components look different on different operating

systems because they rely on native GUI components.

Replaced in many cases by Swing (javax.swing), which is more flexible and platform-
independent, but java.awt is still used especially for base classes like Graphics.

Common Classes in java.awt:

Class Description

Frame A top-level window

Button A button that performs an action

Label Displays a single line of text

TextField Allows user to input a single line of text

Graphics Used for drawing shapes or text

Panel Generic container

Color, Font Used to set colors and fonts

Event, ActionListener For handling GUI events

Simple Example using java.awt:

Import java.awt.*;

Public class AWTExample {

Public AWTExample() {

Frame f = new Frame(“AWT Example”);

Label l = new Label(“Enter Name:”); l.setBounds(20, 50, 100, 30);

TextField t = new TextField(); t.setBounds(130, 50, 100, 30);

Button b = new Button(“Submit”); b.setBounds(100, 100, 80, 30);

f.add(l);

f.add(t);

f.add(b);

f.setSize(300, 200);

f.setLayout(null);

f.setVisible(true);

Public static void main(String[] args) {

New AWTExample();

21 (a) Explain ObjectInputStream and ObjectOutputStream.

(b) What are Mouse Events? Explain the MouseListener and MouseMotionListener
Interface Methods.

(a) ObjectInputStream and ObjectOutputStream:

ObjectOutputStream and ObjectInputStream are used to write and read objects to and
from a file or stream.

This process is called Serialization (writing) and Deserialization (reading).

ObjectOutputStream:

Used to write objects to a file.

ObjectOutputStream out = new ObjectOutputStream(new
FileOutputStream(“data.txt”));

Out.writeObject(object);

ObjectInputStream:

Used to read objects from a file.

ObjectInputStream in = new ObjectInputStream(new FileInputStream(“data.txt”));

MyClass obj = (MyClass) in.readObject();

(b) Mouse Events:

Mouse Events occur when the user interacts with the mouse (clicks, presses, moves,
releases, etc.).

There are two interfaces to handle mouse events:

1. MouseListener

Handles basic mouse actions like click, press, release.

Methods:

mouseClicked(MouseEvent e)

mousePressed(MouseEvent e)

mouseReleased(MouseEvent e)

mouseEntered(MouseEvent e)

mouseExited(MouseEvent e)

2.MouseMotionListener

Handles mouse movement.

Methods:

mouseMoved(MouseEvent e)

mouseDragged(MouseEvent e)

Example:

addMouseListener(new MouseAdapter() {

public void mouseClicked(MouseEvent e) {

 System.out.println(“Mouse Clicked”);

});

addMouseMotionListener(new MouseMotionAdapter() {

public void mouseMoved(MouseEvent e) {

System.out.println(“Mouse Moved”);

});

These interfaces are part of java.awt.event package and are useful for interactive GUI
programs.

22 (a) What is custom (user defined) exception? How do you create & use in one Java?

(b) Write the steps involved in creating a thread by implementing runnable interface.

(a) A custom exception is a user-defined class that extends Java’s Exception class. It is
used when we want to create our own error types to handle specific problems in a
program.

How to Create and Use:

1. Create a class that extends Exception.

2. Use throw to raise it.

3. Use try-catch to handle it.

Example:

// Step 1: Create custom exception

Class MyException extends Exception {

Public MyException(String message) {

Super(message);

// Step 2: Use custom exception

Public class Test {

Public static void main(String[] args) {

 Try {

Int age = 15;

If (age < 18) {

Throw new MyException(“Age must be 18 or above”);

} catch (MyException e) {

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

(b) Steps to Create a Thread Using Runnable Interface:

1. Create a class that implements the Runnable interface.

2. Override the run() method inside that class.

3. Create an object of the class.

4. Pass the object to a Thread constructor.

5. Start the thread using the start() method.

Example:

Class MyRunnable implements Runnable {

Public void run() {

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

Public class Test {

Public static void main(String[] args) {

MyRunnable obj = new MyRunnable(); // Step 3

Thread t = new Thread(obj); // Step 4

t.start(); // Step 5

}
}

Using Runnable is preferred when your class needs to extend another class (since Java
doesn’t support multiple inheritance with classes).

23 (a) Describe the Hierarchy of Collection Framework

(b) What is Generic Programming? Explain the features of Generic Programming.

(a) The Collection Framework in Java provides a standard way to handle groups of
objects. It includes interfaces, classes, and algorithms.

Hierarchy Overview:

Iterable

Collection

List Set Queue

ArrayList HashSet PriorityQueue

LinkedList LinkedHashSet etc.

Vector TreeSet

Map (Not part of Collection interface)

HashMap, TreeMap, LinkedHashMap

Key Interfaces:

Collection: Root of the framework.

List: Ordered collection (allows duplicates). Example: ArrayList, LinkedList.

Set: Unordered, no duplicates. Example: HashSet, TreeSet.

Queue: For holding elements prior to processing. Example: PriorityQueue.

Map: Stores key-value pairs. Example: HashMap, TreeMap.

(b) Generic Programming in Java allows writing code that works with any data type using
a placeholder (like <T>). It increases code reusability and type safety.
Features of Generic Programming:

1. Type Safety

Detects type errors at compile time, not at runtime.

ArrayList<String> list = new ArrayList<>();

2. Code Reusability

The same code works with different types.

Class Box<T> {

T value;

Void set(T val) { value = val; }

T get() { return value; }

3. No Type Casting

No need to cast objects when retrieving.

String str = list.get(0); // no casting needed

4. Generic Methods and Classes

Can define generic methods and classes.

Public <T> void print(T item) {

System.out.println(item);

Generics make Java programs more flexible, readable, and maintainable.