UNIT 1

1. difference between c++ and java ? 4 marks

Difference between C++ and Java (4 Marks):

1. Platform Dependency:
a. C++ is platform-dependent (compiled into machine code).
b. Java is platform-independent (compiled to bytecode and runs on JVM).
2. Memory Management:
a. C++ uses manual memory management (via new and delete).
b. Java has automatic garbage collection.
3. Multiple Inheritance:
a. C++ supports multiple inheritance directly.
b. Java does not support multiple inheritance with classes (uses interfaces
instead).
4. Pointers:
a. C++ supports pointers explicitly.
b. Java does not support explicit pointers for security and simplicity.

2.explain counstruction in java with the help of example ? 8marks

✅ Constructors in Java (8 Marks)

🔹 What is a Constructor?

• A constructor is a special method used to initialize objects in Java.

• It has the same name as the class and no return type (not even void).
• It is called automatically when an object is created using the new keyword.
🔹 Types of Constructors:

1. Default Constructor
a. Takes no arguments.
b. Java provides it automatically if no constructor is defined.
2. Parameterized Constructor
a. Takes arguments to initialize fields with specific values.
3. Copy Constructor (Custom)
a. Copies values from one object to another (manually created, not built-in like
C++).

🔹 Example Program:

java
CopyEdit
class Student {
String name;
int age;

// Default Constructor
Student() {
name = "Unknown";
age = 0;
}

// Parameterized Constructor
Student(String n, int a) {
name = n;
age = a;
}

void display() {
System.out.println("Name: " + name + ", Age: " + age);
}
}

public class Main {

 public static void main(String[] args) {
Student s1 = new Student(); // Calls default
constructor
Student s2 = new Student("John", 20); // Calls
parameterized constructor

s1.display();
s2.display();
}
}

🔹 Key Features:

• Constructor can be overloaded (multiple constructors with different parameters).

• Used for object initialization.
• Helps in setting default or custom values at object creation time.

3. explain static member in java with example ?8 marks

✅ Static Members in Java (8 Marks)

🔹 What is a Static Member?

• A static member (variable or method) belongs to the class, not to any specific
object.
• It can be accessed without creating an object of the class.
• Static members are shared among all instances of a class.
🔹 Types of Static Members:

1. Static Variable
a. Shared across all objects.
b. Useful for constants or counting objects.
2. Static Method
a. Can be called using the class name.
b. Cannot access non-static (instance) variables directly.
3. Static Block
a. Executes once when the class is loaded.
b. Used for static initialization.

🔹 Example Program:

java
CopyEdit
class Student {
int rollNo;
static String college = "ABC College"; // Static variable

Student(int r) {
rollNo = r;
}

static void changeCollege(String name) {

college = name; // Static method
}

void display() {
System.out.println("Roll No: " + rollNo + ", College: " +
college);
}
}

public class Main {

public static void main(String[] args) {
Student s1 = new Student(101);
 Student s2 = new Student(102);

s1.display();
s2.display();

// Change college using static method

Student.changeCollege("XYZ University");

s1.display();
s2.display();
}
}

🔹 Key Points:

• Static members are class-level and shared.

• Static methods cannot use this.
• Ideal for utility or helper methods and common data.

4.what is java machine ? Explain its architecture? 8marks

🔹 Definition:

The Java Virtual Machine (JVM) is a part of the Java Runtime Environment (JRE) that runs
Java programs. It converts Java bytecode into machine code and executes it on the host
system. JVM makes Java platform-independent, meaning the same code can run on any
OS that has a JVM.

🔹 Architecture of JVM (Point-wise):

1. Class Loader:
a. Loads .class files (bytecode) into memory.
b. Performs loading, linking, and initialization.
 2. Method Area:
a. Stores class-level data like method code, field info, and static variables.
3. Heap:
a. Stores all objects and class instances.
b. Shared memory area.
4. Stack:
a. Stores method calls and local variables.
b. Each thread has its own stack.
5. Program Counter (PC) Register:
a. Stores the address of the current instruction being executed.
6. Execution Engine:
a. Interpreter: Reads and executes bytecode line by line.
b. JIT Compiler: Converts frequently used bytecode to native code for better
performance.
7. Native Method Interface:
a. Allows JVM to interact with native libraries (like C/C++).
8. Native Method Libraries:
a. Contains platform-specific native code used via JNI (Java Native Interface).

✅ Diagram (Text-based):

pgsql
CopyEdit
+-------------------------+
| Class Loader |
+-----------+-------------+
|
+-----------v-------------+
| Method Area |
+-----------+-------------+
| | |
+-------v-----+ +---v---+ +-------v------+
| Heap | | Stack | | PC Register |
+-------------+ +-------+ +--------------+
|
+-------v-------+
| Execution Engine |
+--------+--------+
|
+--------v--------+
| Native Interface |
+--------+--------+
| Native Libraries |
+------------------+

