Java 2023 Previous Year Solved | GGSIPU

Q.1 A ) Discuss three usage of final keywords.

• A final variable is a constant whose value cannot be changed once it is assigned.
• If a final variable is not initialized at the time of declaration, it must be initialized in the constructor.
• final variables are often declared using static so that they can be accessed without creating an instance of the class.

1final double PRICE;
2
3final int COUNT_NUMBER = 5;

• A method which uses final keyword cannot be overridden by subclasses.
• This is useful when you want to make sure that the specific behavior of a method remains unchanged in derived class
• Enhances security by preventing alteration of critical methods.

1class Demo
2
3{
4
5final void display()
6
7{
8
9System.out.println("Inside final method.");
10
11}
12
13} 

• A class which uses final keyword cannot be extended by any other class. This is useful when you want to prevent inheritance,
• ensuring that the class's implementation remains unaltered and is not extended or modified.

1public final class FinalClassExample {
2    public void display() {
3        System.out.println("This is a final class.");
4    }
5}
6
7// The following class would produce a compilation error
8// class ExtendedClass extends FinalClassExample {
9// }
10
11public class TestFinalClass {
12    public static void main(String[] args) {
13        FinalClassExample obj = new FinalClassExample();
14        obj.display(); // Calls the method from the final class
15    }
16}

B) Mention various states of thread. Give suitable example.

• New
• Runnable
• Running
• Blocked (Non-runnable state)
• Dead

1/* Thread 1 */
2
3class Thread1 extends Thread
4
5{
6
7public void run()
8
9{
10
11System.out.println("Thread 1");
12
13System.out.println("i in Thread 1 ");
14
15for (int i = 1; i <= 5; i++)
16
17{
18
19System.out.println("i = " + i);
20
21try
22
23{
24
25Thread.sleep(1000);
26
27}
28
29catch (InterruptedException e)
30
31{
32
33e.printStackTrace();
34
35}
36
37}
38
39System.out.println("Thread 1 Completed.");
40
41}
42
43}
44
45/* Thread 2 */
46
47class Thread2 extends Thread
48
49{
50
51public void run()
52
53{
54
55System.out.println("Thread 2");
56
57System.out.println("i in Thread 2 ");
58
59for (int i = 1; i <= 5; i++)
60
61{
62
63System.out.println("i = " + i);
64
65}
66
67System.out.println("Thread 2 Completed.");
68
69}
70
71}
72
73/* Driver code */
74
75public class ThreadDemo
76
77{
78
79public static void main(String[] args) {
80
81// life cycle of Thread
82
83// Thread's New State
84
85Thread1 t1 = new Thread1();
86
87Thread2 t2 = new Thread2();
88
89// Both the above threads are in runnable state
90
91// Running state of Thread1 and Thread2
92
93t1.start();
94
95// Move control to another thread
96
97t2.yield();
98
99// Blocked State Thread1
100
101try
102
103{
104
105t1.sleep(1000);
106
107}
108
109catch (InterruptedException e)
110
111{
112
113e.printStackTrace();
114
115}
116
117t2.start();
118
119System.out.println("Main Thread End");
120
121}
122
123}

C) How the constructor is overloaded in Java?

• In Java, constructor overloading is a technique where a class can have more than one constructor, each with different parameters.
• This allows the creation of objects in different ways.

• If no constructors are defined, Java provides a default constructor with no parameters.
• When you define your own constructors, the default constructor is not provided automatically.

1public class Student {
2
3//instance variables of the class
4
5int id;
6
7String name;
8
9Student(){
10
11System.out.println("this a default constructor");
12
13}
14
15Student(int i, String n){
16
17id = i;
18
19name = n;
20
21}
22
23public static void main(String[] args) {
24
25//object creation
26
27Student s = new Student();
28
29System.out.println("\nDefault Constructor values: \n");
30
31System.out.println("Student Id : "+s.id + "\nStudent Name : "+s.name);
32
33
34
35System.out.println("\nParameterized Constructor values: \n");
36
37Student student = new Student(10, "David");
38
39System.out.println("Student Id : "+student.id + "\nStudent Name : "+student.name);
40
41}
42
43}
44
45Output
46
47this a default constructor
48
49Default Constructor values:
50
51Student Id : 0
52
53Student Name : null
54
55
56
57Parameterized Constructor values:
58
59Student Id : 10
60
61Student Name : David

