Java Top 50 Importatant Questions-Answers - Revision notes

Question 1. What is an abstract class? How is it used to implement polymorphism in Java? Give suitable example in support of your answer. (5 marks)

Answer :

An abstract class in Java is a class that cannot be instantiated and may contain abstract methods (methods without a body). It's used to:
→ Define a common interface for a group of related subclasses
→ Provide a base implementation for some methods while leaving others to be implemented by subclasses
→ Implement polymorphism through method overriding

Abstract classes implement polymorphism by allowing:
→ Creation of a hierarchy of related classes
→ Use of abstract class type to refer to objects of its concrete subclasses
→ Method overriding in subclasses

Example:

abstract class Shape {
    abstract double area();
    void display() {
        System.out.println("This is a shape");
    }
}

class Circle extends Shape {
    double radius;
    Circle(double r) { radius = r; }
    
    @Override
    double area() {
        return Math.PI * radius * radius;
    }
}

class Rectangle extends Shape {
    double length, width;
    Rectangle(double l, double w) { length = l; width = w; }
    
    @Override
    double area() {
        return length * width;
    }
}

// Usage demonstrating polymorphism
Shape shape1 = new Circle(5);
Shape shape2 = new Rectangle(4, 6);
System.out.println(shape1.area());  // Calls Circle's area method
System.out.println(shape2.area());  // Calls Rectangle's area method
    

Question 2. What is an applet? Why is main() not included in writing a Java applet program? (5 marks)

Answer :

An applet is a special type of Java program designed to be embedded in and run from within an HTML page. Key characteristics include:
→ Runs in a web browser or applet viewer
→ Has restricted access to local system resources for security
→ Typically used for creating interactive features on web pages

The main() method is not included in Java applet programs because:
→ Applets are not standalone applications; they're controlled by a web browser or applet viewer
→ The applet's lifecycle is managed by the init(), start(), stop(), and destroy() methods
→ The browser or applet viewer calls these lifecycle methods as needed, not a main() method

Instead of main(), applets use methods like:
→ init(): For initialization when the applet is first loaded
→ start(): Called when the applet should start its execution
→ paint(): For drawing the applet's user interface

Question 3. Explain the process of inter-thread communication in Java, with the help of a suitable example. (5 marks)

Answer :

Inter-thread communication in Java allows synchronized threads to communicate with each other. The process involves:
→ wait(): Causes a thread to suspend execution and release the lock
→ notify(): Wakes up a single thread waiting on the object's monitor
→ notifyAll(): Wakes up all threads waiting on the object's monitor

Key points:
→ These methods must be called from within a synchronized context
→ They are defined in the Object class, so every object has these methods
→ Used to implement producer-consumer scenarios

Example of a simple producer-consumer scenario:

class SharedResource {
    private int data;
    private boolean available = false;

    public synchronized int get() {
        while (!available) {
            try { wait(); } catch (InterruptedException e) {}
        }
        available = false;
        notifyAll();
        return data;
    }

    public synchronized void put(int value) {
        while (available) {
            try { wait(); } catch (InterruptedException e) {}
        }
        data = value;
        available = true;
        notifyAll();
    }
}

class Producer implements Runnable {
    private SharedResource resource;
    
    public Producer(SharedResource resource) {
        this.resource = resource;
    }

    public void run() {
        for (int i = 0; i < 5; i++) {
            resource.put(i);
            System.out.println("Producer put: " + i);
            try { Thread.sleep(1000); } catch (InterruptedException e) {}
        }
    }
}

class Consumer implements Runnable {
    private SharedResource resource;
    
    public Consumer(SharedResource resource) {
        this.resource = resource;
    }

    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("Consumer got: " + resource.get());
            try { Thread.sleep(1000); } catch (InterruptedException e) {}
        }
    }
}
    

Question 4. Differentiate between throw and throws statement. Give example code for each. (5 marks)

Answer :

throw statement:
→ Used to explicitly throw an exception
→ Used within a method or block of code
→ Followed by an instance of an exception class
→ Immediately transfers control to the exception handler

Example of throw:

public void checkAge(int age) {
    if (age < 0) {
        throw new IllegalArgumentException("Age cannot be negative");
    }
    // Rest of the method
}
    

throws clause:
→ Used in method declaration to specify exceptions that might be thrown
→ Indicates that the method doesn't handle the exception itself
→ Can list multiple exceptions
→ Requires the calling method to handle or declare the exception

Example of throws:

public void readFile(String filename) throws FileNotFoundException, IOException {
    FileReader file = new FileReader(filename);
    BufferedReader reader = new BufferedReader(file);
    // Read file operations
    reader.close();
}

// Usage:
public static void main(String[] args) {
    try {
        readFile("example.txt");
    } catch (FileNotFoundException e) {
        System.out.println("File not found: " + e.getMessage());
    } catch (IOException e) {
        System.out.println("Error reading file: " + e.getMessage());
    }
}
    

Question 5. What is classpath? Explain the utility of classpath, with the help of a suitable example. (5 marks)

Answer :

Classpath is a parameter in the Java Virtual Machine (JVM) or the Java compiler that specifies the location of user-defined classes and packages. It's essentially a path that the Java Runtime Environment (JRE) and the Java compiler use to find and load Java classes and interfaces.

Utility of classpath:
→ Helps JVM locate and load classes during runtime
→ Allows using third-party libraries in Java applications
→ Enables organization of classes into different directories or JAR files
→ Provides flexibility in managing multiple versions of the same library

Example:

Suppose you have a project structure like this:

MyProject/
    |-- src/
    |   |-- com/
    |       |-- example/
    |           |-- MyClass.java
    |-- lib/
        |-- external-library.jar
    

To compile and run MyClass.java using the external library:

# Compile
javac -cp "lib/external-library.jar" src/com/example/MyClass.java

# Run
java -cp "src;lib/external-library.jar" com.example.MyClass
    

Here, the classpath includes both the src directory (for our class) and the external JAR file.

Question 6. Compare private and protected access specifiers. Give suitable example for each. (5 marks)

Answer :

private access specifier:
→ Most restrictive access level
→ Accessible only within the same class
→ Not visible to subclasses or other classes
→ Used for encapsulation to hide implementation details

protected access specifier:
→ Accessible within the same package and by subclasses in other packages
→ Provides a level of access between public and private
→ Allows subclasses to use or override the member
→ Used when you want to allow subclass access but restrict general access

Example for private:

public class BankAccount {
    private double balance;
    
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }
    
    public double getBalance() {
        return balance;
    }
}
    

Example for protected:

public class Shape {
    protected double area;
    
    protected void calculateArea() {
        // Default implementation
    }
}

public class Circle extends Shape {
    private double radius;
    
    public Circle(double radius) {
        this.radius = radius;
    }
    
    @Override
    protected void calculateArea() {
        area = Math.PI * radius * radius;
    }
}
    

Question 7. Differentiate between Method-overloading and Method-overriding, with the help of a suitable example. (5 marks)

Answer :

Method Overloading:

Method Overriding:

Example of Method Overloading:

public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
    
    public double add(double a, double b) {
        return a + b;
    }
    
    public int add(int a, int b, int c) {
        return a + b + c;
    }
}
    

Example of Method Overriding:

class Animal {
    public void makeSound() {
        System.out.println("The animal makes a sound");
    }
}

class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("The dog barks");
    }
}

class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("The cat meows");
    }
}
    

Question 8. What is layout manager? Explain any two layouts in Java. (5 marks)

Answer :

A Layout Manager in Java is a class that determines how components are arranged within a container. It automatically positions and sizes components based on certain rules and constraints.

Two common layout managers in Java:

1. FlowLayout:

Example:

JPanel panel = new JPanel(new FlowLayout());
panel.add(new JButton("Button 1"));
panel.add(new JButton("Button 2"));
panel.add(new JButton("Button 3"));
    

2. GridLayout:

Example:

JPanel panel = new JPanel(new GridLayout(2, 3)); // 2 rows, 3 columns
panel.add(new JButton("1"));
panel.add(new JButton("2"));
panel.add(new JButton("3"));
panel.add(new JButton("4"));
panel.add(new JButton("5"));
panel.add(new JButton("6"));
    

Question 9. What are proxy servers? Explain the usage of anonymous proxy servers in designing mailing applications. (6 marks)

Answer :

Proxy servers are intermediary servers that act as a gateway between a client and the internet. They serve several purposes:
→ Improve security by filtering requests
→ Enhance privacy by masking the client's IP address
→ Cache frequently requested content to improve performance
→ Bypass geo-restrictions or content filters

