BE Computer Engineering (Pokhara University) Advanced Programming with Java (PU, CMP 228) Question Paper 2078 Nepal

(a) Method Overloading vs Method Overriding (5)

Overloading example:

class Calc {
    int add(int a, int b) { return a + b; }
    double add(double a, double b) { return a + b; }   // different param types
    int add(int a, int b, int c) { return a + b + c; } // different param count
}

Overriding example:

class Animal {
    void sound() { System.out.println("Some sound"); }
}
class Dog extends Animal {
    @Override
    void sound() { System.out.println("Bark"); }   // redefines parent method
}

(b) Four Pillars of OOP + Abstract Shape Program (7)

1. Encapsulation — Binding data (fields) and the methods that operate on them into a single unit (class) and hiding internal state using private fields exposed through getters/setters.

2. Inheritance — A subclass acquires the fields and methods of a superclass using extends, promoting code reuse and an IS-A relationship.

3. Polymorphism — "One name, many forms." A superclass reference can refer to subclass objects, and the correct overridden method is chosen at runtime.

4. Abstraction — Showing only essential features while hiding implementation details, achieved through abstract classes and interfaces.

abstract class Shape {
    abstract double area();              // abstract method, no body
    void describe() {
        System.out.println("Area = " + area());
    }
}

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

class Rectangle extends Shape {
    private double l, b;
    Rectangle(double l, double b) { this.l = l; this.b = b; }
    @Override
    double area() { return l * b; }
}

public class Main {
    public static void main(String[] args) {
        Shape s;                 // reference of type Shape
        s = new Circle(5);       // runtime polymorphism
        s.describe();            // calls Circle.area()  -> 78.54
        s = new Rectangle(4, 6);
        s.describe();            // calls Rectangle.area() -> 24.0
    }
}

The single Shape reference s invokes different area() implementations at runtime, demonstrating runtime (dynamic) polymorphism.

(a) Life Cycle of a Thread (4)

A Java thread passes through the following states (defined in Thread.State):

1. New — Thread object created (new Thread()) but start() not yet called.
2. Runnable — After start() is called; the thread is ready and waiting for CPU scheduling (includes "ready" and "running").
3. Running — The thread scheduler picks the thread and it executes run().
4. Blocked / Waiting / Timed-Waiting — Thread temporarily inactive: waiting for a lock (Blocked), waiting indefinitely via wait()/join() (Waiting), or waiting for a time via sleep(ms)/wait(ms) (Timed-Waiting).
5. Terminated (Dead) — run() completes or the thread is stopped; it cannot be restarted.

State-transition diagram (described):

  New --start()--> Runnable <----> Running --run() ends--> Terminated
                      ^   |
                      |   |  sleep()/wait()/lock unavailable
                      |   v
          notify()/timeout/  Blocked / Waiting / Timed-Waiting
          lock acquired

(b) Thread Class vs Runnable Interface (4)

Preferred: Runnable, because Java allows only single class inheritance, so implementing Runnable keeps the class free to extend another class, separates the task from the thread, and works seamlessly with ExecutorService thread pools.

(c) Race Condition + Synchronized Bank Account (6)

A race condition occurs when two or more threads access and modify shared data concurrently and the final result depends on the unpredictable order of execution, producing inconsistent values. It is prevented by allowing only one thread into the critical section at a time using synchronized.

class BankAccount {
    private int balance = 1000;

    // synchronized: only one thread can withdraw at a time
    synchronized void withdraw(int amount) {
        if (balance >= amount) {
            System.out.println(Thread.currentThread().getName() + " withdrawing " + amount);
            balance -= amount;
            System.out.println("Remaining balance: " + balance);
        } else {
            System.out.println(Thread.currentThread().getName() + ": Insufficient funds");
        }
    }
}

public class BankDemo {
    public static void main(String[] args) {
        BankAccount acc = new BankAccount();
        Runnable task = () -> {
            for (int i = 0; i < 3; i++) acc.withdraw(200);
        };
        Thread t1 = new Thread(task, "T1");
        Thread t2 = new Thread(task, "T2");
        t1.start();
        t2.start();
    }
}

The synchronized keyword serialises access to withdraw(), so the balance check and update happen atomically and the account never goes negative.

(a) Steps to Connect a Java Program to a Database using JDBC (4)

1. Load/register the driver — Class.forName("com.mysql.cj.jdbc.Driver") (auto-loaded in JDBC 4+).
2. Establish a connection — Connection con = DriverManager.getConnection(url, user, password);
3. Create a statement — Statement / PreparedStatement / CallableStatement object from the connection.
4. Execute the query — executeQuery() for SELECT (returns ResultSet) or executeUpdate() for INSERT/UPDATE/DELETE.
5. Process the ResultSet — iterate with rs.next() and read columns.
6. Close the resources — close ResultSet, Statement, and Connection (or use try-with-resources).

(b) Statement vs PreparedStatement vs CallableStatement (4)

Why PreparedStatement prevents SQL injection: Parameters are bound as typed values (setString, setInt) rather than concatenated into the SQL text, so malicious input such as ' OR '1'='1 is treated as literal data, not executable SQL.