D) How multithreading is achieved in Java. Explain its advantages and disadvantages.

• In Java, multithreading is achieved by using the Thread class or implementing the Runnable interface.
• This allows a program to perform multiple tasks concurrently, improving efficiency and performance.

• Improved Performance: Multithreading allows the concurrent execution of two or more parts of a program,
• leading to better CPU utilization and improved performance, especially on multi-core processors.

• Multithreading makes programs more responsive.
• For example, a graphical user interface can remain responsive to user actions while performing background tasks.

E ) Why Java is called type safe language as compared to C++.

• Java is often referred to as a "type-safe" language compared to C++ due to
• several language design features and runtime environment characteristics as follows:

• Strongly Typed: Java is strongly typed, meaning that every variable and expression has a type that is known at compile time.
• This prevents operations that are not defined for a particular type.
• Automatic Memory Management: Java uses automatic garbage collection,
• which helps prevent memory-related errors such as accessing memory that has been deallocated or using uninitialized memory.
• No Pointer Arithmetic: Java does not allow direct pointer arithmetic like C++.
• No Implicit Type Conversions: Java requires explicit casting for type conversions that may result in loss of precision or data truncation.
• Exception Handling: Java encourages the use of exception handling mechanisms for dealing with runtime errors.

F) What are the roles of Java compiler and interpreter?

Java Compiler

• Translation: Translates Java source code into bytecode.
• Syntax Checking: Checks the source code for syntax errors.
• Optimization: Performs optimizations to improve bytecode performance.
• Type Checking: Ensures consistent usage of variable types.
• Class File Generation: Produces .class files containing the bytecode.

Java Interpreter (Part of the JVM)

• Bytecode Execution: Executes the bytecode line by line.
• Platform Independence: Allows Java programs to run on any device with a JVM.
• Just-In-Time (JIT) Compilation: Converts bytecode into native machine code at runtime.
• Memory Management: Manages memory allocation and garbage collection.
• Runtime Error Detection: Detects and handles runtime errors.

G) Explain why the main function is declared as “Public static void main(String args [])”?

• Accessibility: Ensures the method is accessible by the Java Runtime Environment (JRE) from anywhere.
• Visibility: Allows the JRE to call it from outside the class.

• No Instance Required: Allows the method to be called without creating an instance of the class.
• Direct Access: The JRE can invoke it directly using the class name.

• No Return Value: The method does not return any value.
• Procedure Method: Its purpose is to execute the application logic, not to return a result.

• Standard Entry Point: The JRE looks for this method name as the starting point of the application.
• Convention: Must be named main for the program to start correctly.

• Command-line Arguments: Allows the program to accept arguments from the command line.
• Flexibility: Enables passing multiple arguments to the application.

1public class MainExample {
2    public static void main(String[] args) {
3        for (String arg : args) {
4            System.out.println("Argument: " + arg);
5        }
6    }
7}
8

H) How does java byte code differ from other machine level codes?

• Java Bytecode: Designed to be platform-independent and can run on any device with a Java Virtual Machine (JVM).
• Other Machine-Level Codes: Platform-specific and can only run on the specific architecture (e.g., x86, ARM).

• Java Bytecode: Acts as an intermediate representation that the JVM interprets or compiles at runtime.
• Other Machine-Level Codes: Directly executed by the CPU.

• Java Bytecode: Enhances portability, enabling "write once, run anywhere" capabilities.
• Other Machine-Level Codes: Lack portability; need recompilation for different platforms.

• Java Bytecode: Verified by the JVM’s bytecode verifier for security and correctness before execution.
• Other Machine-Level Codes: No built-in security checks, making them more prone to errors and exploits.

• Java Bytecode: Higher level of abstraction, representing Java's object-oriented features.
• Other Machine-Level Codes: Lower-level, closer to the hardware, representing basic instructions for the CPU.

