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

(a) Four Principles of OOP and their Java support (7 marks)

1. Encapsulation — Bundling data (fields) and the methods that operate on them inside a single unit (a class) and hiding the internal state.

• Java support: private/protected access modifiers hide fields; public getter/setter methods control access.

class Account {
    private double balance;            // hidden state
    public double getBalance() { return balance; }
    public void deposit(double a) { if (a > 0) balance += a; }
}

2. Inheritance — A class (subclass) acquires the fields and methods of another class (superclass), enabling code reuse and an is-a relationship.

• Java support: the extends keyword for classes and implements for interfaces; all classes implicitly extend Object.

class SavingsAccount extends Account { double interestRate; }

3. Polymorphism — "Many forms": the same method call behaves differently depending on the object type.

• Java support: compile-time polymorphism via method overloading, and run-time polymorphism via method overriding with dynamic dispatch through a superclass reference.

4. Abstraction — Exposing only essential features while hiding implementation detail.

• Java support: abstract classes and methods, and interface types that declare what a class does without how.

(b) Overloading vs Overriding, super/this, final (8 marks)

class Calc {                       // OVERLOADING
    int add(int a, int b) { return a + b; }
    double add(double a, double b) { return a + b; }
}

class Animal { void sound() { System.out.println("Generic"); } }
class Dog extends Animal {          // OVERRIDING
    @Override void sound() { System.out.println("Bark"); }
}

this keyword — refers to the current object; used to disambiguate fields from parameters (this.x = x), to call another constructor (this(...)), or to pass the current object.

super keyword — refers to the immediate superclass; used to call the superclass constructor super(...), or to invoke an overridden superclass method super.sound().

final modifier:

• On a method — the method cannot be overridden by any subclass.
• On a class — the class cannot be subclassed (e.g. String is final).
• (On a variable it makes it a constant.)

(a) Thread Life Cycle in Java (6 marks)

A Java thread passes through the following states (managed by the JVM scheduler):

   new Thread()        start()           scheduler picks
  ┌─────────┐  ───────► ┌──────────┐  ─────────────► ┌─────────┐
  │   NEW   │           │ RUNNABLE │  ◄───────────── │ RUNNING │
  └─────────┘           └──────────┘   yield/preempt └─────────┘
                            ▲                              │
              notify()/     │  sleep()/wait()/             │ run() ends
              I/O ready/    │  blocked on lock/join        ▼
              timeout       │                         ┌─────────┐
                       ┌─────────────────┐            │  DEAD   │
                       │ BLOCKED/WAITING │            │(TERMIN.)│
                       └─────────────────┘            └─────────┘

• New — the Thread object is created but start() has not yet been called.
• Runnable — after start(); the thread is ready and waiting for CPU from the scheduler.
• Running — the scheduler has selected the thread and run() is executing.
• Blocked / Waiting / Timed-waiting — temporarily inactive, e.g. waiting for a lock, calling wait(), sleep(ms), or join(). It returns to runnable when the condition is satisfied (notify(), lock acquired, timeout, I/O complete).
• Dead / Terminated — run() has finished or the thread was aborted; it cannot be restarted.

(b) Thread Synchronization & Producer–Consumer (9 marks)

Thread synchronization is the mechanism that ensures only one thread accesses a shared resource (critical section) at a time, preventing race conditions and inconsistent data. In Java it is achieved with the synchronized keyword (intrinsic locks/monitors) and inter-thread coordination via wait(), notify() and notifyAll().

import java.util.LinkedList;
import java.util.Queue;

class BoundedBuffer {
    private final Queue<Integer> buf = new LinkedList<>();
    private final int capacity = 5;

    public synchronized void produce(int value) throws InterruptedException {
        while (buf.size() == capacity)   // wait while full
            wait();
        buf.add(value);
        System.out.println("Produced: " + value);
        notifyAll();                     // wake consumers
    }

    public synchronized int consume() throws InterruptedException {
        while (buf.isEmpty())            // wait while empty
            wait();
        int value = buf.poll();
        System.out.println("Consumed: " + value);
        notifyAll();                     // wake producers
        return value;
    }
}