🔹 Conclusion:

• JVM is the heart of Java's "write once, run anywhere" principle.

• It loads, verifies, executes bytecode, and provides memory management and
security.

5. how java is platform independence ? 4marks

Java achieves platform independence through its compilation process and the use of the
Java Virtual Machine (JVM).

1. Compilation to Bytecode: Java source code (.java files) is compiled into bytecode
(.class files) by the Java compiler (javac). This bytecode is platform-neutral and not
specific to any operating system or hardware architecture.
2. Role of the JVM: The JVM is responsible for interpreting or compiling the bytecode
into native machine code that the host system can execute. Since JVM
implementations exist for various platforms (e.g., Windows, Linux, macOS), the
same bytecode can run on any system that has the appropriate JVM
installed .javatpoint.com

This combination of compiling to bytecode and interpreting it via the JVM allows Java
applications to be written once and run anywhere, embodying the "Write Once, Run
Anywhere" (WORA) philosophy.

6 explain the fratures in java? 8marks

1. Simple

• Java's syntax is clean and easy to learn, especially for those familiar with C/C++. It
eliminates complex features like pointers and multiple inheritance.
geeksforgeeks.org+1codejava.net+1

2. Object-Oriented

• Java follows Object-Oriented Programming principles such as Abstraction,

Encapsulation, Inheritance, and Polymorphism, promoting modular and reusable
code. geeksforgeeks.org+1jcodebook.com+1

3. Platform Independent

• Java code is compiled into bytecode, which can run on any platform with a
compatible Java Virtual Machine (JVM), embodying the "Write Once, Run Anywhere"
philosophy.

4. Secure

• Java provides a secure execution environment through features like bytecode

verification, secure class loading, and a robust security manager. scholarhat.com

5. Robust

• Java emphasizes early error checking, runtime checking, and garbage collection,
making it a reliable language for developing error-free applications. scholarhat.com

6. Multithreaded

• Java supports multithreading, allowing multiple threads to run concurrently, which

is essential for interactive and real-time applications. javatpoint.com

7. High Performance

• Java's performance is enhanced through Just-In-Time (JIT) compilers and efficient

garbage collection mechanisms.
8. Distributed Computing

• Java provides a set of APIs that make it easy to develop distributed applications,
facilitating file sharing, communication, and more. javatpoint.com

7. java is not 100% object oreanted language ? 8 marks

Why Java is Not 100% Object-Oriented

Java is often considered an object-oriented programming (OOP) language, but it is not

100% object-oriented due to the following reasons:

1. Primitive Data Types

Java includes primitive data types like int, char, boolean, etc., which are not
objects and do not have methods associated with them. This deviates from the pure
OOP principle where everything, including basic data types, should be treated as
objects.
2. Static Methods and Variables
Java allows the declaration of static methods and variables that belong to the class
itself rather than to instances of the class. This breaks the principle that all methods
and variables should be associated with objects.
3. Main Method
The entry point of a Java application is the static main method, which does not
require an object to be invoked. In pure OOP languages, the program typically starts
by creating an instance of a class.
4. Wrapper Classes
Java provides wrapper classes (e.g., Integer, Double) to convert primitive types
into objects. However, this introduces a hybrid approach, as the underlying
primitive types are still used for performance reasons, and operations on wrapper
objects may internally use primitive types.

Conclusion
While Java adheres to many OOP principles, its inclusion of primitive data types, static
members, and the use of wrapper classes and the static main method prevent it from
being considered a 100% object-oriented language.
UNIT 2

1. What is the diffrence between method overloading and method overriding?

8marks

✅ Difference Between Method Overloading and Method Overriding (8

Marks)

Feature Method Overloading Method Overriding

Defining multiple methods with the same
Redefining a parent class
Definition name but different parameters in the same
method in the child class.
class.
Inheritan
ce
No Yes
Required
?
Class Involves two classes
Occurs within the same class.
Involved (parent & child).
Polymorp
hism Compile-time polymorphism Runtime polymorphism
Type
Must have same name,
Paramete
Must differ in number, type, or order. return type, and
rs
parameters.
Return Must be same or
Can be different or same.
Type covariant.
Access Cannot be more restrictive
Can be anything
Modifier than the parent method
Allows specific behavior
Use Case Improves code readability and reusability.
for child class.
✅ Example of Overloading:

java
CopyEdit
class Calculator {
int add(int a, int b) { return a + b; }
double add(double a, double b) { return a + b; } // Overloaded
method
}