Anonymous proxy servers in mailing applications:
→ Hide the sender's IP address, enhancing privacy
→ Help bypass email sending limits imposed by ISPs
→ Can be used to send emails from restricted networks
→ Assist in avoiding spam filters by distributing sending across multiple IPs
→ Enable testing of email deliverability from various geographic locations

However, it's important to note that using anonymous proxies for email can raise ethical and legal concerns, and may violate terms of service of email providers. They should be used responsibly and in compliance with applicable laws and regulations.

Question 10. How does Servlet differ from Applet? Discuss all the phases of a servlet lifecycle. (7 marks)

Answer :

Differences between Servlet and Applet:
→ Execution: Servlets run on the server-side; Applets run on the client-side (browser)
→ UI: Servlets typically don't have a UI; Applets can have a graphical user interface
→ Lifecycle: Servlets are managed by the web container; Applets by the browser
→ Communication: Servlets can communicate with databases; Applets have limited access to client resources
→ Security: Servlets have fewer security restrictions; Applets run in a sandbox with more restrictions

Servlet Lifecycle Phases:

1. Loading: The servlet class is loaded by the web container when the application starts or when first requested.
2. Instantiation: The container creates an instance of the servlet.
3. Initialization: The init() method is called once to set up resources.
4. Servicing: The service() method is called for each client request. It typically dispatches to doGet(), doPost(), etc.
5. Destruction: The destroy() method is called when the servlet is being taken out of service.

The servicing phase repeats for each request, while the other phases typically occur only once during the servlet's lifecycle.

Question 11. Write a program in Java to copy the text content of one file into another file. Support your program with suitable comments. (7 marks)

Answer :

import java.io.*;

public class FileCopy {
    public static void main(String[] args) {
        // Specify the source and destination file paths
        String sourceFile = "source.txt";
        String destFile = "destination.txt";

        try (
            // Create readers and writers for the files
            BufferedReader reader = new BufferedReader(new FileReader(sourceFile));
            BufferedWriter writer = new BufferedWriter(new FileWriter(destFile))
        ) {
            String line;
            // Read each line from the source file
            while ((line = reader.readLine()) != null) {
                // Write the line to the destination file
                writer.write(line);
                // Add a newline character after each line
                writer.newLine();
            }
            System.out.println("File copied successfully.");
        } catch (IOException e) {
            // Handle potential IO exceptions
            System.out.println("An error occurred: " + e.getMessage());
            e.printStackTrace();
        }
    }
}
    

This program demonstrates file handling in Java:
→ It uses BufferedReader and BufferedWriter for efficient reading and writing
→ The try-with-resources statement ensures proper closing of file resources
→ It reads the source file line by line and writes each line to the destination file
→ Exception handling is implemented to manage potential IO errors

Question 12. What is StringBuffer class? Write a program in Java to append a given string to a StringBuffer object. (6 marks)

Answer :

StringBuffer is a class in Java that represents mutable sequences of characters. Unlike String, StringBuffer can be modified without creating new objects, making it more efficient for string manipulation operations.

Key features of StringBuffer:
→ Mutable: Contents can be changed without creating new objects
→ Thread-safe: Synchronized methods make it suitable for multi-threaded environments
→ Efficient for frequent modifications: Ideal for loops or situations with many string changes

Program to append a string to a StringBuffer object:

public class StringBufferExample {
    public static void main(String[] args) {
        // Create a StringBuffer object
        StringBuffer sb = new StringBuffer("Hello ");

        // String to be appended
        String appendString = "World!";

        // Append the string to StringBuffer
        sb.append(appendString);

        // Print the result
        System.out.println("Result: " + sb.toString());

        // Demonstrate other StringBuffer operations
        sb.insert(5, "Beautiful ");
        System.out.println("After insert: " + sb);

        sb.reverse();
        System.out.println("After reverse: " + sb);
    }
}
    

This program demonstrates:
→ Creation of a StringBuffer object
→ Appending a string using the append() method
→ Additional StringBuffer operations like insert() and reverse()
→ Converting StringBuffer to String using toString() method

Question 13. Write a program to pass parameters to an Applet using a web page. Also write the phases of an Applet lifecycle. (6 marks)

Answer :

HTML file to pass parameters to an Applet:

<html>
<body>
    <applet code="ParameterApplet.class" width="300" height="200">
        <param name="message" value="Hello from HTML!">
        <param name="color" value="blue">
    </applet>
</body>
</html>
    

Java Applet code:

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

public class ParameterApplet extends Applet {
    private String message;
    private Color textColor;

    public void init() {
        message = getParameter("message");
        String colorParam = getParameter("color");
        textColor = colorParam.equals("blue") ? Color.BLUE : Color.BLACK;
    }

    public void paint(Graphics g) {
        g.setColor(textColor);
        g.drawString(message, 50, 25);
    }
}
    

Phases of Applet Lifecycle:

1. Initialization: The init() method is called when the applet is first loaded.
2. Starting: The start() method is called after init() and each time the applet is revisited in a web page.
3. Painting: The paint() method is called to render the applet's output.
4. Stopping: The stop() method is called when the user navigates away from the applet's page.
5. Destruction: The destroy() method is called when the applet is being unloaded from memory.

Question 14. What is an event in Java? How does Java handle events? Write a program in Java to capture any event generated by keyboard. (8 marks)

Answer :

An event in Java is an object that represents some occurrence or change in state within a component. Events are used to notify the program when something interesting happens, such as a button click or a key press.

Java handles events through the event-delegation model:
→ Event sources generate events
→ Event listeners register with event sources to receive notifications
→ When an event occurs, the source notifies all registered listeners
→ Listeners implement methods to respond to the events

Program to capture keyboard events:

import javax.swing.*;
import java.awt.event.*;

public class KeyEventDemo extends JFrame implements KeyListener {
    private JTextField textField;

    public KeyEventDemo() {
        setTitle("Key Event Demo");
        setSize(300, 200);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        textField = new JTextField(20);
        textField.addKeyListener(this);

        add(textField);
        setVisible(true);
    }

    public void keyPressed(KeyEvent e) {
        displayInfo("Key Pressed", e);
    }

    public void keyReleased(KeyEvent e) {
        displayInfo("Key Released", e);
    }

    public void keyTyped(KeyEvent e) {
        displayInfo("Key Typed", e);
    }

    private void displayInfo(String eventType, KeyEvent e) {
        String keyString = KeyEvent.getKeyText(e.getKeyCode());
        System.out.println(eventType + ": " + keyString);
    }

    public static void main(String[] args) {
        new KeyEventDemo();
    }
}
    

This program demonstrates:
→ Creation of a JFrame with a JTextField
→ Implementation of KeyListener interface
→ Handling of keyPressed, keyReleased, and keyTyped events
→ Displaying information about captured key events

Question 15. Write a Java program to create a Teacher class and derive PGT, TGT and PRT classes from Teacher class. Define appropriate constructors for all the classes. Also define a method to display information of Teacher. Make necessary assumptions as required. (10 marks)

Answer :

class Teacher {
    protected String name;
    protected int id;
    protected String subject;

    public Teacher(String name, int id, String subject) {
        this.name = name;
        this.id = id;
        this.subject = subject;
    }

    public void displayInfo() {
        System.out.println("Name: " + name);
        System.out.println("ID: " + id);
        System.out.println("Subject: " + subject);
    }
}

class PGT extends Teacher {
    private String specialization;

    public PGT(String name, int id, String subject, String specialization) {
        super(name, id, subject);
        this.specialization = specialization;
    }

    @Override
    public void displayInfo() {
        super.displayInfo();
        System.out.println("Position: PGT");
        System.out.println("Specialization: " + specialization);
    }
}

class TGT extends Teacher {
    private int yearsOfExperience;

    public TGT(String name, int id, String subject, int yearsOfExperience) {
        super(name, id, subject);
        this.yearsOfExperience = yearsOfExperience;
    }

    @Override
    public void displayInfo() {
        super.displayInfo();
        System.out.println("Position: TGT");
        System.out.println("Years of Experience: " + yearsOfExperience);
    }
}

class PRT extends Teacher {
    private String gradeLevel;

    public PRT(String name, int id, String subject, String gradeLevel) {
        super(name, id, subject);
        this.gradeLevel = gradeLevel;
    }

    @Override
    public void displayInfo() {
        super.displayInfo();
        System.out.println("Position: PRT");
        System.out.println("Grade Level: " + gradeLevel);
    }
}

