:PROPERTIES:
:ID:       5cfd7f6f-f5ac-4f18-90f9-be9a31dd238e
:END:
#+title: java-portswrigger-test
#+filetags: :java:notes:interview:


* Latest
** Java concepts:
# Java Core Language - Concise Reference Guide

## 1. Object-Oriented Programming Concepts

### Inheritance
- **Definition**: Mechanism where a class inherits properties and behaviors from another class
- **Syntax**: `public class Child extends Parent { }`
- **Types**: Single, Multilevel, Hierarchical
- **'super' keyword**: Refers to parent class objects/constructors
- **Method Overriding**: Child classes can provide specific implementation of methods

### Encapsulation
- **Definition**: Bundling data and methods that operate on the data within a single unit
- **Implementation**: Using private fields with public getters/setters
- **Benefits**: Hides implementation details, controls access, reduces code coupling
```java
public class Account {
    private double balance;
    
    public double getBalance() {
        return balance;
    }
    
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }
}
```

### Polymorphism
- **Definition**: Ability of objects to take different forms
- **Types**:
  - **Compile-time (Method Overloading)**: Multiple methods with same name but different parameters
  - **Runtime (Method Overriding)**: Subclass implementing parent class method
- **Example**:
```java
class Animal {
    void makeSound() { System.out.println("Animal sound"); }
}
class Dog extends Animal {
    @Override
    void makeSound() { System.out.println("Bark"); }
}
```

### Abstraction
- **Definition**: Hiding implementation details, showing only functionality
- **Implementation**: Through abstract classes and interfaces
- **Abstract Classes**: Can have both concrete and abstract methods
- **Interfaces**: Collection of abstract methods (default/static methods allowed in Java 8+)
```java
abstract class Vehicle {
    abstract void start();
    void stop() { System.out.println("Stopping"); }
}

interface Flyable {
    void fly();
    default void land() { System.out.println("Landing"); }
}
```

## 2. Java Syntax and Language Features

### Basic Structure
```java
package com.example;

import java.util.List;

public class MyClass {
    // Fields
    private int number;
    
    // Constructor
    public MyClass(int number) {
        this.number = number;
    }
    
    // Methods
    public void doSomething() {
        // Method body
    }
    
    // Main method
    public static void main(String[] args) {
        // Program execution starts here
    }
}
```

### Access Modifiers
- **public**: Accessible from anywhere
- **protected**: Accessible within package and by subclasses
- **default (no modifier)**: Accessible only within package
- **private**: Accessible only within class

### Non-Access Modifiers
- **static**: Belongs to class rather than instance
- **final**: Cannot be extended (class), overridden (method), or changed (variable)
- **abstract**: Cannot be instantiated (class), must be implemented (method)
- **synchronized**: Controls thread access to method/block
- **volatile**: Variable value always read from main memory

## 3. Data Types, Variables, and Operators

### Primitive Data Types
| Type | Size | Range | Default |
|------|------|-------|---------|
| byte | 8 bits | -128 to 127 | 0 |
| short | 16 bits | -32,768 to 32,767 | 0 |
| int | 32 bits | -2^31 to 2^31-1 | 0 |
| long | 64 bits | -2^63 to 2^63-1 | 0L |
| float | 32 bits | ~3.40282347 x 10^38 | 0.0f |
| double | 64 bits | ~1.79769313486231570 x 10^308 | 0.0d |
| char | 16 bits | 0 to 65,535 | '\u0000' |
| boolean | 1 bit | true/false | false |

### Reference Types
- **Classes**: `String`, custom classes
- **Arrays**: `int[]`, `String[]`
- **Interfaces**: Collections interfaces
- **Wrapper Classes**: `Integer`, `Boolean`, etc.

### Variable Declaration
```java
// Primitive types
int count = 10;
double price = 23.45;

// Reference types
String name = "John";
Date today = new Date();

// Constants
final double PI = 3.14159;
```