✅ Example of Overriding:

java
CopyEdit
class Animal {
void sound() { System.out.println("Animal sound"); }
}

class Dog extends Animal {

@Override
void sound() { System.out.println("Bark"); } // Overridden method
}

2. What is abstract class ? Write a program to inplement abstract class in java ?

8marks

✅ Abstract Class in Java (8 Marks)

🔹 What is an Abstract Class?

• An abstract class is a class that cannot be instantiated (no object can be created
directly).
• It can have abstract methods (without a body) and concrete methods (with body).
• It is used to provide a base for subclasses to implement or override specific
methods.
• Declared using the abstract keyword.

🔹 Key Features:

• Can include fields, constructors, and methods.

• Abstract methods must be implemented by the subclass.
• Helps in achieving abstraction and code reusability.

🔹 Example Program:

java
CopyEdit
// Abstract class
abstract class Animal {
// Abstract method (no body)
abstract void makeSound();

// Concrete method
void sleep() {
System.out.println("Sleeping...");
}
}

// Subclass (inherits Animal)

class Dog extends Animal {
// Implementing abstract method
void makeSound() {
System.out.println("Bark!");
 }
}

public class Main {

public static void main(String[] args) {
Dog myDog = new Dog(); // Create Dog object
myDog.makeSound(); // Call abstract method
myDog.sleep(); // Call concrete method
}
}

🔹 Output:

CopyEdit
Bark!
Sleeping...

🔹 Conclusion:

• Abstract classes are useful when you want to define a common template for all
subclasses.
• They provide partial abstraction and enforce implementation of specific methods

3. What is singleton class in java using example? 4/8marks

✅ Singleton Class in Java (Can be used for 4 or 8 Marks)

🔹 What is a Singleton Class?

A Singleton class in Java is a class that allows only one instance to be created throughout
the lifetime of the application.

It is used when:

• You want to control the creation of objects.

• One object must coordinate actions across the system (e.g., logging, config
manager, DB connection).

🔹 Key Features of Singleton:

1. Private constructor to restrict instantiation.

2. Private static object of the same class.
3. Public static method to provide access to the single instance.

🔹 Example:

java
CopyEdit
class Singleton {
private static Singleton instance;

// Private constructor
private Singleton() {
System.out.println("Singleton Instance Created");
}

// Static method to get the single instance

public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
 }
}

public class Main {

public static void main(String[] args) {
Singleton s1 = Singleton.getInstance();
Singleton s2 = Singleton.getInstance();

// Both references point to the same object

System.out.println(s1 == s2); // Output: true
}
}

🔹 Output:

nginx
CopyEdit
Singleton Instance Created
true

🔹 Conclusion:

• Singleton ensures only one object is created.

• Helps in memory efficiency and shared access.
• Widely used in logging, caching, and thread pool management.

Use this for 4 marks (briefly) or expand with explanation and use-cases for 8 marks.

4. explain exception handle in java ? give one example in user define exception?
8marks
✅ Exception Handling in Java with User-Defined Exception (8 Marks)

🔹 What is Exception Handling?

• Exception handling in Java is a mechanism to handle runtime errors so that

normal flow of the application is maintained.
• Java uses try, catch, finally, throw, and throws keywords to handle
exceptions.

🔹 Keywords:

1. try: Block of code that may throw an exception.

2. catch: Block that handles the exception.
3. finally: Block that executes whether or not an exception occurs.
4. throw: Used to throw an exception explicitly.
5. throws: Declares exceptions that might be thrown.

🔹 User-Defined Exception Example:

java
CopyEdit
// Creating a custom exception class
class InvalidAgeException extends Exception {
InvalidAgeException(String message) {
super(message);
}
}

public class TestException {

static void checkAge(int age) throws InvalidAgeException {
if (age < 18) {
throw new InvalidAgeException("Age must be 18 or above to
vote.");
 } else {
System.out.println("You are eligible to vote.");
}
}

public static void main(String[] args) {

try {
checkAge(15);
} catch (InvalidAgeException e) {
System.out.println("Exception Caught: " + e.getMessage());
}
}
}

🔹 Output:

pgsql
CopyEdit
Exception Caught: Age must be 18 or above to vote.

🔹 Conclusion:

• Exception handling makes programs more robust, reliable, and error-resistant.

• You can define your own exceptions to enforce custom rules.

This is a complete 8-mark answer with explanation and working example.

5. diffrentiate between interface and abstract clan ? 4marks

difference Between Interface and Abstract Class in Java

Feature Interface Abstract Class