I) What is the use of this, final and super keyword in Java.

• Reference to Current Object: Refers to the current instance of the class.
• Disambiguation: Used to resolve conflicts between instance variables and parameters with the same name.
• Constructor Chaining: Invokes another constructor from the same class.
• Method Chaining: Calls other methods of the current object.

• Final Variables: Constants whose values cannot be changed once assigned.
• Final Methods: Methods that cannot be overridden by subclasses.
• Final Classes: Classes that cannot be subclassed.

• Access Superclass Members: Calls superclass methods and variables.
• Constructor Invocation: Calls the constructor of the superclass.
• Method Overriding: Refers to the overridden method of the superclass.
• Inheritance: Facilitates the use of inherited properties and methods.

J) Discuss process of synchronization of a thread with suitable example.

• Prevent Data Inconsistency: Ensures that only one thread can access a resource at a time to avoid data corruption.
• Thread Safety: Helps in making concurrent execution of threads safe and reliable.

• Lock on Object: The thread holds the lock on the object for synchronized instance methods.
• Lock on Class: The thread holds the lock on the class for synchronized static methods.

• Fine-Grained Control: Synchronizes only specific sections of code instead of the entire method.
• Explicit Locking: Uses objects as locks to provide explicit control over synchronization.

1class Table{  
2 synchronized void printTable(int n){//synchronized method  
3   for(int i=1;i<=5;i++){  
4     System.out.println(n*i);  
5     try{  
6      Thread.sleep(400);  
7     }catch(Exception e){System.out.println(e);}  
8   }  
9  
10 }  
11}  
12  
13class MyThread1 extends Thread{  
14Table t;  
15MyThread1(Table t){  
16this.t=t;  
17}  
18public void run(){  
19t.printTable(5);  
20}  
21  
22}  
23class MyThread2 extends Thread{  
24Table t;  
25MyThread2(Table t){  
26this.t=t;  
27}  
28public void run(){  
29t.printTable(100);  
30}  
31}  
32  
33public class TestSynchronization2{  
34public static void main(String args[]){  
35Table obj = new Table();//only one object  
36MyThread1 t1=new MyThread1(obj);  
37MyThread2 t2=new MyThread2(obj);  
38t1.start();  
39t2.start();  
40}  
41}  
42OUTPUT:
43       5
44       10
45       15
46       20
47       25
48       100
49       200
50       300
51       400
52       500
53

UNIT 1

Q,2 (A )What is constructor? Does Java provide default constructor? Explain your answer with suitable example.

• In Java, a constructor is a unique method that is automatically called when an object is created.
• It has the same name as the class and does not have a return type, not even void.
• Constructors are called automatically when an object of a class is created.
• Java does provide a default constructor if you don't explicitly define one in your class.
• The default constructor is a no-argument constructor provided by Java automatically if no constructors are defined in the class.

1// Class with a constructor
2class Car {
3    String color;
4    int year;
5
6    // Constructor with parameters
7    public Car(String c, int y) {
8        color = c;
9        year = y;
10    }
11
12    // Default constructor
13    public Car() {
14        color = "Red";
15        year = 2022;
16    }
17
18    void display() {
19        System.out.println("Color: " + color);
20        System.out.println("Year: " + year);
21    }
22}
23
24public class Main {
25    public static void main(String[] args) {
26        // Creating objects using constructors
27        Car car1 = new Car("Blue", 2020); // Using parameterized constructor
28        Car car2 = new Car(); // Using default constructor
29
30        // Displaying object details
31        System.out.println("Car 1 details:");
32        car1.display();
33
34        System.out.println("\nCar 2 details:");
35        car2.display();
36    }
37}

Q,2 (B) Explain in details the features of Java.

