Java

Java has two kinds of types: primitives and reference types.

• Primitives hold the value directly and are copied on assignment: int, long, double, float, boolean, char, byte, short.
• Reference types (objects, arrays, String) hold a reference to data on the heap; assigning copies the reference, so both variables point at the same object.
• Each primitive has a wrapper class (int↔Integer, boolean↔Boolean) for use in generics/collections. Converting between them is autoboxing / unboxing.

int a = 1; int b = a; b = 9;            // a stays 1 (value copied)

int[] x = { 1 }; int[] y = x; y[0] = 9; // x[0] is now 9 (same array)

List<Integer> nums = new ArrayList<>();
nums.add(5);                            // autobox: int -> Integer

Access modifiers — who can see a member:

• public — anywhere.
• private — only inside the same class.
• protected — same package + subclasses.
• (no modifier) — package-private: visible only within the same package. This is the default.

Other key modifiers:

• static — belongs to the class, not an instance.
• final — can't change: a final variable is a constant, a final method can't be overridden, a final class can't be subclassed.
• abstract — no body; a subclass must implement it.

• Encapsulation — private fields + public getters/setters.
• Inheritance — extends one class; prefer composition over deep hierarchies.
• Polymorphism — overriding (runtime) vs overloading (compile-time).
• Abstraction — abstract classes and interfaces hide detail behind a contract.

abstract class Shape {                  // shared base
    abstract double area();             // no body -> subclass must implement
}
interface Drawable {                    // capability
    void draw();
}

// extend ONE class, implement MANY interfaces
class Circle extends Shape implements Drawable {
    final double r;
    Circle(double r) { this.r = r; }
    @Override double area() { return Math.PI * r * r; }
    @Override public void draw() { System.out.println("O r=" + r); }
}

String is a reference type but immutable — once created it never changes. Every "modification" returns a new String and leaves the original alone.

String s = "hello";
s.toUpperCase();      // returns "HELLO" but s is STILL "hello"
s = s.toUpperCase();  // reassign to keep the result

Why immutable? Thread-safety, safe use as HashMap keys (a stable hashCode), and the String pool — identical literals are interned and shared.

String a = "hi", b = "hi";
a == b;                 // true  -> same pooled object
new String("hi") == a;  // false -> a brand-new object
a.equals(b);            // true  -> ALWAYS compare strings with equals()

Building a string in a loop creates a new object each pass. Use StringBuilder (or StringBuffer when thread-safe).

StringBuilder sb = new StringBuilder();
for (String row : rows) sb.append(row).append('\n');
String out = sb.toString();   // one final allocation

Everything sits under List, Set, Map, or Queue:

• List = ordered, duplicates allowed.
• Set = no duplicates.
• Map = key/value pairs.

Used most in practice: ArrayList for ordered lists and HashMap for key lookups.

List<String> names = new ArrayList<>();
names.add("Ada");
boolean has = names.contains("Ada");

Map<String, Integer> ages = new HashMap<>();
ages.put("Ada", 36);
ages.getOrDefault("Bob", 0);          // safe read, no null
ages.merge("Ada", 1, Integer::sum);   // count / increment

Two kinds:

• Checked — must be handled or declared with throws (e.g. IOException); enforced at compile time.
• Unchecked — RuntimeExceptions like NullPointerException, IllegalArgumentException; not enforced.

• try / catch / finally — finally always runs.
• try-with-resources auto-closes anything AutoCloseable, even on exception.
• throw raises an exception; throws declares one a method may propagate.

// try / catch / finally
try {
    int x = Integer.parseInt(input);
} catch (NumberFormatException e) {
    System.out.println("not a number");
} finally {
    System.out.println("always runs");
}

// try-with-resources: reader closed automatically
try (BufferedReader r = new BufferedReader(new FileReader("data.csv"))) {
    return r.readLine();
} catch (IOException e) {
    throw new RuntimeException("read failed", e);  // wrap, keep the cause
}

Generics add compile-time type safety and remove casts: a List<String> can only hold Strings.

Streams (Java 8+) process a collection as a pipeline: source → intermediate ops (lazy) → one terminal op. Nothing runs until the terminal op.

List<String> names = people.stream()
    .filter(p -> p.getAge() > 18)   // keep adults
    .map(Person::getName)           // transform
    .sorted()
    .collect(Collectors.toList());  // terminal op

long adults = people.stream().filter(p -> p.getAge() > 18).count();

Map<String, List<Person>> byDept = people.stream()
    .collect(Collectors.groupingBy(Person::getDept));

Optional<T> models "maybe a value" and avoids null checks: opt.map(...).orElse(default).

• JUnit 5 — @Test, @BeforeEach/@AfterEach, @BeforeAll/@AfterAll, @ParameterizedTest, @DisplayName, assertions, and a flexible extensions model.
• TestNG — groups, data providers, dependencies, flexible parallel config, suite XML; common in Selenium frameworks.
• Mockito — mock/stub dependencies; verify interactions.
• AssertJ / Hamcrest — fluent, readable assertions.
• Maven / Gradle — build & dependency management; Surefire/Failsafe run tests in CI.

@ParameterizedTest
@CsvSource({ "2,4", "3,9", "5,25" })
void squares(int in, int expected) {
    assertEquals(expected, in * in);
}

@Test
void usesMock() {
    UserRepo repo = mock(UserRepo.class);
    when(repo.find(1)).thenReturn(new User(1, "Ada"));
    assertEquals("Ada", new UserService(repo).nameOf(1));
    verify(repo).find(1);
}