 Supports multiple inheritance (a Does not support multiple
Multiple
class can implement multiple inheritance (a class can extend
Inheritance
interfaces) only one abstract class)

Can have only abstract methods Can have both abstract and
Methods (before Java 8); from Java 8 onwards, concrete (implemented)
can have default and static methods methods

All variables are public static Can have instance variables with
Variables
final (constants) by default any access modifier

Constructor Cannot have constructors Can have constructors

UNIT 3

1. compare the input strean and output stream? 4marks

Comparison Between Input Stream and Output Stream in Java

1. Purpose:
a. Input Stream: Used to read data from a source (e.g., file, keyboard).
b. Output Stream: Used to write data to a destination (e.g., file, console).
2. Direction of Data Flow:
a. Input Stream: Data flows into the program.
b. Output Stream: Data flows out of the program.
3. Base Classes:
a. Input Stream: java.io.InputStream (for byte streams).
b. Output Stream: java.io.OutputStream (for byte streams).
4. Common Methods:
a. Input Stream: read() to read bytes.
 b. Output Stream: write() to write bytes.
5. Usage:
a. Input Stream: Used to get input from files, network, etc.
b. Output Stream: Used to send output to files, network, etc.

2. explain input stream and output stream in detail with example?8marks

✅ What is an Input Stream?

• Definition: An Input Stream is used to read data (usually byte-by-byte) from a

source such as a file, keyboard, or network.
• Superclass: java.io.InputStream is the abstract superclass.
• Common Subclasses:
o FileInputStream – for reading from a file
o BufferedInputStream – for efficient reading

✅ What is an Output Stream?

• Definition: An Output Stream is used to write data (byte-by-byte) to a destination,

like a file or console.
• Superclass: java.io.OutputStream is the abstract superclass.
• Common Subclasses:
o FileOutputStream – for writing to a file
o BufferedOutputStream – for efficient writing

✅ Example: File Copy Program Using Input and Output Stream

java
CopyEdit
import java.io.*;

public class FileCopyExample {

 public static void main(String[] args) {
try {
FileInputStream input = new FileInputStream("input.txt");
FileOutputStream output = new
FileOutputStream("output.txt");

int data;
while ((data = input.read()) != -1) {
output.write(data);
}

input.close();
output.close();
System.out.println("File copied successfully!");
} catch (IOException e) {
System.out.println("Error: " + e.getMessage());
}
}
}

✅ Explanation:

• FileInputStream reads data byte by byte from "input.txt".

• FileOutputStream writes the same data into "output.txt".
• The program copies the contents from one file to another.
• The read() method returns -1 when the end of the file is reached.

✅ Summary Points:

• Input Streams handle data coming into the program.

• Output Streams handle data going out from the program.
• Always close the streams to free system resources.
• Suitable for handling binary data like images, PDFs, etc.
 4. Define syncronization explain the use of syncronization method with
example ? 8 marks

✅ Definition:

• Synchronization in Java is a technique used to control access to shared

resources by multiple threads.
• It ensures that only one thread can access a block of code or method at a time,
preventing data inconsistency or race conditions.
• Java provides the synchronized keyword to implement synchronization.

✅ Why Use Synchronization?

• To protect shared data from corruption when multiple threads try to read/write it at
the same time.
• To ensure thread safety in multithreaded applications.

✅ Synchronized Method:

• A method declared with the synchronized keyword ensures that only one thread
can execute it at a time for a given object.

Example

class Counter {

int count = 0;

public synchronized void increment() {

count++;
 }

public class SyncDemo {

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

Counter c = new Counter();

Thread t1 = new Thread(() -> {

for (int i = 0; i < 1000; i++) c.increment();

});

Thread t2 = new Thread(() -> {

for (int i = 0; i < 1000; i++) c.increment();

});

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

t1.join(); t2.join();

System.out.println("Final Count: " + c.count); // Output: 2000

4.define and explain wrapper class and string class with java program? 8marks
✅ 1. Wrapper Class

Definition:
Wrapper classes in Java are used to wrap primitive data types (int, float, char, etc.)
into objects.
Java provides a wrapper class for each primitive type:

• int → Integer
• char → Character
• float → Float
• etc.

Use Cases:

• Required when working with collections (like ArrayList, HashMap) which store
objects only.
• Enables features like autoboxing (automatic conversion of primitive to object) and
unboxing (object to primitive).

✅ 2. String Class

Definition:
The String class in Java is used to represent sequences of characters.
Strings are immutable, meaning once created, they cannot be changed.

Common Methods:

• length(), charAt(), substring(), equals(), toUpperCase(), concat(), etc.

✅ Java Program Example:

java
CopyEdit
import java.util.*;

public class WrapperStringExample {