• Simple and Easy to Learn: Java was designed to be beginner-friendly with a syntax similar to C++ but without the complex features like pointers and operator overloading.
• Platform-Independent: Java programs can run on any device or operating system with the help of the Java Virtual Machine (JVM).
• This is achieved through the principle of "write once, run anywhere" (WORA).
• Java uses an object-oriented programming (OOP) approach, considering everything as an object.
• It supports features like classes, objects, inheritance, encapsulation, and polymorphism.
• Java facilitates multithreading, enabling simultaneous execution of numerous threads within a program.
• This is useful for writing efficient, responsive, and scalable applications.

Q.3 (A) Explain the concept of abstract classes in Java with suitable example. How abstract classes differ from interface.

• An abstract class in Java is a class that cannot be instantiated on its own and is meant to be subclassed.
• It serves as a blueprint for other classes to inherit from.Keyword: The abstract keyword is used to declare an abstract class.
• Abstract classes in Java can contain both abstract methods (without a body) and concrete methods (with a body).
• Purpose: Abstract classes are used to define common behavior and attributes among related classes.
• They provide a way to enforce a structure for derived classes while allowing flexibility in implementation.
• Cannot be Instantiated: Since abstract classes cannot be instantiated, you cannot create objects of abstract classes directly.

1abstract class Shape {
2    public abstract void draw(); // Abstract method
3    
4    public void display() {
5        System.out.println("Displaying shape");
6    }
7}
8
9class Circle extends Shape {
10    public void draw() {
11        System.out.println("Drawing circle");
12    }
13}
14
15class Rectangle extends Shape {
16    public void draw() {
17        System.out.println("Drawing rectangle");
18    }
19}
20
21public class Main {
22    public static void main(String[] args) {
23        Shape shape1 = new Circle();
24        Shape shape2 = new Rectangle();
25
26        shape1.draw(); // Output: Drawing circle
27        shape2.draw(); // Output: Drawing rectangle
28    }
29}

• Abstract classes can indeed have both abstract and concrete methods, whereas interfaces,
• before Java 8, could only contain abstract methods. Additionally, abstract classes can include instance variables.
• constructors, and static methods, which interfaces cannot have.
• Extending Abstract Classes: Subclasses of abstract classes must either provide implementations for all abstract methods or
• be declared abstract themselves. This enforces the contract specified by the abstract class.

Q.3 (B) What are interfaces? What are their benefits?

1// Interface definition
2interface Printable {
3    void print(); // Abstract method
4
5    default void getInfo() {
6        System.out.println("Printing information");
7    }
8
9    static void welcome() {
10        System.out.println("Welcome to the interface");
11    }
12
13    int MAX_PAGES = 100; // Constant declaration
14}
15
16// Class implementing the interface
17class Printer implements Printable {
18    public void print() {
19        System.out.println("Printing document");
20    }
21}
22
23// Main class to demonstrate interface usage
24public class Main {
25    public static void main(String[] args) {
26        Printable printer = new Printer();
27        printer.print(); // Output: Printing document
28        printer.getInfo(); // Output: Printing information
29        Printable.welcome(); // Output: Welcome to the interface
30        System.out.println(Printable.MAX_PAGES); // Output: 100
31    }
32}

• Promote code reusability by defining a common set of methods that multiple classes can implement.
• Enable polymorphic behavior, allowing objects of different classes to be treated uniformly based on their interface type.
• Support multiple inheritance, allowing classes to implement multiple interfaces and inherit behavior from multiple sources.

UNIT 2

Q.4 (A) Explain different access modifiers available in Java.

• Accessibility: Public members are accessible from any other class in the same package or from a different package.
• Usage: Typically used for methods and variables that are intended to be widely accessible throughout the application.
• Example:

1class MyClass {
2    public int publicVar; // Public access modifier
3    
4    public void publicMethod() {
5        System.out.println("This is a public method with some logic");
6        publicVar = 400; // Modifying publicVar within the publicMethod
7        System.out.println("Updated publicVar: " + publicVar);
8    }
9}
10
11public class Main {
12    public static void main(String[] args) {
13        MyClass myClass = new MyClass();
14        myClass.publicMethod(); // Output: This is a public method with some logic
15                                //         Updated publicVar: 400
16    }
17}

