SEBI Grade A IT Notes and Study Material

Worked example: what parameter passing really does in Java

Java

class Box { int v = 1; }

public class Main {
    static void change(Box b) {
        b.v = 2;
        b = new Box();
        b.v = 3;
    }

    public static void main(String[] args) {
        Box x = new Box();
        change(x);
        System.out.println(x.v);
    }
}

What it printed

2

The method gets a copy of the reference. b.v = 2 changes the caller's object. b = new Box() moves only the copy, so the 3 goes to a different object.

Worked example: why NOT IN can return nothing

SQL, run on SQLite

CREATE TABLE dept(id INT, name TEXT);
INSERT INTO dept VALUES (10, 'IT'), (30, 'HR');
CREATE TABLE emp(id INT, dept_id INT);
INSERT INTO emp VALUES (1, 10), (2, 20), (3, NULL);

SELECT COUNT(*), COUNT(dept_id) FROM emp;
SELECT d.name, e.id FROM dept d LEFT JOIN emp e ON e.dept_id = d.id ORDER BY d.id;
SELECT name FROM dept WHERE id NOT IN (SELECT dept_id FROM emp);
SELECT name FROM dept d WHERE NOT EXISTS (SELECT 1 FROM emp e WHERE e.dept_id = d.id);

What it printed

3 | 2
IT | 1
HR | NULL
(no rows)
HR

The NULL in dept_id makes 30 NOT IN (10, 20, NULL) unknown, so the third query returns no rows. NOT EXISTS has no such problem and finds HR.

Sorting algorithms compared

Worked example: where greedy fails on 0/1 knapsack

Python 3

items = [("A", 6, 30), ("B", 5, 20), ("C", 5, 20)]
capacity = 10

# Greedy: highest value per unit of weight first
left, greedy = capacity, 0
for name, w, v in sorted(items, key=lambda i: i[2] / i[1], reverse=True):
    if w <= left:
        left -= w
        greedy += v

# Dynamic programming: each item used at most once
dp = [0] * (capacity + 1)
for name, w, v in items:
    for c in range(capacity, w - 1, -1):
        dp[c] = max(dp[c], dp[c - w] + v)

print("greedy", greedy)
print("dp", dp[capacity])

What it printed

greedy 30
dp 40

Greedy takes A because it has the highest value per unit of weight, and then nothing else fits. The real answer is B and C together.

Common attacks, what they do and the main defence

Worked example: the same login check, unsafe and safe

Python 3 with SQLite

import sqlite3

db = sqlite3.connect(":memory:")
db.execute("CREATE TABLE users(name TEXT, pw TEXT)")
db.execute("INSERT INTO users VALUES ('asha', 's3cret')")

name, pw = "asha", "' OR '1'='1"

unsafe = f"SELECT COUNT(*) FROM users WHERE name='{name}' AND pw='{pw}'"
print(db.execute(unsafe).fetchone()[0])

safe = "SELECT COUNT(*) FROM users WHERE name=? AND pw=?"
print(db.execute(safe, (name, pw)).fetchone()[0])

What it printed

1
0

In the first query the input becomes part of the SQL, so the OR makes the check pass with a wrong password. In the second it stays a plain value, and no row matches.

Worked example: arguments, a function and a loop

sh

is_big() {
    if [ "$1" -gt 5 ]; then
        return 0
    fi
    return 1
}

count=0
for n in "$@"; do
    if is_big "$n"; then
        count=$((count + 1))
    fi
done
echo "args=$# big=$count"

Printed by sh demo.sh 3 7 9

args=3 big=2

return 0 means success, so if treats it as true. Inside the function $1 is the function's own argument, not the script's.

Worked example: what the declared type decides, and what the object decides

Java

class Base {
    String name = "base field";
    Base() { System.out.println("Base constructor"); }
    void show() { System.out.println("Base show"); }
    static void who() { System.out.println("Base static"); }
}

class Child extends Base {
    String name = "child field";
    Child() { System.out.println("Child constructor"); }
    @Override void show() { System.out.println("Child show"); }
    static void who() { System.out.println("Child static"); }
}

public class Main {
    public static void main(String[] args) {
        Base b = new Child();
        b.show();
        b.who();
        System.out.println(b.name);
    }
}

What it printed

Base constructor
Child constructor
Child show
Base static
base field

The object is a Child, so the overridden show runs. The variable's declared type is Base, so it picks the static method and the field.