 public static void main(String[] args) {
// Wrapper class example
int num = 10;
Integer obj = Integer.valueOf(num); // Boxing
int val = obj.intValue(); // Unboxing
System.out.println("Wrapper Example: " + val);

// String class example

String str = "Java";
String str2 = str.concat(" Programming");
System.out.println("String Example: " + str2);
System.out.println("Length: " + str2.length());
}
}

✅ Summary:

• Wrapper Classes allow primitives to be used as objects.

• String Class handles text and supports many useful methods.
• Both are part of Java's core library and are essential for object-oriented
programming.

5. write a java program to explain the concept of reading and writing from to disk?
8 mraks

🔸 Objective:

To demonstrate how to write data to a file and read it back from disk using Java I/O
streams.
✅ Java Program:

java
CopyEdit
import java.io.*;

public class FileReadWriteExample {

public static void main(String[] args) {
String data = "This is a file writing and reading example.";

try {
// Step 1: Write data to file
FileWriter writer = new FileWriter("sample.txt");
writer.write(data);
writer.close(); // Always close writer
System.out.println("Data written to file successfully.");

// Step 2: Read data from file

FileReader reader = new FileReader("sample.txt");
int ch;
System.out.print("Data read from file: ");
while ((ch = reader.read()) != -1) {
System.out.print((char) ch);
}
reader.close(); // Always close reader

} catch (IOException e) {
System.out.println("An error occurred: " +
e.getMessage());
}
}
}

✅ Explanation:

1. FileWriter is used to write the string to sample.txt on disk.

2. FileReader is used to read the contents of the same file.
 3. Data is processed character by character using a while loop.
4. Both streams are closed to release system resources.

✅ Output:

pgsql
CopyEdit
Data written to file successfully.
Data read from file: This is a file writing and reading example.

✅ Summary:

• This program uses character streams (FileWriter and FileReader) to

demonstrate file handling.
• It shows both writing to disk and reading from disk in Java.
• Suitable for explaining I/O in 8-mark answers.

6.explain the following

1) reader class

2) write class

✅ Introduction:

In Java, Reader and Writer classes are part of the java.io package. They are used for
handling character streams, i.e., reading and writing text data (not binary).
🔹 1. Reader Class

• Reader is an abstract class used for reading character streams.

• It reads characters, arrays, or lines from text sources like files.
• Useful when dealing with text files or data that needs to be read in character
format.

Common Subclasses:

• FileReader: Reads data from a file.

• BufferedReader: Reads text efficiently using a buffer and allows reading line-by-
line using readLine().

🔹 2. Writer Class

• Writer is an abstract class used for writing character streams.

• It writes characters, strings, or arrays to text files or other outputs.
• Used for creating or modifying text files.

Common Subclasses:

• FileWriter: Writes data to a file.

• BufferedWriter: Writes text efficiently using a buffer.

🔹 Example:

java
CopyEdit
import java.io.*;

public class ReaderWriterDemo {

public static void main(String[] args) {
try {
// Writer: writing to a file
Writer w = new FileWriter("output.txt");
 w.write("Hello, Java I/O!");
w.close();

// Reader: reading from a file

Reader r = new FileReader("output.txt");
int ch;
System.out.print("Reading from file: ");
while ((ch = r.read()) != -1) {
System.out.print((char) ch);
}
r.close();
} catch (IOException e) {
System.out.println("Error: " + e.getMessage());
}
}
}

✅ Summary Table:

Feature Reader Class Writer Class

Reads characters Writes characters
Direction
(input) (output)

Base Class java.io.Reader java.io.Writer

Example
Reading text files Writing text files
Uses

7.What is multithreding? 4marks

🔹 Definition:

Multithreading is a feature in Java that allows the execution of two or more threads
concurrently within a program.
Each thread is a lightweight, independent path of execution, running within a single
process.

🔹 Key Points:

1. Thread: A thread is a smaller unit of a process.

2. Multithreading improves application performance by doing multiple tasks in
parallel.
3. It is used in games, real-time systems, animations, servers, etc.
4. Java provides built-in support through the Thread class and Runnable interface.

🔹 Example:

java
CopyEdit
class MyThread extends Thread {
public void run() {
System.out.println("Thread is running");
}
}

public class Test {

public static void main(String[] args) {
MyThread t = new MyThread();
t.start(); // Starts the new thread
}

8. what is mutable and immutable in java also explain string and string buffer class?
8marks

+ String vs StringBuffer Classes

🔹 1. Mutable vs Immutable Objects

Property Immutable Mutable

Can be modified after
Definition Cannot be changed after creation
creation
Creates a new object when
Memory Changes the same object
modified
Example StringBuffer,
String
Classes StringBuilder

🔹 2. String Class (Immutable)

• String objects are immutable, meaning their content cannot be changed once
created.
• Any operation like concat() or replace() returns a new String.

Example:

java
CopyEdit
public class ImmutableExample {
public static void main(String[] args) {
String s = "Java";
s.concat(" Programming");
System.out.println(s); // Output: Java (not changed)
}
}

🔹 3. StringBuffer Class (Mutable)

• StringBuffer is mutable, meaning you can modify the content without creating
a new object.
• Used when you need to manipulate strings frequently (e.g., in loops).

Example:
java
CopyEdit
public class MutableExample {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer("Java");
sb.append(" Programming");
System.out.println(sb); // Output: Java Programming
}
}

✅ Summary:

• Immutable: String – content can't be changed.

• Mutable: StringBuffer – content can be changed.
• Use StringBuffer when performance matters and changes are needed.
• String is thread-safe, and so is StringBuffer.

UNIT 4

1.explain applet tag with all its attribute in detail ?4marks

✅ What is the <applet> Tag?

• The <applet> tag is used to embed a Java applet (a small Java program) inside an
HTML page.
• It allows Java programs to run inside web browsers.

✅ Attributes of <applet> Tag:

Attribute Description
 Specifies the name of the Java class file (the applet) to run. Example:
code
code="MyApplet.class"

width Specifies the width of the applet display area in pixels. Example: width="300"

height Specifies the height of the applet display area in pixels. Example: height="200"

Specifies the base URL for the applet code, if not in the same directory as the
codebase
HTML file.

alt Provides an alternative text when the applet cannot be loaded or run.
name Assigns a name to the applet for identification.

Specifies a JAR file containing the applet class and related files to reduce
archive
downloads.

align Specifies the alignment of the applet in the HTML page (e.g., left, right).

2.explain the life cycle of applet using example? 8marks

✅ 1. What is an Applet Life Cycle?

• The life cycle of an applet defines the sequence of methods invoked during its
execution.
• There are five main methods that control an applet’s life from loading to unloading.

✅ 2. Main Life Cycle Methods:

Method Purpose
init() Called once when the applet is first loaded; used for initialization.
Called after init() and whenever the applet is restarted (e.g., when user returns to
start()
the page).
paint(Graphi
Called whenever the applet needs to redraw itself. Used for displaying graphics/text.
cs g)
Called when the applet is no longer visible or user leaves the page; used to pause
stop()
activities.
destroy() Called when the applet is being removed from memory; used for cleanup.

✅ 3. Applet Life Cycle Flow:

scss
CopyEdit
init() → start() → paint() → stop() → destroy()

• init() and start() run when applet loads.

• paint() is called repeatedly for display.
• stop() and destroy() run when applet stops or is closed.

✅ 4. Example Applet Program

java
CopyEdit
import java.applet.Applet;
import java.awt.Graphics;

public class LifeCycleApplet extends Applet {

public void init() {
System.out.println("Applet initialized");
}

public void start() {

System.out.println("Applet started");
}

public void paint(Graphics g) {

g.drawString("Hello, Applet!", 20, 20);
}

public void stop() {

System.out.println("Applet stopped");
}
 public void destroy() {
System.out.println("Applet destroyed");
}
}

✅ Summary:

• The applet life cycle ensures proper initialization, running, pausing, and cleanup.
• Each method plays a specific role in managing the applet’s state.
• Understanding this helps in writing efficient applets.

3.write a diffrences in swing and AWT component? 4marks

AWT (Abstract Window

Feature Swing
Toolkit)
Heavyweight components
Lightweight components (written
1. Architecture (depend on native OS
entirely in Java)
resources)
Depends on the platform’s Provides a pluggable look and
2. Look and Feel
native look feel, independent of platform

Rich set of components (tables,

3. Components Limited set of components
trees, sliders, etc.)

Less flexible, harder to Highly customizable and

4. Flexibility
customize extendable components
Usually faster due to native Slightly slower as rendering is
5. Performance
peer components handled in Java
Also uses event delegation but
Uses event delegation
6. Event Handling provides more sophisticated event
model
support
 Less portable because it More portable, works uniformly
7. Portability
depends on native OS across platforms

8. Package Part of java.awt package Part of javax.swing package

4. what is JDBC explain JDBC drivers avlable in java?8marks

What is JDBC?

• JDBC (Java Database Connectivity) is an API in Java that allows Java programs to
connect and interact with databases.
• It provides methods to connect to a database, execute SQL queries, and retrieve
results.
• JDBC makes Java applications database-independent, allowing them to work with
different databases using standard interfaces.

Types of JDBC Drivers:

1. Type 1 – JDBC-ODBC Bridge Driver

a. Uses ODBC driver to connect to database.
b. Converts JDBC calls into ODBC calls.
c. Platform-dependent and slower.
d. Mostly obsolete now.
2. Type 2 – Native-API Driver
a. Uses native database API (like C or C++ libraries).
b. Faster than Type 1 but platform-dependent.
3. Type 3 – Network Protocol Driver
a. Translates JDBC calls into database-independent network protocol.
b. Server-side middleware translates this protocol to database commands.
c. Platform-independent and flexible.
4. Type 4 – Thin Driver (Pure Java Driver)
a. Converts JDBC calls directly into database-specific protocol.
b. Written completely in Java.
 c. Platform-independent and fastest.
d. Most widely used.

6. explain server socket with the help of example? 8marks

✅ What is ServerSocket?

• ServerSocket is a Java class used to create a server that listens for client
connection requests over the network.
• It waits for clients to connect and establishes a communication link.
• Commonly used in network programming for TCP connections.

✅ How it works:

1. Server creates a ServerSocket object, specifying a port number.

2. It listens for incoming client requests using the accept() method.
3. When a client connects, accept() returns a Socket object for communication.
4. The server can then read from and write to the client through the socket.

✅ Example: Simple ServerSocket Program

java
CopyEdit
import java.net.*;
import java.io.*;

public class SimpleServer {

public static void main(String[] args) {
try {
// Create server socket listening on port 5000
ServerSocket server = new ServerSocket(5000);
System.out.println("Server started, waiting for
client...");

// Accept client connection

Socket socket = server.accept();
System.out.println("Client connected.");

// Create input stream to receive data from client

BufferedReader input = new BufferedReader(new
InputStreamReader(socket.getInputStream()));

// Read message from client

String message = input.readLine();
System.out.println("Received from client: " + message);

// Close connections
input.close();
socket.close();
server.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}

✅ Summary:

• ServerSocket waits for client requests on a specific port.

• accept() method blocks until a client connects.
• After connection, server and client communicate via sockets.

7. explain AWT in java? 4marks

🔹 Key Points (Point-wise for 4 Marks):

1. Platform Dependent:
AWT components are heavyweight; they rely on the native OS GUI components.
 2. Components:
Provides basic GUI elements like Button, Label, TextField, Frame, Checkbox,
etc.
3. Layout Managers:
Helps arrange components automatically using managers like FlowLayout,
BorderLayout, GridLayout.
4. Package:
AWT is part of the java.awt package in Java.

🔹 Example Code:

java
CopyEdit
Frame f = new Frame("AWT Frame");
Label l = new Label("Hello AWT");
f.add(l);
f.setSize(300, 200);
f.setVisible(true);

UNIT 5

1.explain the collection framwork with suitable example? 8marks

🔹 1. Definition:

Java Collection Framework is a unified architecture for storing, managing, and

manipulating groups of objects.
It provides interfaces and classes for various data structures like lists, sets, queues, and
maps.
🔹 2. Key Interfaces:

Interface Description
Ordered collection (allows duplicates). Example: ArrayList,
List
LinkedList
Set Unordered collection (no duplicates). Example: HashSet, TreeSet
Queue For holding elements before processing. Example: PriorityQueue
Map Stores key-value pairs. Example: HashMap, TreeMap

🔹 3. Benefits of Collection Framework:

• Reduces programming effort.

• Increases performance and flexibility.
• Provides ready-to-use algorithms like sorting, searching, etc.
• Supports generics, iteration, and thread-safety (via Concurrent Collections).

🔹 4. Example: Using List

java
CopyEdit
import java.util.*;

public class CollectionExample {

public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("Java");
list.add("Python");
list.add("C++");

// Iterating over elements

for (String language : list) {
System.out.println(language);
}
}
}

Output:

mathematica
CopyEdit
Java
Python
C++

✅ Summary:

• The Collection Framework simplifies working with groups of objects.

• It includes useful data structures and algorithms.
• It is a powerful tool for efficient and reusable Java programming.

2.how do you retrive all the keys present in hashmap? 8marks

✅ 1. Introduction

• A HashMap stores data as key-value pairs.

• Sometimes, you need to get all the keys stored in the HashMap.
• Java provides a method called .keySet() to retrieve all keys as a Set.

✅ 2. Method to Retrieve Keys

• keySet() returns a Set view of all keys contained in the map.

• This Set can be iterated using loops like for-each or an Iterator.
✅ 3. Example Program

java
CopyEdit
import java.util.*;

public class HashMapKeysExample {

public static void main(String[] args) {
// Creating a HashMap
HashMap<Integer, String> map = new HashMap<>();

// Adding key-value pairs

map.put(1, "Apple");
map.put(2, "Banana");
map.put(3, "Cherry");

// Retrieving all keys using keySet()

Set<Integer> keys = map.keySet();

System.out.println("Keys in the HashMap:");

for (Integer key : keys) {
System.out.println(key);
}
}
}

✅ 4. Output:

yaml
CopyEdit
Keys in the HashMap:
1
2
3
✅ Summary:

• Use .keySet() to get all keys from a HashMap.

• It returns a Set of keys.
• You can loop through the set to access each key.
• This is a simple and efficient way to retrieve all keys in Java.

3.explain event delegation model (edm ) ? 8marks

✅ 1. Definition:

• The Event Delegation Model is a design pattern used in Java's AWT and Swing to
handle events efficiently.
• Instead of each component handling its own events, events are delegated to a
single event listener.
• The listener is registered with a source component and listens for specific events
(like mouse clicks, key presses).

✅ 2. How EDM Works:

• Event Source: The GUI component (e.g., Button) that generates an event.
• Event Object: Contains information about the event (like which button was
clicked).
• Event Listener: An object that implements a specific listener interface (e.g.,
ActionListener).
• When an event occurs, the source notifies the registered listener by calling its
callback method (e.g., actionPerformed()).

✅ 3. Advantages of EDM:

• Separation of event handling code from GUI components.

 • Reduces the number of event objects created (improves performance).
• Easy to manage and maintain event handling logic.
• Supports multiple listeners for a single event source.

✅ 4. Example:

java
CopyEdit
import java.awt.*;
import java.awt.event.*;

public class EDMExample extends Frame implements ActionListener {

Button b;

public EDMExample() {
b = new Button("Click Me");
b.setBounds(50, 100, 80, 30);

// Register event listener (this class) with button

b.addActionListener(this);

add(b);
setSize(200, 200);
setLayout(null);
setVisible(true);
}

// Event handler method

public void actionPerformed(ActionEvent e) {
System.out.println("Button clicked!");
}

public static void main(String[] args) {

new EDMExample();
}
}
✅ Summary:

• The Event Delegation Model delegates event handling from GUI components to
listener objects.
• It improves performance and code organization.
• Widely used in Java GUI programming with AWT and Swing.

4.explain with code the concept of genric classes & method ? 8marks

✅ 1. What are Generics?

• Generics enable classes and methods to operate on objects of various types while
providing compile-time type safety.
• Avoids casting and ClassCastException at runtime.
• Uses type parameters (like <T>) to specify the data type.

✅ 2. Generic Class

• A class that can work with any data type.

• The type is specified when creating an object of the class.

✅ 3. Generic Method

• A method that can work with different data types.

• Type parameter is declared before the return type.

Usage Example:
java
CopyEdit
Box<Integer> intBox = new Box<>();
intBox.setItem(10);
System.out.println(intBox.getItem()); // Output: 10

display("Hello Generics"); // Output: Hello Generics

display(123); // Output: 123

5. write the use of hashtable and hashset class? 4 marks

Use of Hashtable and HashSet Classes in Java

(4 Marks)

1. Hashtable:

• Stores data as key-value pairs (like a dictionary).

• Provides fast lookup, insertion, and deletion using a hash function.
• Synchronised (thread-safe), so suitable for multi-threaded environments.
• Does not allow null keys or values.
• Example use: Storing and retrieving configuration settings by key.

2. HashSet:

• Implements a collection of unique elements (no duplicates).

• Does not maintain any order of elements.
• Provides fast operations like add, remove, and contains.
• Used when you want to store unique items without duplicates.
• Example use: Storing unique user IDs or eliminating duplicates from a list.
7. explain

1) hashtable

2)treeset

3)arraylist

4)linkedlist

1. Hashtable

• Stores key-value pairs like a dictionary.

• Uses hashing for fast access (constant-time complexity).
• Synchronized (thread-safe), but slower than HashMap.
• Does not allow null keys or null values.
• Useful in multi-threaded applications.

2. TreeSet

• Implements the Set interface to store unique elements.

• Maintains elements in sorted (natural) order.
• Uses a Red-Black tree (self-balancing binary search tree).
• Provides efficient operations like add, remove, and search in O(log n) time.
• Does not allow duplicates or null elements.

3. ArrayList

• Implements the List interface using a dynamic array.

• Allows fast random access (O(1) time) by index.
• Adding/removing elements at the end is fast; at middle is slow (O(n)).
• Allows duplicate elements and null.
 • Good when frequent access by index is needed.

4. LinkedList

• Implements List and Deque interfaces using a doubly linked list.

• Slow random access (O(n)) but fast insertion and deletion anywhere (O(1)).
• Allows duplicates and null elements.
• Suitable when many insertions/deletions occur.