• Private members, such as variables and methods, can only be accessed and manipulated from within the class in which they are defined.
• They are not visible to classes in other packages or even subclasses.
• Usage: Used to encapsulate internal functionality and prevent direct access or modification from outside the class.
• Example

1class MyClass {
2    private int privateVar; // Private access modifier
3    
4    private void privateMethod() {
5        System.out.println("This is a private method with some logic");
6        privateVar = 200; // Modifying privateVar within the privateMethod
7        System.out.println("Updated privateVar: " + privateVar);
8    }
9}
10
11public class Main {
12    public static void main(String[] args) {
13        MyClass myClass = new MyClass();
14        // Cannot access privateVar or privateMethod directly
15        // myClass.privateVar = 300; // Compilation error
16        // myClass.privateMethod(); // Compilation error
17    }
18}

• Accessibility: Protected members are accessible within the same package and also by subclasses (even if they are in a different package).
• Usage: Used for methods and variables that need to be accessible within subclasses but not to the general public.
• Example

1class MyClass {
2    protected int protectedVar; // Protected access modifier
3    
4    protected void protectedMethod() {
5        System.out.println("This is a protected method with some logic");
6        protectedVar = 300; // Modifying protectedVar within the protectedMethod
7        System.out.println("Updated protectedVar: " + protectedVar);
8    }
9}
10
11class Subclass extends MyClass {
12    public void accessProtectedMembers() {
13        protectedMethod(); // Accessing protectedMethod from subclass
14    }
15}
16
17public class Main {
18    public static void main(String[] args) {
19        Subclass subclass = new Subclass();
20        subclass.accessProtectedMembers(); // Output: This is a protected method with some logic
21                                           //         Updated protectedVar: 300
22    }
23}

• Accessibility: If no access modifier is specified (default), the member is accessible only within the same package. It is not accessible outside the package, even to subclasses.
• Usage: Used when you want to limit the visibility of members to classes within the same package.
• Example:

1class MyClass {
2    int defaultVar; // Default access modifier (package-private)
3    
4    void defaultMethod() {
5        System.out.println("This is a default method with some logic");
6        defaultVar = 100; // Modifying defaultVar within the defaultMethod
7        System.out.println("Updated defaultVar: " + defaultVar);
8    }
9}
10
11public class Main {
12    public static void main(String[] args) {
13        MyClass myClass = new MyClass();
14        myClass.defaultMethod(); // Output: This is a default method with some logic
15                                 //         Updated defaultVar: 100
16    }
17}

Q.4 (B) Differentiate between checked and unchecked exception. Write a program to show user defined exception.

• Checked exceptions are exceptions that must be handled at compile time.
• They are checked by the compiler, and the code that may throw checked
• exceptions must be surrounded by a try-catch block or declare the exception using throws keyword.
• Examples: Some examples of checked exceptions include IOException, SQLException, and ClassNotFoundException.
• Purpose: Checked exceptions are typically used for situations where the code may encounter errors that are outside of its control.
• They force the developer to explicitly handle potential errors, promoting robust error-handling mechanisms.

• Unchecked exceptions (Runtime exceptions) are exceptions that do not
• need to be declared in a method's throws clause and are not checked by the compiler at compile time.
• Examples: Some examples of unchecked exceptions include
• NullPointerException, ArrayIndexOutOfBoundsException, and IllegalArgumentException.
• Handling: Unchecked exceptions do not require explicit handling using try-catch blocks or throws declarations.
• Purpose: Unchecked exceptions typically indicate programming errors or exceptional conditions that can be avoided with proper coding practices.
• Runtime Occurrence: Unchecked exceptions often occur at runtime due to logic errors, null references, or invalid arguments passed to methods.