public class SchoolSystem {
    public static void main(String[] args) {
        Teacher pgt = new PGT("John Doe", 101, "Physics", "Quantum Mechanics");
        Teacher tgt = new TGT("Jane Smith", 102, "Mathematics", 5);
        Teacher prt = new PRT("Alice Johnson", 103, "English", "Elementary");

        System.out.println("PGT Information:");
        pgt.displayInfo();
        System.out.println("
TGT Information:");
        tgt.displayInfo();
        System.out.println("
PRT Information:");
        prt.displayInfo();
    }
}
    

This program demonstrates:
→ Creation of a base Teacher class with common attributes
→ Derivation of PGT, TGT, and PRT classes from Teacher
→ Use of constructors to initialize attributes
→ Method overriding to display specific information for each teacher type
→ Use of inheritance and polymorphism in the main method

Question 16. Write a Java program to set up JDBC and execute an SQL statement on a database table 'BOOK', with fields BOOK_ISBN, BOOK_AUTH, BOOK_PRICE, BOOK_PUBL. The SQL statement should find the BOOK_AUTH and BOOK_PRICE of the BOOK having ISBN = 500123. (10 marks)

Answer :

import java.sql.*;

public class BookDatabaseQuery {
    public static void main(String[] args) {
        // JDBC driver name and database URL
        String JDBC_DRIVER = "com.mysql.jdbc.Driver";
        String DB_URL = "jdbc:mysql://localhost/library";

        // Database credentials
        String USER = "username";
        String PASS = "password";

        Connection conn = null;
        Statement stmt = null;
        try {
            // Register JDBC driver
            Class.forName(JDBC_DRIVER);

            // Open a connection
            System.out.println("Connecting to database...");
            conn = DriverManager.getConnection(DB_URL, USER, PASS);

            // Execute a query
            System.out.println("Creating statement...");
            stmt = conn.createStatement();
            String sql = "SELECT BOOK_AUTH, BOOK_PRICE FROM BOOK WHERE BOOK_ISBN = 500123";
            ResultSet rs = stmt.executeQuery(sql);

            // Extract data from result set
            if (rs.next()) {
                String author = rs.getString("BOOK_AUTH");
                double price = rs.getDouble("BOOK_PRICE");
                System.out.println("Book Author: " + author);
                System.out.println("Book Price: $" + price);
            } else {
                System.out.println("No book found with ISBN 500123");
            }

            // Clean-up environment
            rs.close();
            stmt.close();
            conn.close();
        } catch(SQLException se) {
            // Handle errors for JDBC
            se.printStackTrace();
        } catch(Exception e) {
            // Handle errors for Class.forName
            e.printStackTrace();
        } finally {
            // Finally block used to close resources
            try {
                if(stmt!=null) stmt.close();
            } catch(SQLException se2) {
            } // nothing we can do
            try {
                if(conn!=null) conn.close();
            } catch(SQLException se) {
                se.printStackTrace();
            }
        }
        System.out.println("Goodbye!");
    }
}
    

This program demonstrates:
→ Setting up a JDBC connection to a MySQL database
→ Creating and executing an SQL query
→ Retrieving and displaying results from the query
→ Proper exception handling and resource management
→ Closing database connections and statements

Question 17. What is an Exception? Briefly explain the causes of Exceptions. Describe how multiple exceptions are caught in Java, with the help of a suitable program code. (10 marks)

Answer :

An Exception in Java is an event that occurs during the execution of a program that disrupts the normal flow of the program's instructions. It represents an error condition that a program may encounter at runtime.

Common causes of Exceptions:
→ Invalid user input
→ Device errors (e.g., file not found)
→ Network errors
→ Code errors (e.g., division by zero)
→ Out of memory errors

Catching multiple exceptions:

Java allows catching multiple exceptions using multiple catch blocks or using a single catch block with multiple exception types (introduced in Java 7).

import java.io.*;

public class MultipleExceptionHandler {
    public static void main(String[] args) {
        try {
            // Code that may throw exceptions
            int[] numbers = {1, 2, 3};
            System.out.println(numbers[4]); // ArrayIndexOutOfBoundsException

            FileInputStream file = new FileInputStream("nonexistent.txt"); // FileNotFoundException

            int result = 10 / 0; // ArithmeticException
        } 
        catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("Array index error: " + e.getMessage());
        } 
        catch (FileNotFoundException e) {
            System.out.println("File not found: " + e.getMessage());
        } 
        catch (ArithmeticException | NullPointerException e) {
            // Catching multiple exceptions in one block (Java 7+)
            System.out.println("Arithmetic or Null Pointer error: " + e.getMessage());
        } 
        catch (Exception e) {
            // Catch-all for any other exceptions
            System.out.println("An error occurred: " + e.getMessage());
        } 
        finally {
            System.out.println("This block always executes.");
        }
    }
}
    

This program demonstrates:
→ Using multiple catch blocks for different exception types
→ Catching multiple exceptions in a single catch block
→ Using a catch-all block for any unspecified exceptions
→ Using a finally block that always executes

Question 18. Write a Java program to print Fibonacci series, up to the nth term entered by the user. Support your program with suitable comments. (5 marks)

Answer :

import java.util.Scanner;

public class FibonacciSeries {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // Prompt user for input
        System.out.print("Enter the number of terms for Fibonacci series: ");
        int n = scanner.nextInt();

        // Initialize first two terms
        int firstTerm = 0, secondTerm = 1;

        System.out.println("Fibonacci Series up to " + n + " terms:");

        for (int i = 1; i <= n; ++i) {
            // Print the current term
            System.out.print(firstTerm + " ");

            // Calculate the next term
            int nextTerm = firstTerm + secondTerm;
            firstTerm = secondTerm;
            secondTerm = nextTerm;
        }

        scanner.close();
    }
}
    

This program demonstrates:
→ User input handling with Scanner
→ Initialization of the first two terms of the Fibonacci series
→ Use of a for loop to generate and print the series
→ Calculation of each subsequent term in the series
→ Proper closing of the Scanner resource

Question 19. Explain the Java RMI architecture, with the help of a diagram. (5 marks)

Answer :

Java RMI (Remote Method Invocation) is an API that allows an object to invoke a method on an object running in another JVM (Java Virtual Machine).

Key components of RMI architecture:

1. Client: Invokes methods on remote objects.
2. Server: Creates remote objects, makes references to them accessible, and waits for clients to invoke methods on these objects.
3. RMI Registry: A naming service that maintains a list of available remote objects.
4. Stub: Client-side proxy for the remote object.
5. Skeleton: Server-side object that communicates with the stub and passes method calls to the actual remote object.

Diagram of RMI Architecture:

Process:

1. Client looks up the remote object in the RMI Registry.
2. Registry returns a reference to the stub of the remote object.
3. Client invokes a method on the stub, which forwards the call to the server.
4. Server's skeleton receives the call, invokes the method on the actual object, and returns the result.

This architecture allows for distributed computing, where objects on different machines can interact as if they were on the same machine.

Question 20. Explain the basic features of object oriented programming language. [5 marks]

Answer :

The basic features of object-oriented programming (OOP) languages are:

1. Classes and Objects: Classes are blueprints for creating objects, which are instances of classes. They encapsulate data for the object and methods to manipulate that data. Objects are instances of classes created at runtime.

2. Encapsulation: This principle involves bundling data and methods that operate on that data within a single unit (class). It includes the concept of data hiding, where an object's internal details are hidden from the outside world, and access is restricted through well-defined interfaces.

3. Inheritance: This feature allows a class (subclass or derived class) to inherit properties and methods from another class (superclass or base class). It promotes code reusability and establishes a relationship between parent and child classes.

4. Polymorphism: This allows objects to take on multiple forms. It's often achieved through method overriding (runtime polymorphism) or method overloading (compile-time polymorphism). Polymorphism enables a single interface to be used for a general class of actions.

5. Abstraction: This involves hiding complex implementation details and showing only essential features of an object. It's achieved through abstract classes and interfaces, allowing developers to focus on what an object does rather than how it does it.

Question 21. Why is Java called machine independent language? Explain the functionality of JVM. [5 marks]

Answer :

Java is called a machine-independent language because Java code can run on any platform without recompilation, following the "Write Once, Run Anywhere" principle. This is achieved through the use of bytecode and the Java Virtual Machine (JVM).

The Java Virtual Machine (JVM) enables this machine independence through the following process:

1. Compilation: Java source code (.java files) is compiled into bytecode (.class files) by the Java compiler. This bytecode is platform-independent.

2. Bytecode: This is an intermediate code that's closer to machine code but not specific to any computer architecture. It's a set of instructions that the JVM can understand.

3. JVM: The JVM acts as an interpreter, translating bytecode to machine-specific code at runtime. Each operating system has its own JVM implementation.

4. Execution: The JVM executes the translated code on the host machine. It provides a runtime environment that includes memory management, garbage collection, and security features.