### Operators
- **Arithmetic**: `+`, `-`, `*`, `/`, `%`, `++`, `--`
- **Relational**: `==`, `!=`, `>`, `<`, `>=`, `<=`
- **Logical**: `&&`, `||`, `!`
- **Bitwise**: `&`, `|`, `^`, `~`, `<<`, `>>`, `>>>`
- **Assignment**: `=`, `+=`, `-=`, `*=`, `/=`, etc.
- **Ternary**: `condition ? expr1 : expr2`
- **instanceof**: Tests if object is instance of class/interface

## 4. Control Flow Statements

### Conditional Statements
```java
// if-else
if (condition) {
    // code block
} else if (anotherCondition) {
    // code block
} else {
    // code block
}

// switch
switch (variable) {
    case value1:
        // code block
        break;
    case value2:
        // code block
        break;
    default:
        // code block
}

// Enhanced switch (Java 14+)
switch (variable) {
    case value1 -> // code or expression;
    case value2 -> // code or expression;
    default -> // code or expression;
}
```

### Loops
```java
// for loop
for (int i = 0; i < 10; i++) {
    // code block
}

// enhanced for loop (for-each)
for (String item : itemList) {
    // code block
}

// while loop
while (condition) {
    // code block
}

// do-while loop
do {
    // code block
} while (condition);
```

### Control Statements
- **break**: Exits loop or switch
- **continue**: Skips to next iteration
- **return**: Exits method, optionally returning value
- **yield**: Returns value from switch expression (Java 14+)

## 5. Exception Handling

### Exception Hierarchy
- **Throwable**: Base class for all exceptions
  - **Error**: Serious problems, not typically caught
  - **Exception**: Base for checked exceptions
    - **RuntimeException**: Base for unchecked exceptions

### Try-Catch-Finally
```java
try {
    // code that might throw exception
} catch (ExceptionType1 e1) {
    // handle exception type 1
} catch (ExceptionType2 | ExceptionType3 e2) {
    // handle multiple exception types
} finally {
    // always executed code
}
```

### Try-With-Resources
```java
try (BufferedReader br = new BufferedReader(new FileReader("file.txt"))) {
    // code that uses resource
    // resource automatically closed
}
```

### Throwing Exceptions
```java
if (value < 0) {
    throw new IllegalArgumentException("Value cannot be negative");
}
```

### Creating Custom Exceptions
```java
public class CustomException extends Exception {
    public CustomException() { super(); }
    public CustomException(String message) { super(message); }
    public CustomException(String message, Throwable cause) { super(message, cause); }
}
```

### Checked vs. Unchecked Exceptions
- **Checked**: Must be caught or declared (IOException, SQLException)
- **Unchecked**: Not required to be caught (RuntimeException and subclasses)

## 6. Java Collections Framework

### Main Interfaces
- **Collection**: Root interface
  - **List**: Ordered collection (allows duplicates)
  - **Set**: No duplicates
  - **Queue**: Typically FIFO order
- **Map**: Key-value pairs

### Common Implementations
- **Lists**:
  - `ArrayList`: Dynamic array, fast random access
  - `LinkedList`: Fast insertions/deletions
  - `Vector`: Synchronized version of ArrayList
- **Sets**:
  - `HashSet`: Fast operations, no order guarantee
  - `LinkedHashSet`: Preserves insertion order
  - `TreeSet`: Sorted set (implements SortedSet)
- **Maps**:
  - `HashMap`: Fast operations, no order guarantee
  - `LinkedHashMap`: Preserves insertion order
  - `TreeMap`: Sorted by keys (implements SortedMap)
  - `Hashtable`: Synchronized version of HashMap
- **Queues**:
  - `ArrayDeque`: Resizable array implementation
  - `PriorityQueue`: Elements processed by priority