(c) JDBC Program for Student Table (4)

import java.sql.*;

public class StudentJDBC {
    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/school";
        String user = "root", pass = "password";

        try (Connection con = DriverManager.getConnection(url, user, pass)) {

            // Insert a new record
            String ins = "INSERT INTO Student(roll, name, marks) VALUES (?, ?, ?)";
            try (PreparedStatement ps = con.prepareStatement(ins)) {
                ps.setInt(1, 101);
                ps.setString(2, "Ram");
                ps.setInt(3, 75);
                ps.executeUpdate();
            }

            // Retrieve students with marks > 60
            String sel = "SELECT roll, name, marks FROM Student WHERE marks > ?";
            try (PreparedStatement ps = con.prepareStatement(sel)) {
                ps.setInt(1, 60);
                ResultSet rs = ps.executeQuery();
                System.out.println("Roll\tName\tMarks");
                while (rs.next()) {
                    System.out.println(rs.getInt("roll") + "\t"
                        + rs.getString("name") + "\t" + rs.getInt("marks"));
                }
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

(a) Delegation Event Model (4)

The delegation event model is the standard mechanism by which Java handles events (since JDK 1.1). An event generated by a source is delegated to one or more registered listener objects that handle it. It has three participants:

• Event Source — The GUI component (e.g. a JButton) on which the event occurs. It maintains a list of registered listeners and creates an event object when acted upon.
• Event Object — An object (e.g. ActionEvent) that encapsulates information about the event (source, type, coordinates, etc.) and is passed to the listener.
• Event Listener — An object that implements a listener interface (e.g. ActionListener) and contains the handler method (e.g. actionPerformed()) invoked when the event occurs.

Flow: A listener registers with the source using addActionListener(listener). When the user acts, the source creates an event object and calls the listener's handler method, passing the event object.

(b) Swing Login Form (6)

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

public class LoginForm extends JFrame implements ActionListener {
    JTextField userField = new JTextField(15);
    JPasswordField passField = new JPasswordField(15);
    JButton loginBtn = new JButton("Login");
    JLabel result = new JLabel("");

    LoginForm() {
        setLayout(null);
        JLabel u = new JLabel("Username:"); u.setBounds(30, 30, 80, 25);
        JLabel p = new JLabel("Password:"); p.setBounds(30, 70, 80, 25);
        userField.setBounds(120, 30, 150, 25);
        passField.setBounds(120, 70, 150, 25);
        loginBtn.setBounds(120, 110, 90, 30);
        result.setBounds(30, 150, 250, 25);

        add(u); add(p); add(userField); add(passField); add(loginBtn); add(result);
        loginBtn.addActionListener(this);   // register listener

        setSize(320, 230);
        setDefaultCloseOperation(EXIT_ON_CLOSE);
        setVisible(true);
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        String user = userField.getText();
        String pass = new String(passField.getPassword());
        if (user.equals("admin") && pass.equals("1234"))
            result.setText("Login Successful");
        else
            result.setText("Invalid Credentials");
    }

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

The loginBtn is the event source, this (the ActionListener) is the listener, and ActionEvent e is the event object delivered to actionPerformed().

(a) Checked vs Unchecked Exceptions (3)

(b) try / catch / finally / throw + Custom Exception (5)

• try — Encloses code that may throw an exception.
• catch — Handles a specific exception thrown inside the try block.
• finally — Always executes (whether or not an exception occurs); used for cleanup such as closing resources.
• throw — Used to explicitly throw an exception object.

class InvalidAgeException extends Exception {
    InvalidAgeException(String msg) { super(msg); }
}

public class AgeTest {
    static void validate(int age) throws InvalidAgeException {
        if (age < 18)
            throw new InvalidAgeException("Age " + age + " is below 18 — not eligible");
        System.out.println("Valid age: " + age);
    }

    public static void main(String[] args) {
        try {
            validate(15);
        } catch (InvalidAgeException e) {
            System.out.println("Caught: " + e.getMessage());
        } finally {
            System.out.println("Validation finished");
        }
    }
}

Output:

Caught: Age 15 is below 18 — not eligible
Validation finished

(a) ArrayList vs LinkedList (3)

Summary: Use ArrayList for frequent random access/reads; use LinkedList for frequent insertions/deletions.

(b) ArrayList -> HashSet -> TreeSet Program (5)

import java.util.*;

public class UniqueNames {
    public static void main(String[] args) {
        // 1. Store names (with duplicates) in an ArrayList
        ArrayList<String> names = new ArrayList<>(
            Arrays.asList("Sita", "Ram", "Hari", "Sita", "Ram", "Gita"));

        // 2. Remove duplicates using a HashSet
        HashSet<String> set = new HashSet<>(names);

        // 3. Sort by inserting into a TreeSet (natural ordering)
        TreeSet<String> sorted = new TreeSet<>(set);

        System.out.println("Unique sorted names: " + sorted);
    }
}

Output:

Unique sorted names: [Gita, Hari, Ram, Sita]

HashSet discards duplicates; TreeSet stores the unique names in ascending (natural) sorted order.

(a) TCP vs UDP in Java (3)

(b) TCP Echo Client-Server (5)

Server:

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

public class EchoServer {
    public static void main(String[] args) throws IOException {
        ServerSocket ss = new ServerSocket(5000);
        System.out.println("Server waiting...");
        Socket s = ss.accept();
        BufferedReader in = new BufferedReader(new InputStreamReader(s.getInputStream()));
        PrintWriter out = new PrintWriter(s.getOutputStream(), true);

        String msg = in.readLine();
        System.out.println("Received: " + msg);
        out.println(msg);              // echo back
        s.close(); ss.close();
    }
}

Client:

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

public class EchoClient {
    public static void main(String[] args) throws IOException {
        Socket s = new Socket("localhost", 5000);
        PrintWriter out = new PrintWriter(s.getOutputStream(), true);
        BufferedReader in = new BufferedReader(new InputStreamReader(s.getInputStream()));

        out.println("Hello Server");           // send
        System.out.println("Echo: " + in.readLine());  // receive echo
        s.close();
    }
}

Run the server first, then the client; the client prints Echo: Hello Server.

(a) Servlet Life Cycle (3)

The servlet container (web server) manages a servlet through three life-cycle methods:

1. init() — Called once when the servlet is first loaded/instantiated. Used for one-time initialisation (e.g. opening a DB connection).
2. service() — Called for every client request. It examines the HTTP method and dispatches to doGet(), doPost(), etc. Runs in a separate thread per request.
3. destroy() — Called once before the servlet is unloaded/removed. Used to release resources (close connections, save state).

Flow: Loading & Instantiation -> init() -> service() (repeated per request) -> destroy().

(b) Servlet vs JSP (3)

Two advantages of JSP over servlets:

1. Easier presentation — HTML is written directly, so designing the view is simpler and more readable.
2. Automatic recompilation / separation of concerns — JSP pages are auto-translated and recompiled when changed, and they cleanly separate presentation from logic (especially with tags/EL).

(a) String vs StringBuffer vs StringBuilder (3)

(b) Palindrome Check Without Built-in Reverse (3)

import java.util.Scanner;

public class Palindrome {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter a string: ");
        String str = sc.nextLine();

        boolean isPalindrome = true;
        int i = 0, j = str.length() - 1;
        while (i < j) {
            if (str.charAt(i) != str.charAt(j)) {
                isPalindrome = false;
                break;
            }
            i++; j--;
        }

        System.out.println(str + (isPalindrome ? " is a palindrome" : " is not a palindrome"));
    }
}

The two pointers move inward comparing characters from both ends; if all matching pairs are equal, the string is a palindrome (e.g. madam -> palindrome).

(a) Inter-Thread Communication (3)

Inter-thread communication is a mechanism that lets synchronized threads cooperate by signalling one another, so a thread can pause and let another proceed instead of busy-waiting. It uses three methods of Object, called from within a synchronized block/method:

• wait() — Causes the current thread to release the lock and wait until another thread calls notify()/notifyAll() on the same object.
• notify() — Wakes up one waiting thread on that object's monitor.
• notifyAll() — Wakes up all threads waiting on that object's monitor (they then compete for the lock).

(b) Producer-Consumer Problem (3)

The producer-consumer problem is a classic synchronization problem involving a shared, bounded buffer:

• The producer generates data and places it into the buffer.
• The consumer removes and uses data from the buffer.

The challenge: the producer must wait when the buffer is full, and the consumer must wait when the buffer is empty, while both access the buffer safely.

Java solution: Use a synchronized shared buffer with wait() and notify(). The producer calls wait() when full and notify() after producing; the consumer calls wait() when empty and notify() after consuming. Alternatively, use a thread-safe BlockingQueue (e.g. ArrayBlockingQueue) whose put()/take() methods handle the blocking automatically.

(Write any two of the following.)

(a) Layout Managers in Swing (3)

A layout manager automatically arranges components inside a container, adapting to size changes.

• FlowLayout — Places components left-to-right in a row (like words in a line), wrapping to the next line when full. Default for JPanel.
• BorderLayout — Divides the container into five regions: NORTH, SOUTH, EAST, WEST, CENTER; each holds one component, with CENTER taking the remaining space. Default for JFrame.
• GridLayout — Arranges components in a grid of equal-sized cells (rows × columns), each component filling one cell.

(b) Difference between AWT and Swing (3)

(c) Stage, Scene, and Node Hierarchy in JavaFX (3)

JavaFX GUIs follow a theatre metaphor:

• Stage — The top-level container / window of the application (created by the runtime and passed to start(Stage)). One application can have multiple stages.
• Scene — The container for all visual content displayed on a stage. A stage shows one scene at a time; set with stage.setScene(scene).
• Node — Every visual element (button, label, shape, layout pane) is a Node. Nodes are organised in a scene graph, a tree whose root node is attached to the scene; parent nodes (layout panes) contain child nodes.

Hierarchy: Stage -> Scene -> root Node -> child Nodes (scene graph).