BUET M.Sc. Admission — Department of ICT — May: 2019প্রশ্ন ও সমাধান

A non-static inner class cannot be instantiated on its own — it needs an existing instance of its enclosing (outer) class, because every inner-class object implicitly holds a reference back to the outer object that created it.

class Outer {
    int x = 10;
    class Inner {              // non-static inner class
        void show() {
            System.out.println("Outer x = " + x);   // can access outer's members directly
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Outer outer = new Outer();          // step 1: create outer instance
        Outer.Inner inner = outer.new Inner();  // step 2: create inner via outer instance
        inner.show();
    }
}

Output: Outer x = 10

Two ways, depending on the inner class's kind:

Kind	Instantiation syntax	Needs outer instance?
Non-static inner class	Outer.Inner obj = outerObj.new Inner();	Yes
Static nested class	Outer.Inner obj = new Outer.Inner();	No

classDiagram
    class Outer { +int x }
    class Inner { +show() }
    Outer *-- Inner : outer.new Inner()

• The outerObj.new Inner() syntax exists precisely because a non-static inner class instance carries a hidden reference to its enclosing instance (accessible internally as Outer.this), letting it freely use the outer object's fields/methods (as show() does with x above).

Exam takeaway: new Inner() alone fails to compile for a non-static inner class — always instantiate as outerInstance.new InnerClass(), unless the inner class is declared static, in which case it behaves like a top-level class.

Unit testing verifies the smallest testable piece of code (a single function/method/class) in isolation; acceptance testing verifies the whole system against business/user requirements — they sit at opposite ends of the testing pyramid.

Aspect	Unit Testing	Acceptance Testing
Scope	Single function/method/class	Entire system/feature end-to-end
Performed by	Developers	Client/end-users/QA (with business input)
When	During coding, continuously	Near the end, before release
Goal	Code behaves correctly in isolation	System meets business requirements
Tools (example)	JUnit, pytest, Google Test	Manual UAT scripts, Selenium/Cucumber
Failure means	A logic bug in that unit	The product doesn't satisfy what was asked for

graph TD
    U[Unit Tests - individual functions] --> I[Integration Tests - modules together]
    I --> S[System Tests - whole application]
    S --> A[Acceptance Tests - business requirements]

Worked examples:

• Unit test: for a function add(a, b), assert add(2, 3) == 5 — tests only that one function, with all dependencies mocked/stubbed out.
• Acceptance test: for an e-commerce checkout feature, a tester (or the client) walks through "add item to cart -> pay -> receive order confirmation" exactly as a real customer would, and signs off only if the complete business flow works as specified in the requirements document.

Exam takeaway: unit testing answers "is this piece of code built correctly?" (verification); acceptance testing answers "did we build the right product for the customer?" (validation) — both are essential but check fundamentally different things.