### Usage Examples
```java
// ArrayList
List<String> names = new ArrayList<>();
names.add("Alice");
names.add("Bob");
names.remove(0);
String first = names.get(0);

// HashMap
Map<String, Integer> ages = new HashMap<>();
ages.put("Alice", 30);
ages.put("Bob", 25);
int aliceAge = ages.get("Alice");
boolean containsBob = ages.containsKey("Bob");

// HashSet
Set<String> uniqueNames = new HashSet<>();
uniqueNames.add("Alice");
uniqueNames.add("Alice");  // Ignored (duplicate)
boolean hasAlice = uniqueNames.contains("Alice");
```

## 7. Generics

### Basic Syntax
```java
// Generic class
public class Box<T> {
    private T value;
    
    public void set(T value) { this.value = value; }
    public T get() { return value; }
}

// Usage
Box<Integer> intBox = new Box<>();
intBox.set(10);
Integer value = intBox.get();
```

### Wildcards
```java
// Unknown type (?)
void processElements(List<?> elements) {
    // Can read but not write elements
}

// Upper bounded wildcard
void addNumbers(List<? extends Number> numbers) {
    // Can read elements knowing they are at least Number
}

// Lower bounded wildcard
void addIntegers(List<? super Integer> integers) {
    integers.add(10); // Can write Integers
}
```

### Type Parameters
- **Type Parameter Naming Conventions**:
  - `E`: Element
  - `K`: Key
  - `V`: Value
  - `N`: Number
  - `T`: Type
  - `S`, `U`, `V`, etc.: Additional types

### Type Erasure
- During compilation, generic type information is removed ("erased")
- Runtime doesn't have access to generic type information

## 8. Functional Interfaces and Lambda Expressions

### Functional Interfaces
- Interface with exactly one abstract method
- Annotated with `@FunctionalInterface`
- Common functional interfaces:
  - `Predicate<T>`: Takes T, returns boolean (`boolean test(T t)`)
  - `Consumer<T>`: Takes T, returns void (`void accept(T t)`)
  - `Function<T,R>`: Takes T, returns R (`R apply(T t)`)
  - `Supplier<T>`: Takes nothing, returns T (`T get()`)
  - `BinaryOperator<T>`: Takes two T, returns T (`T apply(T t1, T t2)`)

### Lambda Expressions
```java
// Basic syntax
(parameters) -> expression
(parameters) -> { statements; }

// Examples
Predicate<String> isEmpty = s -> s.isEmpty();
Consumer<String> printer = s -> System.out.println(s);
Function<String, Integer> lengthFinder = s -> s.length();
Supplier<Double> random = () -> Math.random();
BinaryOperator<Integer> sum = (a, b) -> a + b;
```

### Method References
```java
// Static method
Function<String, Integer> parseInt = Integer::parseInt;

// Instance method of specific object
Consumer<String> printer = System.out::println;

// Instance method of arbitrary object
Function<String, Integer> length = String::length;

// Constructor
Supplier<List<String>> listSupplier = ArrayList::new;
```

## 9. Streams API

### Creating Streams
```java
// From collection
List<String> list = Arrays.asList("a", "b", "c");
Stream<String> stream = list.stream();

// From array
String[] array = {"a", "b", "c"};
Stream<String> stream = Arrays.stream(array);

// Generate/iterate
Stream<Integer> numbers = Stream.iterate(0, n -> n + 1).limit(10);
Stream<Double> randoms = Stream.generate(Math::random).limit(5);
```

### Common Operations
- **Intermediate Operations** (return a stream):
  - `filter(Predicate)`: Filters elements
  - `map(Function)`: Transforms elements
  - `flatMap(Function)`: Transforms and flattens
  - `sorted()`: Sorts elements
  - `distinct()`: Removes duplicates
  - `limit(n)`: Limits size
  - `skip(n)`: Skips elements