1class InvalidAgeException  extends Exception  
2{  
3    public InvalidAgeException (String str)  
4    {  
5        // calling the constructor of parent Exception  
6        super(str);  
7    }  
8}  
9    
10// class that uses custom exception InvalidAgeException  
11public class TestCustomException1  
12{  
13  
14    // method to check the age  
15    static void validate (int age) throws InvalidAgeException{    
16       if(age < 18){  
17  
18        // throw an object of user defined exception  
19        throw new InvalidAgeException("age is not valid to vote");    
20    }  
21       else {   
22        System.out.println("welcome to vote");   
23        }   
24     }    
25  
26    // main method  
27    public static void main(String args[])  
28    {  
29        try  
30        {  
31            // calling the method   
32            validate(13);  
33        }  
34        catch (InvalidAgeException ex)  
35        {  
36            System.out.println("Caught the exception");  
37    
38            // printing the message from InvalidAgeException object  
39            System.out.println("Exception occured: " + ex);  
40        }  
41  
42        System.out.println("rest of the code...");    
43    }  
44}  
45

UNIT 3

Q 5 (A) Explain life cycle of threads. Also explain different ways of creating threads in Java.

• When a thread is created using the new keyword or by instantiating a class that implements the Runnable interface, it is in the new state.
• The thread exists, but it has not yet started its execution.

• After creating a thread, it enters the runnable state when the start() method is called.
• The thread is ready to run, but the scheduler has not yet selected it to be executed.

• When the scheduler selects a runnable thread, it enters the running state and starts executing its run() method.
• The thread remains in this state until it completes its task, yields its execution, or is paused by another thread.

• A thread may enter the blocked or waiting state under certain conditions, such as waiting for I/O operations, synchronization, or a specified time delay.
• In the blocked state, the thread is not eligible for execution until the condition causing the blockage is resolved.

• Threads can enter the timed waiting state when they call methods like Thread.sleep(milliseconds) or Object.wait(milliseconds).
• The thread remains in this state for the specified time duration before transitioning back to the runnable state.

• A thread enters the terminated state when it completes its execution, exits its run() method, or encounters an unhandled exception.
• Once in the terminated state, the thread cannot be started again.

• Creation: Thread is created using the new keyword or by instantiating a class that implements Runnable.
• Start: Thread starts executing by calling the start() method.
• Run: Thread executes its logic inside the run() method.
• Blocked/Waiting/Timed Waiting: Thread may enter these states based on certain conditions or method calls.
• Termination: Thread completes execution or encounters an exception, transitioning to the terminated state.

1public class MyThread extends Thread {
2    public void run() {
3        System.out.println("Thread is running");
4        try {
5            Thread.sleep(2000); // Thread enters timed waiting state for 2 seconds
6        } catch (InterruptedException e) {
7            System.out.println("Thread interrupted");
8        }
9        System.out.println("Thread completes its task");
10    }
11
12    public static void main(String[] args) {
13        MyThread thread = new MyThread();
14        System.out.println("Thread is in new state");
15        thread.start(); // Thread transitions to runnable and then running state
16        System.out.println("Thread is in running state");
17        try {
18            thread.join(); // Wait for the thread to complete
19        } catch (InterruptedException e) {
20            System.out.println("Main thread interrupted");
21        }
22        System.out.println("Thread is terminated");
23    }
24}

Q 5 (B) Write a program to print the table of any no. inside the applet

1import java.applet.Applet;
2import java.awt.Graphics;
3
4public class TableApplet extends Applet {
5    int number = 5; // Default number to generate table for
6
7    public void paint(Graphics g) {
8        int x = 50; // x-coordinate for the table
9        int y = 50; // y-coordinate for the table
10        int tableLength = 10; // Length of the table (number of rows)
11
12        // Print the table header
13        g.drawString("Table of " + number, x, y);
14        y += 20;
15        g.drawString("---------------", x, y);
16        y += 20;
17
18        // Print the table content
19        for (int i = 1; i <= tableLength; i++) {
20            int result = number * i;
21            g.drawString(number + " * " + i + " = " + result, x, y);
22            y += 20;
23        }
24    }
25}
26
27
28<html>
29<head>
30    <title>Table Applet</title>
31</head>
32<body>
33    <applet code="TableApplet.class" width="300" height="300">
34        <param name="number" value="7"> <!-- Change the value to generate table for different numbers -->
35    </applet>
36</body>
37</html>
38
39

UNIT 4

Q.6 (A) Discuss various Layout Managers available in AWT