public class ProducerConsumer {
    public static void main(String[] args) {
        BoundedBuffer b = new BoundedBuffer();
        Thread producer = new Thread(() -> {
            try { for (int i = 1; i <= 10; i++) b.produce(i); }
            catch (InterruptedException e) { Thread.currentThread().interrupt(); }
        });
        Thread consumer = new Thread(() -> {
            try { for (int i = 1; i <= 10; i++) b.consume(); }
            catch (InterruptedException e) { Thread.currentThread().interrupt(); }
        });
        producer.start();
        consumer.start();
    }
}

How race conditions are avoided:

• produce() and consume() are synchronized on the same buffer object, so only one thread holds the monitor at a time — no concurrent modification of buf.
• wait() is called inside a while loop (not if) so a thread re-checks the condition after waking, guarding against spurious wake-ups.
• wait() releases the lock while sleeping, letting the partner thread proceed; notifyAll() wakes waiting threads when the buffer state changes, preventing deadlock and lost updates.

(a) Four Types of JDBC Drivers (6 marks)

Type 1 — JDBC-ODBC Bridge Driver

• Translates JDBC calls into ODBC calls.
• Advantage: easy to use, connects to any database with an ODBC source.
• Disadvantage: slow (extra translation layer), platform-dependent, requires ODBC installed; removed in JDK 8.

Type 2 — Native-API (Partly Java) Driver

• Converts JDBC calls into the database vendor's native client API.
• Advantage: faster than Type 1.
• Disadvantage: native client library must be installed on each machine; not fully portable.

Type 3 — Network-Protocol (Middleware) Driver

• Pure Java; sends JDBC calls to a middleware server that talks to the database.
• Advantage: no client-side library, can connect to many databases through one driver.
• Disadvantage: needs an extra middleware/application server tier.

Type 4 — Thin (Pure Java) Driver

• Pure Java; converts JDBC calls directly into the database's network protocol.
• Advantage: fully portable, fastest, no client software needed (most widely used, e.g. MySQL Connector/J).
• Disadvantage: database-specific (a different driver is needed per database vendor).

(b) JDBC Program with PreparedStatement (8 marks)

import java.sql.*;

public class EmployeeList {
    public static void main(String[] args) {
        String url  = "jdbc:mysql://localhost:3306/company";
        String user = "root", pass = "password";
        String sql  = "SELECT empId, name, salary FROM Employee";

        // Step 1: Load driver (optional since JDBC 4.0 auto-loads)
        // Step 2: Establish connection (try-with-resources auto-closes)
        try (Connection con = DriverManager.getConnection(url, user, pass);
             PreparedStatement ps = con.prepareStatement(sql);   // Step 3
             ResultSet rs = ps.executeQuery()) {                 // Step 4

            System.out.printf("%-6s %-15s %-10s%n", "ID", "Name", "Salary");
            while (rs.next()) {                                  // Step 5: process
                System.out.printf("%-6d %-15s %-10.2f%n",
                    rs.getInt("empId"), rs.getString("name"), rs.getDouble("salary"));
            }
        } catch (SQLException e) {                               // Step 6: close is automatic
            e.printStackTrace();
        }
    }
}

Standard JDBC steps: (1) load/register the driver, (2) establish a Connection via DriverManager, (3) create a Statement/PreparedStatement, (4) execute the query to obtain a ResultSet, (5) iterate and process the results, (6) close the resources (here handled automatically by try-with-resources).

Statement vs PreparedStatement:

(a) Java Event Delegation Model (5 marks)

In the delegation event model an event generated by a source is delegated to (handled by) one or more registered listener objects, rather than the source handling it itself. Three participants:

• Event Source — the GUI component that generates the event (e.g. a JButton). It maintains a list of registered listeners and fires events to them via addXxxListener().
• Event Object — an object (e.g. ActionEvent) that encapsulates information about what happened (source, command, timestamp). It is passed to the listener method.
• Event Listener — an object implementing a listener interface (e.g. ActionListener) whose callback method (actionPerformed(ActionEvent e)) contains the response code.

Flow for a button click: user clicks the JButton (source) → an ActionEvent (event object) is created → the JVM invokes actionPerformed() on every registered ActionListener → the listener executes the handling logic.

(b) Swing Login Form (7 marks)

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