- **Terminal Operations** (produce a result):
  - `forEach(Consumer)`: Processes each element
  - `collect(Collector)`: Gathers elements
  - `reduce(BinaryOperator)`: Reduces to single value
  - `count()`: Counts elements
  - `anyMatch(Predicate)`: Tests if any match
  - `allMatch(Predicate)`: Tests if all match
  - `noneMatch(Predicate)`: Tests if none match
  - `findFirst()`, `findAny()`: Finds elements

### Example
```java
List<String> names = Arrays.asList("John", "Jane", "Jack", "James");

List<String> filteredNames = names.stream()
    .filter(name -> name.startsWith("J"))
    .filter(name -> name.length() > 3)
    .map(String::toUpperCase)
    .sorted()
    .collect(Collectors.toList());
```

## 10. Multithreading and Concurrency

### Thread Creation
```java
// Extending Thread
class MyThread extends Thread {
    public void run() {
        // Code to execute in thread
    }
}
MyThread thread = new MyThread();
thread.start();

// Implementing Runnable
class MyRunnable implements Runnable {
    public void run() {
        // Code to execute in thread
    }
}
Thread thread = new Thread(new MyRunnable());
thread.start();

// Lambda expression
Thread thread = new Thread(() -> {
    // Code to execute in thread
});
thread.start();
```

### Thread Lifecycle
- **New**: Created but not started
- **Runnable**: Started, waiting for scheduler
- **Blocked**: Waiting for monitor lock
- **Waiting**: Called wait() without timeout
- **Timed Waiting**: Called sleep() or wait() with timeout
- **Terminated**: Completed execution

### Thread Synchronization
```java
// Synchronized method
synchronized void method() {
    // Thread-safe code
}

// Synchronized block
synchronized (lockObject) {
    // Thread-safe code
}

// Lock interface
Lock lock = new ReentrantLock();
lock.lock();
try {
    // Critical section
} finally {
    lock.unlock();
}
```

### Concurrent Collections
- **ConcurrentHashMap**: Thread-safe HashMap
- **CopyOnWriteArrayList**: Thread-safe ArrayList
- **BlockingQueue**: Queue with blocking operations

### Thread Pools (ExecutorService)
```java
// Fixed thread pool
ExecutorService executor = Executors.newFixedThreadPool(5);
executor.submit(() -> {
    // Task to execute
});
executor.shutdown();

// CompletableFuture
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    // Async computation
    return "Result";
});
future.thenAccept(System.out::println);
```

### Atomic Variables
```java
AtomicInteger counter = new AtomicInteger(0);
counter.incrementAndGet(); // Thread-safe increment
```

### Thread Communication
- **wait()**: Causes thread to wait until notify/notifyAll
- **notify()**: Wakes up one waiting thread
- **notifyAll()**: Wakes up all waiting threads
- **join()**: Waits for thread to die

* Original
1. Object-Oriented Programming (OOP) in Java  
- Encapsulation (Access Modifiers: private, protected, public, default)  
- Abstraction (abstract classes, interfaces, default methods in interfaces)  
- Inheritance (extends, method overriding, super keyword, constructor chaining)  
- Polymorphism (Compile-time vs. Runtime, method overloading vs. method overriding)  
- Composition vs. Inheritance (Why favor composition over inheritance?)  
- SOLID Principles (How they apply in Java)  
- JavaBeans and POJOs (Plain Old Java Objects)  

2. Java Data Types and Memory Management  
- Primitive vs. Reference Types  
- Wrapper classes (Integer, Double, Boolean, etc.)  
- String handling (String, StringBuilder, StringBuffer, immutability)  
- Autoboxing and Unboxing  
- Memory Allocation (Heap vs. Stack)  
- Garbage Collection (How it works, finalize(), weak references, types of GC algorithms)  