• Places components in a row, wrapping to the next row if necessary, maintaining their natural order.
• Suitable for creating simple, linear layouts with components placed one after another.

• Divides the container into five regions: North, South, East, West, and Center.
• Components added to a BorderLayout are positioned in one of these regions, providing a structured layout.

• The GridLayout manager organizes UI elements into a uniform matrix structure,
• creating a consistent layout where each component occupies a cell of identical dimensions.
• Suitable for creating grid-based layouts with a fixed number of rows and columns.

• Allows switching between multiple components (cards) stacked on top of each other.
• Useful for creating wizard-style interfaces or tabbed panels where only one card is visible at a time.

• Provides a flexible and powerful layout manager with support for specifying constraints on individual components.
• Allows components to span multiple rows and columns, have variable sizes, and be aligned in different ways.

• Arranges components in a single row or column, similar to FlowLayout but with more control over alignment and sizing.
• Suitable for creating horizontal or vertical layouts with components aligned in a specific manner.

1import java.awt.*;
2import javax.swing.*;
3
4public class FlowLayoutExample {
5    public static void main(String[] args) {
6        JFrame frame = new JFrame("FlowLayout Example");
7        frame.setLayout(new FlowLayout());
8
9        for (int i = 1; i <= 5; i++) {
10            frame.add(new JButton("Button " + i));
11        }
12
13        frame.setSize(300, 200);
14        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
15        frame.setVisible(true);
16    }
17}

Q.6 (B) Diff Btw Swing and AWT

1class OverloadingExample{
2
3static int add(int a,int b){return a+b;}
4
5static int add(int a,int b,int c){return a+b+c;}
6
7}

1class Animal{
2
3void eat(){System.out.println("eating...");}
4
5}
6
7class Dog extends Animal{
8
9void eat(){System.out.println("eating bread...");}
10
11}

Q.7 (B) Write short Notes on the following

Adapter class

• An adapter class in Java is a class that provides default implementations (empty or default methods) for all methods in an interface.
• It allows a class to implement only the methods it needs from an interface,
• rather than implementing all methods, providing flexibility and reducing code verbosity.

Applet and application program

• An applet is a Java program that is designed to run within a web browser using a Java applet viewer or a web plugin like Java Web Start.
• Applets are used for creating interactive and dynamic content on web pages, such as animations, games, and multimedia applications.
• To run the application, compile the Java file and execute the compiled class using the java command from the command line or an IDE.

1public class MyApplication {
2    public static void main(String[] args) {
3        System.out.println("Hello, World!");
4    }
5}

Check Box and choice list

• A CheckBox in Java is a graphical user interface component that allows users to select one or more options from a list of choices.
• It presents a checkable box that can be checked (selected) or unchecked (deselected) by the user.
• A Choice List, also known as a ComboBox in Java, is a graphical user interface component that presents a list of options in a drop-down menu. Users can select one option from the list at a time.

Q.8 (A) What is JDBC? Explain all JDBC drivers in detail.

• JDBC is an API (Application Programming Interface) that allows Java applications to interact with databases.
• It provides a standard interface for connecting to relational databases, executing SQL queries, and processing database results.
• JDBC enables Java applications to access various database management systems (DBMS) such as
• MySQL, Oracle, SQL ,PostgreSQL, etc., by providing a common set of methods and classes.

• DriverManager: Responsible for managing a list of database drivers, establishing connections to databases,
• and providing a mechanism to obtain connection objects.
• Connection: Represents a connection to a database, allowing the execution of SQL statements and transactions.
• Statement: Used to execute SQL queries and updates against the database. It can be a Statement, PreparedStatement, or CallableStatement.
• ResultSet: Represents the result of a SQL query, providing methods to retrieve data from the database.

• Relies on ODBC drivers to establish a connection with the database, acting as a bridge between JDBC and ODBC.
• Offers limited performance due to the additional layer of communication between JDBC and ODBC.
• Requires the installation of ODBC drivers on the client machine, reducing portability and cross-platform compatibility.

