Bangladesh Bank; Assistant Programmer Written Test: 2016প্রশ্ন ও সমাধান

Polymorphism ("many forms") is the OOP principle that lets the same interface — a method name or operator — behave differently depending on the object or arguments involved. It comes in two flavours:

• Compile-time (static) polymorphism — method overloading: multiple methods share a name in the same class but differ in parameter list; the compiler resolves which one to call.
• Run-time (dynamic) polymorphism — method overriding: a subclass supplies its own implementation of a method already defined in its superclass; the JVM/runtime resolves which version to call based on the actual object type.

Aspect	Overloading	Overriding
Classes	Same class	Parent and child
Signature	Differs (params)	Identical
Resolved	Compile-time	Run-time
Also called	Static/early binding	Dynamic/late binding

class Shape {
    double area() { return 0; }
}
class Circle extends Shape {
    double r;
    Circle(double r) { this.r = r; }
    @Override
    double area() { return Math.PI * r * r; }   // overriding
}
class Calc {
    int sum(int a, int b) { return a + b; }
    double sum(double a, double b) { return a + b; } // overloading
}

Exam takeaway: polymorphism = one interface, many implementations; overloading picks the version at compile time by signature, overriding picks it at run time by actual object type.

Integrity rules are constraints a relational database enforces so that stored data remains accurate and consistent:

1. Entity integrity: every table must have a primary key, and that key's value can never be NULL — it uniquely identifies each row.
2. Referential integrity: a foreign key value must either match an existing primary key value in the referenced table or be NULL — no row may reference a non-existent parent.
3. Domain integrity: every column's value must respect its declared data type, format, and constraints (e.g. CHECK, NOT NULL, valid range).

SQL — second highest salary from Employee:

-- Method 1: subquery
SELECT MAX(salary) AS second_highest
FROM   Employee
WHERE  salary < (SELECT MAX(salary) FROM Employee);

-- Method 2: window function (handles ties cleanly)
SELECT salary AS second_highest
FROM (
    SELECT salary, DENSE_RANK() OVER (ORDER BY salary DESC) AS rnk
    FROM   Employee
) ranked
WHERE rnk = 2
LIMIT 1;

How it works: Method 1 excludes the overall maximum, then re-applies MAX() to what remains — leaving exactly the second-highest value. Method 2 ranks all salaries in descending order and picks the row ranked 2, correctly handling duplicate top salaries.

Exam takeaway: entity, referential, and domain integrity are the three classic integrity rules; for "Nth highest" queries, DENSE_RANK() is the most robust general solution.