5. Platform Adaptation: The JVM handles platform-specific operations, allowing the same bytecode to run on different systems. It abstracts the underlying hardware and OS, providing a consistent environment for Java programs.

This process allows Java programs to run on any device with a JVM, regardless of the underlying hardware or operating system. The developer writes and compiles the code once, and it can then be distributed and run on various platforms without modification → true "Write Once, Run Anywhere" capability.

Question 22. Differentiate between constructor and method, give example for both. [5 marks]

Answer :

Constructors and methods are both important components in object-oriented programming, but they serve different purposes and have distinct characteristics:

1. Purpose:
→ Constructor: Initializes object state when created. It sets up the initial values for object attributes.
→ Method: Performs operations or computations on an object or its data.

2. Naming:
→ Constructor: Must have the same name as the class. It's a special method.
→ Method: Can have any valid identifier as a name, following the language's naming conventions.

3. Return Type:
→ Constructor: No return type, not even void. It implicitly returns an instance of the class.
→ Method: Must have a return type (void if no value is returned).

4. Invocation:
→ Constructor: Automatically called when an object is created using the 'new' keyword.
→ Method: Explicitly called on an object or, if static, on the class itself.

5. Inheritance:
→ Constructor: Not inherited by subclasses, but can be called using 'super()'.
→ Method: Inherited by subclasses (unless private or the class is final).

Examples:

Constructor:

    public class Car {
        private String model;
        private int year;
        
        public Car(String model, int year) {
            this.model = model;
            this.year = year;
            System.out.println("A new " + year + " " + model + " car is created.");
        }
    }

    // Usage
    Car myCar = new Car("Tesla Model 3", 2023);
     

Method:

    public class Car {
        private int speed;
        
        public void accelerate(int increment) {
            speed += increment;
            System.out.println("The car accelerated. Current speed: " + speed + " km/h");
        }

        public int getCurrentSpeed() {
            return speed;
        }
    }

    // Usage
    Car myCar = new Car();
    myCar.accelerate(20);
    int currentSpeed = myCar.getCurrentSpeed();
     

Question 23. What is an abstract class? Explain the use of abstract class with an example. [5 marks]

Answer :

An abstract class is a class that cannot be instantiated and may contain abstract methods (methods without a body) as well as concrete methods (with implementation). It serves as a base for subclasses to inherit from and implement the abstract methods.

Uses of abstract classes:

1. Define a common interface for a group of related subclasses
2. Provide default implementations for some methods
3. Declare fields that are common to all subclasses
4. Enforce certain methods to be implemented by subclasses
5. Achieve a level of abstraction by hiding certain details and only showing the object's essential features

Example:

    abstract class Shape {
        protected String color;

        public Shape(String color) {
            this.color = color;
        }

        // Abstract method - must be implemented by subclasses
        public abstract double calculateArea();

        // Concrete method - provides implementation
        public void displayColor() {
            System.out.println("Color: " + color);
        }

        // Another abstract method
        public abstract void draw();
    }

    class Circle extends Shape {
        private double radius;

        public Circle(String color, double radius) {
            super(color);
            this.radius = radius;
        }

        @Override
        public double calculateArea() {
            return Math.PI * radius * radius;
        }

        @Override
        public void draw() {
            System.out.println("Drawing a circle");
        }
    }

    class Rectangle extends Shape {
        private double width;
        private double height;

        public Rectangle(String color, double width, double height) {
            super(color);
            this.width = width;
            this.height = height;
        }

        @Override
        public double calculateArea() {
            return width * height;
        }

        @Override
        public void draw() {
            System.out.println("Drawing a rectangle");
        }
    }

    // Usage
    public class Main {
        public static void main(String[] args) {
            Shape circle = new Circle("Red", 5);
            Shape rectangle = new Rectangle("Blue", 4, 6);

            circle.displayColor();
            System.out.println("Circle area: " + circle.calculateArea());
            circle.draw();

            rectangle.displayColor();
            System.out.println("Rectangle area: " + rectangle.calculateArea());
            rectangle.draw();
        }
    }
     

In this example, Shape is an abstract class with abstract methods calculateArea() and draw(). It also provides a concrete method displayColor(). Circle and Rectangle are concrete subclasses that extend Shape and implement the abstract methods.

The abstract class provides a common structure for all shapes, enforcing the implementation of area calculation and drawing for each specific shape. It also allows for shared functionality (like displaying color) and common attributes (color) across all shapes.

This demonstrates how abstract classes can be used to create a hierarchy of related classes, providing a mix of implemented and to-be-implemented functionality, which is particularly useful in designing frameworks and large-scale applications.

Question 24. What are cookies and session variables? Briefly discuss the utility of both. [5 marks]

Answer :

Cookies:

Cookies are small pieces of data stored on the client-side (user's browser) by websites. They are sent back to the server with subsequent requests, allowing the server to remember information about the user or their preferences.

Session Variables:

Session variables are server-side storage mechanisms that maintain user-specific information for the duration of a user's interaction with a web application (a session).

Utility of Cookies:

• Remembering user preferences (e.g., language settings, theme choices)
• Tracking user behavior for analytics
• Maintaining login state across pages
• Storing shopping cart information in e-commerce sites

Utility of Session Variables:

• Storing user authentication information
• Maintaining user-specific data during a browsing session
• Implementing features like multi-page forms
• Managing user state without modifying the client-side

Both cookies and session variables are crucial for creating personalized and stateful web experiences, but they differ in where data is stored (client vs. server) and how long it persists.

Question 25. Explain the different steps in the life cycle of an applet. [5 marks]

Answer :

The life cycle of a Java applet consists of the following steps:

1. Initialization (init()): This method is called when the applet is first loaded. It's used to initialize variables, load images or fonts, and set up the initial state of the applet.

2. Starting (start()): Called after init() and each time the applet is revisited in a web page. It starts the applet's execution, often used to begin animations or start threads.

3. Painting (paint()): Invoked to draw the applet's output on the screen. It's called after init() and start(), and whenever the applet needs to redraw its contents.

4. Stopping (stop()): Called when the user navigates away from the applet's page. It's used to suspend threads or stop ongoing processes to conserve resources.

5. Destruction (destroy()): The final method called before the applet is unloaded. It's used for cleanup operations like closing files or network connections.

This lifecycle allows for efficient resource management and ensures the applet behaves correctly in a web environment. The browser or applet viewer manages these transitions automatically.

Question 26. Discuss the relationship between data abstraction and encapsulation. [5 marks]

Answer :

Data abstraction and encapsulation are closely related concepts in object-oriented programming:

Data Abstraction:

Data abstraction is the process of hiding complex implementation details and showing only the essential features of an object. It focuses on what an object does rather than how it does it.

Encapsulation:

Encapsulation is the bundling of data and the methods that operate on that data within a single unit (class). It includes the concept of data hiding, where an object's internal details are hidden from the outside world.

Relationship:

• Encapsulation is a mechanism that enables data abstraction.
• Data abstraction focuses on the observable behavior of an object, while encapsulation focuses on the implementation that gives rise to this behavior.
• Encapsulation provides a way to achieve data abstraction by bundling the data and methods together and controlling access through access modifiers.
• Data abstraction often relies on encapsulation to hide the internal details and expose only what's necessary.

In essence, data abstraction is the what (the abstract view of the data) and encapsulation is the how (the technique used to achieve and maintain this abstraction). Together, they help in creating more maintainable and modular code.

Question 27. Explain the usage of container in Java Applet and Servlet. [5 marks]

Answer :

Containers in Java play crucial roles in both Applets and Servlets, though their usage differs:

Containers in Applets:

• In Applets, containers are GUI components that can hold other GUI components.
• Common containers include Panel, Frame, and Applet itself.
• They manage the layout and display of child components within the applet's visual interface.
• Containers help in organizing and structuring the user interface of the applet.

Containers in Servlets:

• For Servlets, the container (often called Servlet Container or Web Container) is a part of the web server that manages the servlet's lifecycle.
• Examples include Apache Tomcat, Jetty, and WebSphere.
• The container handles communication between the servlet and the web server.
• It manages servlet initialization, execution, and destruction.
• Provides services like session management, security, and concurrency handling.

Key Differences:

While both are called containers, they serve different purposes. Applet containers are UI-focused, managing visual components, while Servlet containers are server-side runtime environments managing the lifecycle and execution of servlets.

Understanding these container concepts is crucial for developing effective Java-based web applications, whether client-side (Applets) or server-side (Servlets).

Question 28. Explain how exception handling is performed in Java. Briefly discuss the concept of checked exception and unchecked exception, with an example of each. [10 marks]

Answer :

Exception Handling in Java:

Exception handling in Java is performed using try-catch blocks and throw statements. The process involves:

1. Try block: Contains code that might throw an exception
2. Catch block: Handles the exception if it occurs
3. Finally block: (Optional) Executes regardless of whether an exception occurred
4. Throw statement: Used to explicitly throw an exception

Checked Exceptions:

Checked exceptions are exceptions that must be either caught or declared in the method signature. They are checked at compile-time.

Example:

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

    public class CheckedExceptionExample {
        public static void main(String[] args) {
            try {
                FileReader file = new FileReader("nonexistent.txt");
            } catch (IOException e) {
                System.out.println("File not found: " + e.getMessage());
            }
        }
    }
    

Unchecked Exceptions:

Unchecked exceptions are exceptions that don't need to be explicitly caught or declared. They usually indicate programming errors and are subclasses of RuntimeException.

Example:

    public class UncheckedExceptionExample {
        public static void main(String[] args) {
            int[] numbers = {1, 2, 3};
            try {
                System.out.println(numbers[5]); // Accessing out of bounds index
            } catch (ArrayIndexOutOfBoundsException e) {
                System.out.println("Array index out of bounds: " + e.getMessage());
            }
        }
    }
    

The key difference is that checked exceptions force the programmer to handle potential errors, while unchecked exceptions represent runtime errors that are often due to programming mistakes.

Question 29. Briefly discuss the concept of listener in Java. Write a program in Java to implement mouse motion listener, support your program with suitable comments. [10 marks]

Answer :

Concept of Listener in Java:

In Java, a listener is an interface that allows an object to receive notifications when a specific event occurs. It's a key part of event handling in Java, especially in GUI programming. Listeners are used to create interactive applications that respond to user actions or system events.

Here's a program implementing a MouseMotionListener:

    import javax.swing.*;
    import java.awt.event.*;

    public class MouseMotionListenerExample extends JFrame implements MouseMotionListener {
        private JLabel statusBar;

        public MouseMotionListenerExample() {
            // Set up the frame
            setTitle("Mouse Motion Listener Example");
            setSize(300, 200);
            setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

            // Create a status bar to display mouse coordinates
            statusBar = new JLabel("Move the mouse inside the window");
            add(statusBar);

            // Add mouse motion listener to the frame
            addMouseMotionListener(this);
        }

        // Implement MouseMotionListener methods

        @Override
        public void mouseMoved(MouseEvent e) {
            // Update status bar with current mouse coordinates
            statusBar.setText("Mouse moved to: (" + e.getX() + ", " + e.getY() + ")");
        }

        @Override
        public void mouseDragged(MouseEvent e) {
            // Update status bar when mouse is dragged
            statusBar.setText("Mouse dragged to: (" + e.getX() + ", " + e.getY() + ")");
        }

        public static void main(String[] args) {
            // Create and display the frame on the Event Dispatch Thread
            SwingUtilities.invokeLater(() -> {
                new MouseMotionListenerExample().setVisible(true);
            });
        }
    }
    

Explanation:

• The class extends JFrame and implements MouseMotionListener interface.
• In the constructor, we set up a basic window and add a JLabel as a status bar.
• We add the MouseMotionListener to the frame using addMouseMotionListener(this).
• The mouseMoved() method is called when the mouse is moved within the frame.
• The mouseDragged() method is called when the mouse is dragged within the frame.
• Both methods update the status bar with the current mouse coordinates.
• The main method creates an instance of the class and makes it visible.

This program demonstrates how listeners can be used to respond to user interactions in a GUI application. When run, it will display a window where the status bar updates with the mouse's coordinates as it moves or is dragged within the window.

Question 30. What is string class? How is it different from String Buffer class? Write a Java program to find the length of a given string. [7 marks]

Answer :

String Class:

The String class in Java is an immutable class that represents a sequence of characters. Once a String object is created, its value cannot be changed.

StringBuffer Class:

StringBuffer is a mutable class that also represents a sequence of characters. Unlike String, StringBuffer objects can be modified after creation.

Key Differences:

• Mutability: String is immutable, StringBuffer is mutable.
• Performance: StringBuffer is more efficient for frequent modifications.
• Thread Safety: StringBuffer is synchronized and thread-safe, while String is not.
• Memory: String can be more memory-efficient for unchanging text.

Java Program to Find String Length:

    public class StringLengthExample {
        public static void main(String[] args) {
            // Create a string
            String sampleString = "Hello, World!";

            // Get the length of the string
            int length = sampleString.length();

            // Print the result
            System.out.println("The length of the string "" + sampleString + "" is: " + length);
        }
    }
    

This program demonstrates how to use the length() method of the String class to find the number of characters in a string. When run, it will output:

The length of the string "Hello, World!" is: 13

Question 31. What is servlet? Explain how session handling is performed in servlet programming. [7 marks]

Answer :

Servlet:

A servlet is a Java programming language class used to extend the capabilities of servers that host applications accessed by means of a request-response programming model. Servlets are primarily used to process or store data submitted by an HTML form, provide dynamic content, and manage state information that doesn't exist in the stateless HTTP protocol.

Session Handling in Servlet Programming:

Session handling in servlets allows the server to maintain state information about a series of requests from the same client. Here's how it's typically performed:

1. Session Creation: When a client makes the first request, the server creates a new HttpSession object.
2. Session ID: A unique session ID is generated and typically stored as a cookie in the client's browser.
3. Retrieving Session: In subsequent requests, the server retrieves the existing session using the session ID.
4. Storing Data: Servlets can store data in the session using setAttribute() method.
5. Retrieving Data: Data can be retrieved from the session using getAttribute() method.
6. Session Timeout: Sessions typically have a timeout period after which they are invalidated.

Example Code Snippet:

    protected void doGet(HttpServletRequest request, HttpServletResponse response) 
            throws ServletException, IOException {
        // Get the session object
        HttpSession session = request.getSession();

        // Store data in the session
        session.setAttribute("username", "JohnDoe");

        // Retrieve data from the session
        String username = (String) session.getAttribute("username");

        // Set or get session timeout (in seconds)
        session.setMaxInactiveInterval(1800); // 30 minutes

        // Invalidate the session
        // session.invalidate();
    }
    

This approach allows servlets to maintain user-specific information across multiple requests, enabling the development of stateful web applications.

Question 32. What is an Interface? Write a Java program to show how a class implements two interfaces. [6 marks]

Answer :

Interface:

An interface in Java is an abstract type that is used to specify a behavior that classes must implement. It contains abstract methods (methods without a body) and can also include constants, default methods, and static methods.

Key Characteristics of Interfaces:

• All methods in an interface are implicitly public and abstract.
• Interfaces can extend multiple interfaces.
• A class can implement multiple interfaces.

Java Program Implementing Two Interfaces:

    // First interface
    interface Printable {
        void print();
    }

    // Second interface
    interface Displayable {
        void display();
    }

    // Class implementing both interfaces
    class Document implements Printable, Displayable {
        private String content;

        public Document(String content) {
            this.content = content;
        }

        // Implementing print() from Printable
        @Override
        public void print() {
            System.out.println("Printing: " + content);
        }

        // Implementing display() from Displayable
        @Override
        public void display() {
            System.out.println("Displaying: " + content);
        }
    }

    // Main class to demonstrate
    public class InterfaceExample {
        public static void main(String[] args) {
            Document doc = new Document("Hello, World!");
            doc.print();   // Calls print() method
            doc.display(); // Calls display() method
        }
    }
    

In this program:

• We define two interfaces: Printable and Displayable.
• The Document class implements both interfaces.
• The class provides implementations for both print() and display() methods.
• In the main method, we create a Document object and call both methods.

This example demonstrates how a single class can implement multiple interfaces, allowing for a form of multiple inheritance of behavior in Java.

Question 33. Write a Java program to create a volume class. Derive cube and sphere classes from it. Define constructor for these three classes. [7 marks]

Answer :

Here's a Java program that creates a Volume class and derives Cube and Sphere classes from it, with constructors for all three classes:

    // Abstract base class for volume
    abstract class Volume {
        protected double volume;

        // Constructor
        public Volume() {
            this.volume = 0;
        }

        // Abstract method to calculate volume
        public abstract void calculateVolume();

        // Method to get volume
        public double getVolume() {
            return volume;
        }
    }

    // Cube class derived from Volume
    class Cube extends Volume {
        private double side;

        // Constructor
        public Cube(double side) {
            super();
            this.side = side;
            calculateVolume();
        }

        @Override
        public void calculateVolume() {
            this.volume = Math.pow(side, 3);
        }
    }

    // Sphere class derived from Volume
    class Sphere extends Volume {
        private double radius;

        // Constructor
        public Sphere(double radius) {
            super();
            this.radius = radius;
            calculateVolume();
        }

        @Override
        public void calculateVolume() {
            this.volume = (4.0 / 3.0) * Math.PI * Math.pow(radius, 3);
        }
    }

    // Main class to demonstrate
    public class VolumeDemo {
        public static void main(String[] args) {
            Cube cube = new Cube(5);
            System.out.println("Volume of Cube: " + cube.getVolume());

            Sphere sphere = new Sphere(3);
            System.out.println("Volume of Sphere: " + sphere.getVolume());
        }
    }
    

In this program:

• The Volume class is an abstract base class with an abstract method calculateVolume().
• The Cube class extends Volume and implements calculateVolume() for a cube.
• The Sphere class extends Volume and implements calculateVolume() for a sphere.
• Each class has its own constructor that initializes its specific attributes and calls calculateVolume().
• The main method demonstrates the creation and use of Cube and Sphere objects.

Question 34. What is Synchronization? Explain how methods are synchronized in Java, with the help of an example. [6 marks]

Answer :

Synchronization in Java is a mechanism to control access to shared resources in a multi-threaded environment. It ensures that only one thread can access the synchronized code at a time, preventing race conditions and ensuring thread safety.

How methods are synchronized in Java:

1. Using the synchronized keyword before the method declaration.
2. Using synchronized blocks within methods.

Example of synchronized methods:

    public class BankAccount {
        private int balance = 0;

        // Synchronized method for deposit
        public synchronized void deposit(int amount) {
            balance += amount;
            System.out.println("Deposited: " + amount + ", New Balance: " + balance);
        }

        // Synchronized method for withdrawal
        public synchronized void withdraw(int amount) {
            if (balance >= amount) {
                balance -= amount;
                System.out.println("Withdrawn: " + amount + ", New Balance: " + balance);
            } else {
                System.out.println("Insufficient funds");
            }
        }
    }

    class TransactionThread extends Thread {
        private BankAccount account;
        private boolean isDeposit;
        private int amount;

        public TransactionThread(BankAccount account, boolean isDeposit, int amount) {
            this.account = account;
            this.isDeposit = isDeposit;
            this.amount = amount;
        }

        public void run() {
            if (isDeposit) {
                account.deposit(amount);
            } else {
                account.withdraw(amount);
            }
        }
    }

    public class SynchronizationExample {
        public static void main(String[] args) {
            BankAccount account = new BankAccount();
            TransactionThread t1 = new TransactionThread(account, true, 1000);
            TransactionThread t2 = new TransactionThread(account, false, 500);

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

In this example:

• The deposit() and withdraw() methods are synchronized, ensuring that only one thread can access them at a time.
• This prevents race conditions where two threads might try to modify the balance simultaneously.
• The TransactionThread class simulates concurrent transactions on the account.
• The main method creates two threads that perform a deposit and a withdrawal concurrently.

Synchronization ensures that these operations are thread-safe and maintain the integrity of the account balance.

Question 33. Write short notes on the following: [5×4=20 marks]
(a) Dynamic Binding
(b) Stream Tokenizer
(c) JDBC Drivers
(d) Function Overloading

Answer :

(a) Dynamic Binding:

• Dynamic binding, also known as late binding, is a mechanism in Java where the method call is resolved at runtime rather than compile time.
• It's associated with polymorphism and method overriding in inheritance.
• The JVM determines which method to call based on the actual object type, not the reference type.
• This allows for more flexible and extensible code, as subclasses can provide specific implementations of methods.
• Example: When a method is called on a superclass reference to a subclass object, the subclass's overridden method is executed.

(b) Stream Tokenizer:

• StreamTokenizer is a class in Java that breaks an input stream into tokens, making it easier to parse.
• It's particularly useful for reading formatted input from files or strings.
• Tokens can be numbers, words, or individual characters.
• It provides methods like nextToken() to read the next token and various methods to check the token type.
• Useful in scenarios like parsing configuration files, simple programming languages, or structured text data.

(c) JDBC Drivers:

• JDBC (Java Database Connectivity) drivers are software components that enable Java applications to interact with databases.
• They implement the JDBC API for a particular database management system.
• Four types of JDBC drivers:
  1. Type 1: JDBC-ODBC Bridge driver
  2. Type 2: Native-API driver (partly Java driver)
  3. Type 3: Network-Protocol driver (fully Java driver)
  4. Type 4: Thin driver (pure Java driver)
• Type 4 drivers are most commonly used as they are database-specific, entirely written in Java, and provide the best performance.

(d) Function Overloading:

• Function overloading is a feature in Java that allows a class to have multiple methods with the same name but different parameters.
• It's a form of compile-time polymorphism or static polymorphism.
• Methods can be overloaded by changing:
  1. The number of parameters
  2. The data types of parameters
  3. The order of parameters
• Return type alone is not sufficient for overloading; the parameter list must differ.
• It enhances code readability and reusability by allowing related methods to have the same name.
• Example: print(int i), print(double d), print(String s) are overloaded methods.

Question 34. What is a class ? How does it accomplish data hiding ? Explain with an example. (5 Marks)

Answer:

A class in object-oriented programming (OOP) is a blueprint for creating objects (instances), which are instances of the class. It defines the attributes (data) and methods (functions) that the objects of the class will have.

Data hiding, also known as encapsulation, is a key concept in OOP that allows the internal details of a class to be hidden from the outside world. This means that the implementation details of a class are not accessible to code outside the class, which helps in protecting the integrity of the data and prevents unintended modifications.

Here is a java code example for represeting class and data hiding.

public class BankAccount {
    private String accountNumber; // Encapsulated attribute
    private double balance; // Encapsulated attribute

    // Constructor
    public BankAccount(String accountNumber, double balance) {
        this.accountNumber = accountNumber;
        this.balance = balance;
    }

    // Method to deposit money
    public void deposit(double amount) {
        balance += amount;
    }

    // Method to withdraw money
    public void withdraw(double amount) {
        if (amount <= balance) {
            balance -= amount;
        } else {
            System.out.println("Insufficient funds");
        }
    }

    // Getter method for account number (optional)
    public String getAccountNumber() {
        return accountNumber;
    }

    // Getter method for balance (optional)
    public double getBalance() {
        return balance;
    }

    // Main method for example usage
    public static void main(String[] args) {
        BankAccount account1 = new BankAccount("123456789", 1000);
        account1.deposit(500);
        account1.withdraw(200);
        System.out.println(account1.getBalance()); // Output: 1300.0
        System.out.println(account1.getAccountNumber()); // Output: 123456789
    }
}

In this Java example, the BankAccount class has private attributes accountNumber and balance, which are encapsulated within the class. These attributes can only be accessed and modified through the class methods (deposit and withdraw). Additionally, getter methods (getAccountNumber and getBalance) are provided for accessing these attributes from outside the class.

Question 35. Differentiate between AWT and Swing components. Give suitable example for each. (5 Marks)

Answer:

AWT (Abstract Window Toolkit) and Swing are both Java libraries used for creating graphical user interfaces (GUIs). However, they have some differences in terms of functionality and appearance.

AWT -AWT is the original GUI toolkit for Java. The components of AWT are lightweight because they rely on the native platform's GUI components. AWT components have a platform-dependent look and feel. AWT provides fewer components compared to Swing.

Code example of AWT Components -

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

public class AWTButtonExample {
    public static void main(String[] args) {
        Frame frame = new Frame("AWT Button Example");
        Button button = new Button("Click Me");
        button.setBounds(100, 100, 80, 30);
        frame.add(button);
        frame.setSize(300, 200);
        frame.setLayout(null);
        frame.setVisible(true);
    }
}

Swing - it is built on top of AWT but provides a more sophisticated set of GUI components. Components are lightweight, meaning they are not dependent on the native platform's components, resulting in consistent appearance across different platforms. Swing provides a rich set of components, including advanced ones like tables, trees, and tabbed panes.

Example of Swing Components:

import javax.swing.*;

public class SwingButtonExample {
    public static void main(String[] args) {
        JFrame frame = new JFrame("Swing Button Example");
        JButton button = new JButton("Click Me");
        button.setBounds(100, 100, 120, 50);
        frame.add(button);
        frame.setSize(300, 200);
        frame.setLayout(null);
        frame.setVisible(true);
    }
}

Question 36. Explain the relationship between inheritance and polymorphism. Give example of each. (5 Marks)

Answer:

Inheritance and polymorphism are two fundamental concepts in object-oriented programming, and they are closely related.

Inheritance - Inheritance is a mechanism where a new class (subclass or derived class) is created from an existing class (superclass or base class). The subclass inherits the properties and behaviors (methods and fields) of the superclass. It allows code reusability and promotes the concept of "is-a" relationship.

Code Example of Inheritance

// Superclass
class Animal {
    void makeSound() {
        System.out.println("Some generic sound");
    }
}

// Subclass inheriting from Animal
class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("Woof");
    }
}

In this example, Dog is a subclass of Animal. It inherits the makeSound() method from the Animal class and overrides it to provide its own implementation.

Polymorphism - It is the ability of a single interface (or method) to represent multiple underlying implementations. It allows objects of different classes to be treated as objects of a common superclass, leading to code flexibility and extensibility. Polymorphism is achieved through method overriding and method overloading.

Code example of Polymorphism -

class Shape {
    void draw() {
        System.out.println("Drawing a shape");
    }
}

class Circle extends Shape {
    @Override
    void draw() {
        System.out.println("Drawing a circle");
    }
}

class Drawing {
    void drawShape(Shape shape) {
        shape.draw();
    }
}

public class PolymorphismExample {
    public static void main(String[] args) {
        Drawing drawing = new Drawing();
        Shape shape1 = new Shape();
        Shape shape2 = new Circle();
        drawing.drawShape(shape1); // Output: Drawing a shape
        drawing.drawShape(shape2); // Output: Drawing a circle
    }
}

In this example, Shape is a superclass with a method draw(). Circle is a subclass of Shape and overrides the draw() method to draw a circle. The Drawing class demonstrates polymorphism by accepting objects of type Shape and invoking their draw() methods, which are dynamically bound to the appropriate implementation based on the actual object type (Shape or Circle).

Quesiton 37. What is Java Bean ? Briefly discuss the features of Java Bean. (5 Marks)

Answer:

A Java Bean is a reusable software component model for Java. It's a simple, reusable software component that can be manipulated visually in a builder tool. Here are the key features of Java Beans:

Overall, Java Beans provide a standardized way to create reusable components in Java, promoting code reuse, modular design, and interoperability.

Quesiton 38. Explain why main() method is not included in writing a Java applet program using an applet coding.

Answer:

In Java, applets are special types of programs that are designed to be embedded within web pages and executed in a web browser. Unlike standalone Java applications that use the main() method as an entry point, Java applets use a different lifecycle and are loaded, initialized, and executed by the web browser.

Here's why the main() method is not included in writing a Java applet program using applet coding:

Questionn 39. Compare structured programming and object oriented programming. (5 Marks)

Answer:

Structured programming and object-oriented programming (OOP) are two different programming paradigms, each with its own principles, advantages, and use cases. Here's a comparison between the two:

Question 40. Discuss the utility of final and finalize keywords in Java. Give example code for each. (5 Marks)

Answer:

In Java, the final keyword is used to declare constants, mark methods that cannot be overridden, and prevent subclassing. On the other hand, the finalize() method is used for garbage collection, allowing an object to perform any necessary cleanup operations before it is reclaimed by the garbage collector. Let's discuss each in detail with examples:

Final Keyword is used when we declare a variable as final, its value cannot be changed once initialized or a method as final, it cannot be overridden by subclasses or When we declare a class as final, it cannot be subclassed.

Code example for final keyword usage

// Using final for constants
public class ConstantsExample {
    public static final double PI = 3.14159;
    public static final int MAX_SIZE = 100;
    
    public static void main(String[] args) {
        // Trying to reassign a final variable will result in a compilation error
        // PI = 3.14; // Compilation error: cannot assign a value to final variable PI
    }
}


// Using final for methods
class Parent {
    public final void display() {
        System.out.println("This method cannot be overridden.");
    }
}

class Child extends Parent {
    // Trying to override the final method will result in a compilation error
    public void display() {} // Compilation error: display() in Child cannot override display() in Parent
}


// Using final for classes
final class FinalClass {
    // Class implementation
}

// Trying to inherit from a final class will result in a compilation error
class SubClass extends FinalClass {} // Compilation error: cannot inherit from final FinalClass

                        

The finalize() method is called by the garbage collector before reclaiming an object's memory. It's used for cleanup operations or releasing resources. It's generally discouraged to rely on for critical resource cleanup due to uncertainty about when it will be called.

Code example for finalize() method usage

class Resource {
    public void finalize() {
        // Cleanup operations such as closing files or releasing network connections
        System.out.println("Resource cleanup performed.");
    }
}

public class FinalizeExample {
    public static void main(String[] args) {
        Resource resource = new Resource();
        
        // Make the resource eligible for garbage collection
        resource = null;
        
        // Request garbage collection
        System.gc();
        
        // Although we request garbage collection, we can't guarantee when finalize() will be called
        System.out.println("End of main method.");
    }
}

Question 41. How does datagram socket differ from stream socket ? (5 Marks)

Answer:

In Java, DatagramSocket and StreamSocket are two different types of sockets used for communication over a network, each with its own characteristics and usage scenarios. Here's how they differ:

DatagramSocket - It is used for sending and receiving datagrams (packets) over a connectionless protocol such as UDP (User Datagram Protocol). DatagramSocket does not establish a persistent connection between the client and the server. Instead, it sends individual packets of data known as datagrams. it is suitable for scenarios where real-time or loss-tolerant communication is required, such as multimedia streaming, online gaming, or network monitoring. DatagramSocket does not guarantee delivery or order of packets, as it operates in an unreliable manner. It also does not provide error checking or flow control mechanisms.

StreamSocket - it is also known as a TCP socket, is used for establishing a reliable, bidirectional, byte-oriented communication channel between a client and a server. StreamSocket establishes a connection-oriented communication channel between the client and the server before data exchange begins. it ensures reliable data delivery, in-order data transmission, and error detection through mechanisms like sequence numbers, acknowledgment, and retransmission. StreamSocket is suitable for scenarios where data integrity, reliability, and ordered delivery are critical, such as file transfer, web browsing, or client-server applications.

Question 2(a). Write a Java applet to display. “Java is an object oriented programming language” in red color. Support your code with suitable comments. (5 marks)

Answer:

Java applet code to display the text "Java is an object-oriented programming language" in red color:

import java.applet.*;
import java.awt.*;

public class RedTextApplet extends Applet {
    public void paint(Graphics g) {
        // Set the color to red
        g.setColor(Color.RED);
        
        // Set the font size and style
        g.setFont(new Font("Arial", Font.BOLD, 16));
        
        // Draw the text at specified coordinates
        g.drawString("Java is an object-oriented programming language", 20, 20);
    }
}
Explanation: 
The RedTextApplet class extends the Applet class, which is the base class for applets in Java. 
The paint() method is overridden to perform custom drawing operations. Inside the paint() method: 
setColor() method is used to set the drawing color to red. 
setFont() method is used to set the font for drawing the text. In this example, "Arial" font with bold style and size 16 is used. 
drawString() method is used to draw the specified text at the specified coordinates (x=20, y=20). 
When the applet is executed, it will display the text "Java is an object-oriented programming language" in red color at the specified coordinates.

Question 42. What is a layout manager ? Explain the flow layout and border layout. Also explain how a layout is set. (8 marks)

Answer:

Layout manager in Java is responsible for organizing and positioning components within a container. Let's learn more about these two common layout managers: FlowLayout and BorderLayout.

FlowLayout arranges components in a left-to-right, top-to-bottom flow. This means that when one row is filled, the next component moves to the next row. It's handy for dynamically arranging components based on the container's size.

For instance, to use FlowLayout, we can set it by calling setLayout(new FlowLayout()).

On the other hand, BorderLayout divides the container into five regions: North, South, East, West, and Center. Each region can hold only one component, which is stretched to fit the available space within its region. This layout is useful for creating typical application layouts, like having a main content area with optional side panels.

To employ BorderLayout, we set it using setLayout(new BorderLayout()), and then we add components to specific regions using add(component, BorderLayout.NORTH) for example.

Setting a layout is straightforward. We just call the setLayout() method of the container and pass in an instance of the desired layout manager. From then on, any components we add to that container will be arranged according to the rules of the layout manager we've chosen.

Question 43. What are packages in Java ? How do we create a package in Java ? What are the steps to add Classes and Interfaces in a package ? (7 marks)

Answer:

Packages in Java help us organize classes and interfaces into namespaces, providing a way to group related code and avoid naming conflicts. Here's how we can create a package in Java and add classes and interfaces to it:

src/
└── com/
    └── example/
        └── package/

Here's an example of how we can create a simple package and add classes and interfaces to it:

// File: src/com/example/package/MyClass.java
package com.example.package;

public class MyClass {
    // Class implementation
}

// File: src/com/example/package/MyInterface.java
package com.example.package;

public interface MyInterface {
    // Interface methods
}

In this example, MyClass and MyInterface belong to the com.example.package package. We've organized them into the appropriate directory structure under the src directory. This way, we've created a package in Java and added classes and interfaces to it.

Question 44. Differentiate between thread and process. Explain Java thread model using thread life cycle. (7 marks)

Answer:

Differentiating between a thread and a process, a thread represents the smallest unit of execution within a process, while a process is an instance of a running program comprising one or more threads. Threads share the same memory space within a process, enabling communication and cooperation.

In Java, the thread model revolves around the java.lang.Thread class and related APIs. Threads in Java undergo a life cycle with distinct states

To utilize threads in Java, we create instances of the Thread class or implement the Runnable interface. We control thread behavior using methods like start(), join(), sleep(), and wait(), enabling concurrent and parallel execution of tasks within a Java program.

Question 45. Compare Applet and Servlet. Write the steps to incorporate applet in a webpage. (8 marks)

Answer:

Applet- It is a small Java program that runs within a web browser. It is typically used for client-side scripting, providing interactive and dynamic content on a web page. Applets have direct access to the client's system resources, such as the file system and network connections. They are embedded within HTML pages using the <applet> tag.

Servlet-It is a Java program that runs on the server side. It handles client requests and generates dynamic content that is sent back to the client. Servlets run within a servlet container (e.g., Apache Tomcat), which manages their lifecycle and handles communication with clients. Servlets have access to server-side resources and can interact with databases, perform authentication, and more.

Steps to incorporate an applet in a webpage:

Question 46. Explain method overriding in Java using a program in Java. (5 marks)

Answer:

Method overriding in Java allows a subclass to provide a specific implementation of a method that is already defined in its superclass. When a subclass overrides a method, it provides its own implementation of the method, which is used instead of the superclass's implementation when the method is called on an instance of the subclass.

Simple program in java for method overiding:-

class Animal {
    void makeSound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    // Override the makeSound() method
    @Override
    void makeSound() {
        System.out.println("Dog barks");
    }
}

public class MethodOverridingExample {
    public static void main(String[] args) {
        Animal animal = new Animal();
        animal.makeSound(); // Output: Animal makes a sound
        
        Dog dog = new Dog();
        dog.makeSound(); // Output: Dog barks
        
        // Upcasting: Animal reference to Dog object
        Animal anotherDog = new Dog();
        anotherDog.makeSound(); // Output: Dog barks (Dynamic method dispatch)
    }
}

Question 47. Write a Java program for writing files in “C:\javafiles\” location. Support your program with suitable comments. (7 marks)

Answer:

Java program that writes files to the "C:\javafiles" location:

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

public class FileWritingExample {
    public static void main(String[] args) {
        // Specify the directory path
        String directoryPath = "C:\javafiles\";
        
        // Specify the file name
        String fileName = "example.txt";
        
        // Specify the file content
        String fileContent = "This is a sample file content.";

        // Create FileWriter and BufferedWriter objects
        FileWriter fileWriter = null;
        try {
            // Create FileWriter with the specified file path
            fileWriter = new FileWriter(directoryPath + fileName);
            
            // Write the content to the file
            fileWriter.write(fileContent);
            
            // Print success message
            System.out.println("File '" + fileName + "' created successfully at location: " + directoryPath);
        } catch (IOException e) {
            // Handle IO exception
            e.printStackTrace();
        } finally {
            // Close FileWriter to release resources
            try {
                if (fileWriter != null) {
                    fileWriter.close();
                }
            } catch (IOException e) {
                // Handle IO exception
                e.printStackTrace();
            }
        }
    }
}

Quesiton 48. Write the steps of JDBC in establishing a connection for creating dynamic website for INSERT/UPDATE the attendance record for students of a college. (7 Marks)

Answer:

Steps of JDBC in establishing a connection for creating a dynamic website to INSERT/UPDATE the attendance record for students of a college:

• Step 1. Import the necessary JDBC packages, including java.sql.*, to enable JDBC functionality in your Java code.
• Step 2. Load and register the appropriate JDBC driver for the database we are using. Different databases require different JDBC drivers. For example, if we're using MySQL, you would load the MySQL JDBC driver using Class.forName("com.mysql.cj.jdbc.Driver").
• Step 3. Create a connection object using the DriverManager.getConnection() method, passing the database URL, username, and password as parameters. The database URL specifies the location of the database.
• Step 4. Create an SQL statement (INSERT or UPDATE) to perform the desired database operation (e.g., adding or updating attendance records for students).
• Step 5. Execute the SQL statement using the Statement or PreparedStatement object obtained from the connection. If you are executing a parameterized SQL statement, use a PreparedStatement to prevent SQL injection attacks.
• Step 6. If your SQL statement returns a result set (e.g., after executing a SELECT query), use the ResultSet object to process the returned data.
• Step 7. Close all database resources (connection, statement, result set) using the close() method to release database connections and prevent resource leaks.

Question 49. What is synchronization ? Explain how methods are synchronized in Java with the help of an example. (6 Marks)

Answer:

Synchronization in Java is a technique used to control access to shared resources or critical sections of code by multiple threads. It ensures that only one thread can access the shared resource or critical section at a time, preventing concurrent access and potential data corruption or inconsistency.

In Java, methods can be synchronized using the `synchronized` keyword. When a method is declared as synchronized, only one thread can execute that method at a time. Other threads attempting to call the synchronized method must wait until the executing thread releases the lock.

Example demonstrating how methods are synchronized in Java:

public class Counter {
    private int count = 0;

    // Synchronized method to increment the counter
    public synchronized void increment() {
        count++;
    }

    // Synchronized method to decrement the counter
    public synchronized void decrement() {
        count--;
    }

    // Method to get the current value of the counter
    public int getCount() {
        return count;
    }
}

Question 50. Write short notes on the following : 4×5=20 Marks
(a) Object serialization
(b) Liberals and its types
(c) Servlet life cycle
(d) Garbage collection
(e) Role of cookies in session handling

Answer:

(a) Object Serialization: It is the process of converting an object into a byte stream so that it can be persisted to a file, sent over a network, or stored in a database. In Java, serialization is achieved by implementing the Serializable interface. Serialized objects can be deserialized back into Java objects, allowing for the preservation of object state across different executions of a program or during communication between different Java applications.

(b) Libraries and its types: Libraries in software development refer to collections of reusable code modules or functions that provide specific functionalities to developers. There are two main types of libraries:

• Static Libraries, also known as archives, static libraries are collections of precompiled object files (.o files) that are linked with a program at compile time. They are embedded directly into the executable binary and remain fixed once linked.
• Dynamic libraries, also known as shared libraries or DLLs (Dynamic Link Libraries), are loaded into memory only when needed at runtime. They allow for code reuse across multiple applications and facilitate more efficient memory usage by sharing code among different processes.

(c) Servlet Life Cycle:It refers to the sequence of events that occur from the creation to the destruction of a servlet instance within a Java web application. The servlet life cycle consists of several stages:

• Initialization: The servlet container initializes the servlet by calling its init() method. This method is called only once during the servlet's lifetime and is used to perform any necessary initialization tasks.
• Handling Client Requests: Once initialized, the servlet can handle client requests by processing HTTP request messages sent by clients (e.g., web browsers). Each request is processed in a separate thread, allowing the servlet to handle multiple requests concurrently.
• Destroying the Servlet: When the servlet container determines that the servlet is no longer needed (e.g., when the web application is shut down), it calls the servlet's destroy() method to release any allocated resources and perform cleanup tasks.

(d) Garbage Collection:Garbage collection is a memory management technique used in programming languages like Java to automatically reclaim memory occupied by objects that are no longer in use. In Java, the garbage collector periodically identifies and removes unreferenced objects from memory, freeing up space for new objects. The process of garbage collection helps prevent memory leaks and improves the efficiency of memory usage in Java programs.

(e) Role of Cookies in Session Handling:Cookies are small pieces of data sent from a web server to a user's web browser and stored on the user's device. In session handling, cookies play a crucial role in maintaining state information between multiple HTTP requests from the same client. When a user visits a website, the server can create a session and associate it with a unique session identifier (session ID). This session ID is then stored in a cookie and sent back to the client's browser. Subsequent requests from the client include the session ID cookie, allowing the server to retrieve the associated session data and maintain the user's session state across multiple requests. Cookies can also be used to store other types of data, such as user preferences or shopping cart items, for personalized user experiences.