public class LoginForm extends JFrame {
    private final JTextField userField = new JTextField(15);
    private final JPasswordField passField = new JPasswordField(15);

    public LoginForm() {
        setTitle("Login");
        setLayout(new GridLayout(3, 2, 5, 5));   // layout manager

        add(new JLabel("Username:"));  add(userField);
        add(new JLabel("Password:"));  add(passField);
        JButton loginBtn = new JButton("Login");
        add(new JLabel());             add(loginBtn);

        loginBtn.addActionListener(new ActionListener() {   // register listener
            public void actionPerformed(ActionEvent e) {
                String u = userField.getText();
                String p = new String(passField.getPassword());
                if (u.equals("admin") && p.equals("1234"))    // hard-coded valid pair
                    JOptionPane.showMessageDialog(LoginForm.this, "Login Successful!");
                else
                    JOptionPane.showMessageDialog(LoginForm.this, "Invalid Credentials!",
                        "Error", JOptionPane.ERROR_MESSAGE);
            }
        });

        setSize(300, 150);
        setDefaultCloseOperation(EXIT_ON_CLOSE);
        setVisible(true);
    }

    public static void main(String[] args) {
        SwingUtilities.invokeLater(LoginForm::new);
    }
}

Here the JButton is the event source, the ActionListener is the listener registered with addActionListener, and ActionEvent e is the event object; the GridLayout arranges the labels, fields and button in a neat 3×2 grid.

Checked vs Unchecked Exceptions

Exception-handling constructs

• try — encloses the code that may throw an exception.
• catch — handles a specific exception type thrown from the try block.
• finally — always executes (whether or not an exception occurs), used for cleanup such as closing files/connections.
• throw — explicitly throws an exception object: throw new XxxException(...).
• throws — declares in a method signature the checked exceptions the method may propagate to its caller.

Custom Exception Program

class InvalidAgeException extends Exception {     // user-defined checked exception
    public InvalidAgeException(String msg) { super(msg); }
}

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

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

Output: Caught: Age 15 is below 18 — not eligible then Validation complete.

Java Collections Framework Hierarchy

The framework is rooted at the Iterable → Collection interface, which branches into:

            Iterable
               │
          Collection ───────────────┐
        ┌──────┼───────┐            (Map is separate)
      List    Set     Queue            Map
     (Array   (Hash   (Linked     (HashMap, TreeMap,
      List,    Set,    List,        LinkedHashMap,
      Linked   TreeSet) PriorityQ)  Hashtable)
      List,    Linked
      Vector)  HashSet)

• List — ordered, allows duplicates, index-based.
• Set — no duplicates.
• Queue — FIFO/priority ordering.
• Map — key→value pairs (does not extend Collection).

ArrayList vs LinkedList

HashMap vs TreeMap

Iterator over a generic List

List<String> names = new ArrayList<>(List.of("Asha", "Bibek", "Chandra"));
Iterator<String> it = names.iterator();
while (it.hasNext()) {
    String name = it.next();
    System.out.println(name);
}

TCP vs UDP in Java

TCP Echo Server and Client

Server (EchoServer.java):

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

public class EchoServer {
    public static void main(String[] args) throws IOException {
        ServerSocket server = new ServerSocket(5000);
        System.out.println("Server listening on port 5000...");
        Socket client = server.accept();                 // wait for client

        BufferedReader in = new BufferedReader(
                new InputStreamReader(client.getInputStream()));
        PrintWriter out = new PrintWriter(client.getOutputStream(), true);

        String msg;
        while ((msg = in.readLine()) != null) {
            System.out.println("Received: " + msg);
            out.println("Echo: " + msg);                 // echo back
        }
        client.close();
        server.close();
    }
}

Client (EchoClient.java):

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

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

        String line;
        while ((line = console.readLine()) != null) {
            out.println(line);                           // send to server
            System.out.println("Server says: " + in.readLine());
        }
        socket.close();
    }
}

The server creates a ServerSocket and blocks on accept(); the client creates a Socket to connect; messages flow over the input/output streams and the server echoes each line back.

Servlet Life Cycle

A servlet is managed by the servlet container (web server) through three life-cycle methods:

1. init(ServletConfig config) — Called once, when the servlet is first loaded/instantiated. Used for one-time setup such as opening database connections or reading configuration.
2. service(ServletRequest req, ServletResponse res) — Called for every client request. The container creates a new thread per request and dispatches to doGet(), doPost(), etc. This is where the request is processed and the response generated.
3. destroy() — Called once, before the servlet is unloaded/the container shuts down. Used to release resources (close connections, save state).

Load → init() [once] → service() [per request, many times] → destroy() [once] → unload

Servlet vs JSP

When a JSP becomes a servlet: at the first request (or at deployment if pre-compiled), the container's JSP engine translates the .jsp file into an equivalent Java servlet source file, then compiles it into a .class. This compiled servlet then follows the normal servlet life cycle (init → service → destroy). Thus a JSP is ultimately a servlet in disguise.

String vs StringBuffer vs StringBuilder

Why String is immutable

Once a String object is created, its character contents cannot be changed; any "modifying" method (e.g. concat, replace) returns a new String object. Reasons for immutability:

• Security — strings are used for file paths, URLs, DB credentials; immutability prevents tampering.
• String pool sharing — multiple references can safely share the same literal.
• Thread safety — immutable objects need no synchronization.
• Hashcode caching — safe to cache the hashcode, making String efficient as a HashMap key.

String Constant Pool

The string constant pool is a special region of the heap where the JVM stores unique string literals. When a literal like "hello" is created, the JVM checks the pool; if it already exists, the same reference is reused instead of creating a new object — saving memory.

String a = "hello";
String b = "hello";       // refers to the SAME pooled object
System.out.println(a == b);            // true
String c = new String("hello");        // new object on heap (not pooled)
System.out.println(a == c);            // false

Creating a Thread: Thread class vs Runnable interface

1. Extending the Thread class

class MyThread extends Thread {
    public void run() { System.out.println("Running via Thread"); }
}
// usage: new MyThread().start();

2. Implementing the Runnable interface

class MyTask implements Runnable {
    public void run() { System.out.println("Running via Runnable"); }
}
// usage: new Thread(new MyTask()).start();

Preferred approach: implementing Runnable.

Justification: Java allows only single inheritance, so extending Thread blocks the class from extending any other class, whereas a class can implement Runnable and still extend another class. Runnable also cleanly separates the task (what to run) from the thread (how to run it), and is the form required by the ExecutorService thread-pool API and lambdas:

Runnable r = () -> System.out.println("Lambda task");
new Thread(r).start();

Role of the ResultSet Interface

ResultSet represents the table of data returned by executing a SQL query (typically a SELECT). It acts as a cursor pointing to a row of the result; methods like next() advance the cursor and getXxx("column") retrieve column values of the current row. It is obtained from Statement.executeQuery() or PreparedStatement.executeQuery().

Forward-only vs Scrollable ResultSet

TYPE_SCROLL_INSENSITIVE does not reflect later DB changes; TYPE_SCROLL_SENSITIVE does.

Updating a column via an Updatable ResultSet

To update through the result set, request CONCUR_UPDATABLE concurrency:

Statement st = con.createStatement(
        ResultSet.TYPE_SCROLL_SENSITIVE,
        ResultSet.CONCUR_UPDATABLE);
ResultSet rs = st.executeQuery("SELECT empId, salary FROM Employee");

while (rs.next()) {
    if (rs.getInt("empId") == 101) {
        rs.updateDouble("salary", 75000.0);   // change column value
        rs.updateRow();                        // commit change to DB
    }
}

Abstract Class vs Interface

Use an abstract class when classes share common state/implementation; use an interface to define a contract that unrelated classes can fulfil.

Evolution of Interfaces since Java 8

Before Java 8 an interface could contain only abstract methods (and constants). Since Java 8 interfaces may contain:

• default methods — methods with a body, so new methods can be added to an interface without breaking existing implementing classes; subclasses inherit the default unless they override it.
• static methods — utility methods called on the interface itself.
• (Java 9 further added private interface methods to share code between defaults.)

interface Vehicle {
    void start();                                  // abstract
    default void honk() { System.out.println("Beep!"); }   // default method
    static int wheels() { return 4; }              // static method
}

This blurred the line between interfaces and abstract classes, though interfaces still cannot hold mutable instance state.