java-portswrigger-test

## 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	-231 to 231-1	0
long	64 bits	-263 to 263-1	0L
float	32 bits	~3.40282347 x 1038	0.0f
double	64 bits	~1.79769313486231570 x 10308	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