3. Java Collections Framework (JCF)  
- List Interface (ArrayList, LinkedList, Vector, Stack)  
- Set Interface (HashSet, TreeSet, LinkedHashSet)  
- Map Interface (HashMap, TreeMap, LinkedHashMap, Hashtable)  
- Queue Interface (PriorityQueue, Deque, ArrayDeque)  
- Concurrent Collections (ConcurrentHashMap, CopyOnWriteArrayList)  
- Sorting and Searching in Collections (Comparable vs. Comparator)  
- Big-O Complexity of Collection Operations  
- Immutable Collections (List.of(), Set.of(), Map.of())  

4. Exception Handling  
- Checked vs. Unchecked Exceptions  
- Custom Exceptions  
- Try-Catch-Finally vs. Try-With-Resources (AutoCloseable)  
- Throw vs. Throws  
- Multi-catch blocks (catch (IOException | SQLException e))  
- Best Practices for Exception Handling (Avoiding Generic Exceptions)  

5. Java Multithreading and Concurrency  
- Thread Lifecycle  
- Creating Threads (Thread vs. Runnable, Callable, Future)  
- Synchronization (synchronized keyword, locks, ReentrantLock, wait(), notify())  
- Thread Safety and Shared Resource Handling  
- Executors and Thread Pools (ExecutorService, ScheduledExecutorService)  
- Atomic Variables (AtomicInteger, AtomicBoolean)  
- Fork-Join Framework  
- Deadlocks, Race Conditions, and Livelocks  

6. Java Streams and Functional Programming  
- Lambda Expressions ((a, b) -> a + b)  
- Method References (Class::methodName)  
- Functional Interfaces (Predicate, Consumer, Supplier, Function, BiFunction)  
- Streams API (Intermediate vs. Terminal Operations)  
- Stream Processing (map(), filter(), reduce(), collect())  
- Parallel Streams (parallelStream())  
- Optional Class (Optional<T>, avoiding null)  

7. Java Input/Output (I/O) and Serialization  
- Byte Streams vs. Character Streams (InputStream, OutputStream, Reader, Writer)  
- File Handling (File, Files, BufferedReader, BufferedWriter)  
- Object Serialization (Serializable, transient keyword)  
- New I/O (NIO) (Path, Files, ByteBuffer, Channels)  
- Memory-Mapped Files  
- Java 11+ Features (Files.writeString(), Files.readString())  

8. Java 8+ Features  
- Default and Static Methods in Interfaces  
- Optional Class  
- New Date and Time API (LocalDate, LocalTime, LocalDateTime, ZonedDateTime)  
- CompletableFuture (thenApply(), thenAccept(), exceptionally())  
- New Collection Methods (List.of(), Set.of(), Map.of())  
- Records (Java 14+)  
- Pattern Matching (Java 17+)  
- Sealed Classes (Java 17+)  

9. Java Reflection and Dynamic Class Loading  
- Getting Class Information (.class, Class.forName())  
- Accessing Private Fields and Methods  
- Dynamic Proxy and InvocationHandler  
- Annotations and Annotation Processing  

10. Java Networking (Sockets, HTTP)  
- Java Sockets (ServerSocket, Socket)  
- URL and HttpURLConnection  
- HTTP Clients (Java 11 HttpClient)  
- Multithreaded Server Applications  

11. Java Security Basics  
- Encryption and Hashing (AES, SHA, RSA)  
- Java Cryptography API (MessageDigest, Cipher)  
- Secure Random Numbers (SecureRandom)  
- Security Manager (doPrivileged())  
- Understanding Java Classloaders and Security Policies  

12. Java Virtual Machine (JVM) Internals  
- JVM Architecture (ClassLoader, Method Area, Heap, Stack, Execution Engine, Garbage Collector)  
- Class Loading (ClassLoader, Bootstrap, Extensions, Application ClassLoader)  
- JIT Compilation (Just-In-Time Compiler)  
- Garbage Collection Algorithms (G1, ZGC, Epsilon GC)  
- JVM Performance Tuning (-Xms, -Xmx, -XX:+UseG1GC)  