• Uses native libraries specific to the database to communicate directly with the database management system.
• Provides improved performance compared to Type 1 drivers by eliminating the JDBC-ODBC bridge.
• Requires the installation of native libraries on the client machine, which can limit portability and increase deployment complexity.

• Communicates with a middleware server using a database-independent protocol, which in turn translates the requests to database-specific calls.
• Offers increased scalability and flexibility by allowing multiple databases to be accessed through a single driver.
• Provides a pure Java implementation, eliminating the need for native libraries and enhancing portability across different platforms.

• Communicates directly with the database using a vendor-specific protocol, without requiring any intermediate layers.
• Offers the best performance among all JDBC driver types due to its direct communication with the database.
• Provides a pure Java implementation, ensuring high portability and compatibility across different platforms and environments.

Q.8 (B) Write short notes on Java Servlet

• Server-side Java Technology: Servlets are Java programs that run on the server side, handling client requests and generating dynamic web content.
• Lifecycle Methods: Servlets have lifecycle methods such as init(), service(), and destroy().
• These methods are called by the servlet container during different stages of the servlet's life.
• HTTP Protocol Support: Servlets are primarily used to handle HTTP requests and responses.
• They can process GET and POST requests, manage sessions, handle cookies, and interact with other web technologies.
• Extensibility and Reusability: Servlets can be extended to create custom functionality and are reusable components that can be deployed in various web applications.
• They promote modular design and code reusability.
• Servlet Container: Servlets are executed within a servlet container (like Apache Tomcat, Jetty, etc.), which provides runtime environment support for servlets.

Q.9 (A) Explain the following term with respect to exception handling.

Try

• The try block in Java is used to enclose code that may throw exceptions.

• It allows you to handle potential exceptions gracefully and prevent the program from crashing.

1try {
2    // Code that may throw exceptions
3} catch (ExceptionType1 e1) {
4    // Exception handling for ExceptionType1
5} catch (ExceptionType2 e2) {
6    // Exception handling for ExceptionType2
7} finally {
8    // Optional finally block for cleanup or resource release
9}

• The try block is used to wrap code that might throw exceptions, providing a structured way to handle potential errors without disrupting the program's flow.
• Execution Flow: When an exception occurs inside the try block, the control jumps to the corresponding catch block based on the type of exception thrown.

Catch

• The catch block in Java is used to catch and handle exceptions thrown within a corresponding try block.
• multiple catch blocks can be defined to handle different types of exceptions that may be thrown within the corresponding try block.

1try {
2
3// Code that may throw exceptions
4
5} catch (ExceptionType1 e1) {
6
7// Exception handling for ExceptionType1
8
9} catch (ExceptionType2 e2) {
10
11// Exception handling for ExceptionType2
12
13} finally {
14
15// Optional finally block for cleanup or resource release
16
17}

• The catch block catches exceptions thrown within the corresponding try block and provides a mechanism to handle those exceptions gracefully.
• Exception Handling: Inside the catch block, you can write code to handle the exception, such as logging the error,
• displaying an error message to the user, or taking corrective actions.

Finally

1try {
2
3// Code that may throw exceptions
4
5} catch (ExceptionType1 e1) {
6
7// Exception handling for ExceptionType1
8
9} catch (ExceptionType2 e2) {
10
11// Exception handling for ExceptionType2
12
13} finally {
14
15// Optional finally block for cleanup or resource release
16
17}

• The finally block ensures that certain code is executed irrespective of whether an exception occurs or not.
• It is commonly used for releasing resources, closing connections, or performing cleanup tasks.

Throw

• The throw keyword in Java is used to explicitly throw an exception within a method.
• It is used to signal abnormal conditions or error situations.

1void methodName() {
2
3if (/* Condition */) {
4
5throw new ExceptionType("Error message");
6
7}
8
9}

• The throw statement is used to throw exceptions programmatically when certain conditions are met
• , allowing you to handle exceptional scenarios in a controlled manner.
• Exception Type: You can create and throw instances of any exception class that extends Throwable,
• such as RuntimeException, IOException, or custom exception classes.

Q.9 (B) Differentiate between JDBC and ODBC