Velislav Krastev-blog

What are SOLID principles ?

What is Single Responsibility Principle (SRP):

A class should have only one responsibility.
It should have only one reason to change.
Benefits include easier testing, lower coupling, and better organization.
Voorbeeld:

Java

public class Book {
private String name;
private String author;
private String text;
// constructor, getters, and setters
}

What is Open-Closed Principle (OCP):

Software entities (classes, modules, functions) should be open for extension but closed for modification.
Achieve this by using interfaces, abstract classes, and inheritance.
Voorbeeld:
Java

interface Shape {
double area();
}
class Circle implements Shape { /* implementation / } class Rectangle implements Shape { / implementation */ }

What is Liskov Substitution Principle (LSP):

Subtypes must be substitutable for their base types without altering the correctness of the program.
Follows the “is-a” relationship.
Voorbeeld:
Java

class Bird { /* common bird behavior / } class Sparrow extends Bird { / specific sparrow behavior */ }

What is Interface Segregation Principle (ISP):

Clients should not be forced to depend on interfaces they don’t use.
Split large interfaces into smaller, more specific ones.
Voorbeeld:
Java

interface Worker {
void work();
}
interface Eater {
void eat();
}
class Robot implements Worker { /* implementation */ }

What is Dependency Inversion Principle (DIP):

High-level modules should not depend on low-level modules; both should depend on abstractions.
Abstractions should not depend on details; details should depend on abstractions.

// Abstraction
interface MessageSender {
void sendMessage(String message);
}

// High-level module
class NotificationService {
private MessageSender messageSender;

public NotificationService(MessageSender messageSender) {
    this.messageSender = messageSender;
}
public void send(String message) {
    messageSender.sendMessage(message);
}

}

// Low-level module
class EmailSender implements MessageSender {
@Override
public void sendMessage(String message) {
System.out.println(“Verzendt e-mail: ” + bericht);
}
}

// Another Low-level module
class SmsSender implements MessageSender {
@Override
public void sendMessage(String message) {
System.out.println(“SMS verzenden: ” + bericht);
}
}

// Main class
public class Main {
public static void main(String[] args) {
// Use EmailSender
MessageSender emailSender = new EmailSender();
NotificationService notificationService1 = new NotificationService(emailSender);
notificatieService1.send(“Hallo via e-mail!”);

    // Use SmsSender
    MessageSender smsSender = new SmsSender();
    NotificationService notificationService2 = new NotificationService(smsSender);
    notificationService2.send("Hello via SMS!");
}

}

The MessageSender interface serves as the abstraction.
High-level module NotificationService depends on this abstraction instead of concrete implementations.
Low-level modules like EmailSender and SmsSender also depend on the abstraction by implementing the MessageSender interface.

What is Normalization of SQL

What is Normalization?
Normalization involves structuring data within a relational database to eliminate anomalies like redundancy.
It breaks down large, complex tables into smaller ones while maintaining data relationships.
Why Is Normalization Important?
Reduces Redundancy: By splitting data into smaller tables, we avoid storing the same information multiple times.
Improves Query Performance: Smaller normalized tables lead to faster query execution.
Minimizes Update Anomalies: Updates can be made without affecting other records.
Enhances Data Integrity: Ensures consistent and accurate data.
Scenarios for Normalization:
Data Integrity: Prevent inconsistencies when updating data (e.g., customer age changes).
Efficient Querying: Simplify complex queries by breaking down data.
Storage Optimization: Eliminate unnecessary redundancy to save space.

What is Microservices monolith?

What is monolith?

A monolithic application is built as a single, unified unit. It tightly couples all components (such as the client-side UI, database, and server-side application) into one code base.
Advantages:
Easy Deployment: Since it’s a single executable file or directory, deployment is straightforward.
Development Speed: Early in a project’s life, monoliths allow fast development due to their simplicity.
Performance: Centralized code can handle various functions.

What are Microservices?

Microservices break down the application into smaller, independently deployable services. Each service focuses on a specific business domain.
Advantages:
Scalability: Microservices allow scaling individual components independently.
Flexibility: Developers can choose different technologies for each service.
Isolation: Failures in one service don’t affect others.
Challenges:
Complexity: Managing multiple services requires robust orchestration.
Network Overhead: Communication between services introduces latency.
Deployment Complexity: Coordinating updates across services can be tricky.

What is Polymorphism?

Method Overriding:
When a subclass provides a specific implementation for a method that is already defined in its superclass.

Method Overloading:
When a class has multiple methods with the same name but different parameters (different number or types of arguments).

What is Private constructors use?

–Private-constructors worden gebruikt in nutsklassen of constante klassen.
These classes contain only static methods or members.

–A Subclassificatie vermijden

— constructeursdelegatie:
Private constructors allow constructor delegation, where specific constructors call a common private constructor.

— Singleton-patroon

About JVM

–-compilatie:
When you compile a .java file, the Java compiler generates .class files containing bytecode (intermediate representation).
Bytecode is platform-independent and can run on any system with a compatible JVM.
–Class ladersubsysteem:
Responsible for loading classes into memory.
Reads .class files, generates binary data, and stores it in the method area.
Creates a Class object representing the loaded class in heap memory.
Example: Student s1 = new Student(); Class c1 = s1.getClass();
–Koppeling:
Consists of three steps:
Verification: Ensures the correctness of the .class file.
Preparation: Allocates memory for class variables and initializes them.
Resolution (optional): Resolves symbolic references to other classes or methods.
–Initialisatie:
Executes static initializers (e.g., static blocks) and initializes static variables.
Instance variables are initialized when an object is created.
– Uitvoeringsengine:
Converts bytecode into machine code.
Includes Just-In-Time (JIT) compilation for performance optimization.

– Samengevat zorgt de JVM ervoor dat Java-programma's overal kunnen worden uitgevoerd door bytecode te interpreteren en geheugen te beheren

What is Privat abstract method?

–Gebruik cases voor privémethoden in abstracte klassen:
While abstract methods cannot be private, you can use private methods within an abstract class for various purposes:
–Helper-methoden: implementeer gemeenschappelijke functionaliteit die door andere methoden wordt gedeeld.
–Encapsulatie: implementatiedetails verbergen voor subklassen.
–Struct-achtige klassen: Creëer kleine klassen met privémethoden die dienen als gegevenscontainers

What is Garbage collector?

–Heap-geheugen:
Java objects are created in the heap, a dedicated memory area.
Some objects become unreachable (no longer referenced by the program).
–Vuilnisverzamelaar (GC):
The GC identifies and deletes unused objects to free up memory.
It runs automatically in the background.
Two types:
Minor GC: Removes unreachable objects in the young generation.
Major GC (Full GC): Clears objects in the old generation.
–Voordelen:
Developers don’t need to explicitly delete objects.
GC ensures memory availability and prevents OutOfMemoryErrors

What is OOP?

Four Principles of OOP:
–Encapsulatie: het samenbundelen van gegevens (attributen) en methoden (functies) binnen een klasse om implementatiedetails te verbergen en een schone interface te bieden.
–Inheritance: Nieuwe klassen creëren op basis van bestaande klassen, waarbij hun attributen en gedrag worden overgenomen. Het bevordert hergebruik van code.
–Polymorfisme: Hiermee kunnen objecten van verschillende klassen uniform worden behandeld via een gemeenschappelijke interface. Het maakt flexibiliteit en uitbreidbaarheid mogelijk.
–Abstractie: Focussen op essentiële functies terwijl onnodige complexiteiten worden verborgen. Abstractie vereenvoudigt het ontwerp en maakt het beter beheersbaar.

What is ACID properties play a crucial role in ensuring the reliability and consistency of transactions.

–atomiciteit:
Transactions are either executed entirely or not at all.
No partial execution: If a transaction fails midway, any changes made to the database are rolled back.
Example: Consider transferring $100 from account X to account Y. If the transaction fails after deducting from X but before adding to Y, the database remains consistent.
–Consistentie:
The database must maintain integrity constraints before and after a transaction.
Example: If the total amount before a transaction is $700 (X: $500, Y: $200), it should remain the same after the transaction (X: $400, Y: $300).
–Isolatie:
Multiple transactions can occur concurrently without affecting each other.
Changes made by one transaction are not visible to others until committed.
Ensures equivalent results as if transactions were executed serially.
Example: Isolating transactions prevents inconsistencies due to interleaved operations.
–Duurzaamheid:
Once a transaction is committed, its changes are permanent.
Survives system failures or crashes.
Ensures data persistence.
Example: Even after a system restart, committed changes remain intact.
Remember, ACID properties provide the foundation for reliable and consistent database operations! 🌟

What is Strategy Pattern?
Description: Defines a family of algorithms, encapsulates each one, and makes them interchangeable. It allows the algorithm to vary independently from clients that use them.
Voorbeeld:
Java

// Interface for eat behavior
interface EatBehavior {
void eat();
}

// Concrete implementations of eat behavior
class NormalDiet implements EatBehavior {
@Override
public void eat() {
// Normal food
}
}

class LosingWeightDiet implements EatBehavior {
@Override
public void eat() {
// Healthy food
}
}

// Cat class with eat behavior
abstract class Cat {
EatBehavior eatBehavior;

public void eat() {
    eatBehavior.eat();
}
public void setEatBehavior(EatBehavior eatBehavior) {
 this.eatBehavior = eatBehavior;
}

}

// Usage
Cat cat = new Cat();
cat.setEatBehavior(new LosingWeightDiet());
cat.eat(); // Cat eats with a healthier diet

Creational Patterns:
These patterns focus on class instantiation.
Examples include

— Fabrieksmethode,
Problem Statement: Suppose we want to create different types of products (e.g., cars, bikes, cycles) without tightly coupling our code to specific implementations.
Key Components:
Product: An abstract class or interface defining common operations for the objects that the factory will create.
Concrete Products: Actual classes implementing the Product interface, representing specific types of objects.
Creator: An abstract class or interface declaring the factory method. It’s responsible for creating Product objects but delegates the actual creation to subclasses.
Concrete Creators: Subclasses of the Creator that implement the factory method. They decide which specific Concrete Product to create based on input parameters or configuration.
Factory Method: A method defined in the Creator class that creates Product objects. It’s typically declared as abstract in the Creator and implemented in the Concrete Creators.
Example in Java: Let’s say we have a Factory that produces different types of vehicles. Here’s a simplified example:
Java

// Abstract Product
interface Product {
void display();
}

// Concrete Products
class Car implements Product {
public void display() {
System.out.println (“Car gemaakt”);
}
}

class Bike implements Product {
public void display() {
System.out.println(“Bike gemaakt”);
}
}

// Creator (Factory)
interface Factory {
Product factoryMethod();
}

// Concrete Creators
class ConcreteFactoryA implements Factory {
public Product factoryMethod() {
return new Car();
}
}

class ConcreteFactoryB implements Factory {
public Product factoryMethod() {
return new Bike();
}
}

public class FactoryMethodExample {
public static void main(String[] args) {
Factory factoryA = new ConcreteFactoryA();
Product productA = factoryA.factoryMethod();
productA.display();

    Factory factoryB = new ConcreteFactoryB();
    Product productB = factoryB.factoryMethod();
    productB.display();
}

}

—-bouwer
The Builder Pattern is a creational design pattern that allows you to construct complex objects step by step,
separating their construction from their representation. Here’s a simple example in Java:
// Define the class you want to build
class Post {
private final String title;
private final String text;
private final String category;

Post(Builder builder) {
    this.title = builder.title;
    this.text = builder.text;
    this.category = builder.category;
}
// Getters for properties
public String getTitle() {
    return title;
}
public String getText() {
    return text;
}
public String getCategory() {
    return category;
}
// Builder class
public static class Builder {
    private String title;
    private String text;
    private String category;
    public Builder title(String title) {
        this.title = title;
        return this;
    }
    public Builder text(String text) {
        this.text = text;
        return this;
    }
    public Builder category(String category) {
        this.category = category;
        return this;
    }
    public Post build() {
        return new Post(this);
    }
}

}

// Usage
public class Main {
public static void main(String[] args) {
Post post = new Post.Builder()
.title(“Java Builder-patroon”)
.text(“Elegt uit hoe u het Builder-patroon in Java kunt implementeren”)
.category(“Ontwerppatronen”)
.build();

    System.out.println("Title: " + post.getTitle());
    System.out.println("Text: " + post.getText());
    System.out.println("Category: " + post.getCategory());
}

}

–Prototype
The Prototype Pattern is a creational design pattern that allows you to create new objects by copying an existing object.
Instead of creating new instances from scratch, you clone an existing prototype, which can be more efficient and flexible. Let’s dive into an example in Java:
Define the Prototype Interface: First, we create an abstract class or interface called Tree with an abstract method copy():
Java

public abstract class Tree {
public abstract Tree copy();
}

Concrete Prototypes: Next, we implement two concrete classes that extend Tree: PlasticTree and PineTree. These classes represent specific types of trees and provide their own implementation of the copy() method:
Java

public class PlasticTree extends Tree {
@Override
public Tree copy() {
PlasticTree plasticTreeClone = new PlasticTree(this.getMass(), this.getHeight());
plasticTreeClone.setPosition(this.getPosition());
return plasticTreeClone;
}
}

public class PineTree extends Tree {
@Override
public Tree copy() {
PineTree pineTreeClone = new PineTree(this.getMass(), this.getHeight());
pineTreeClone.setPosition(this.getPosition());
return pineTreeClone;
}
}
In these classes, we customize the cloning process based on the specific tree type. For example, we copy the mass, height, and position of the original tree.
Usage: Now, let’s create instances of our concrete prototypes:
Java

public class Main {
public static void main(String[] args) {
Tree originalPlasticTree = new PlasticTree(10, 5);
Tree clonedPlasticTree = originalPlasticTree.copy();

    Tree originalPineTree = new PineTree(15, 8);
    Tree clonedPineTree = originalPineTree.copy();

    // Use the cloned trees as needed
    // ...
}

}

What are Structural Patterns?
These patterns deal with a class’s structure and composition.

–Aadapterpatroon
The Adapter Pattern is a structural design pattern that allows you to make two incompatible interfaces work together.
It acts as a bridge between these interfaces, enabling collaboration without modifying their source code.

Object Adapter:
In this approach, we use composition to delegate logic to the adapter.
The adapter contains the Adaptee and delegates the request() method to the specificRequest() method in the Adaptee.
Java

// Adaptee (existing class)
class Adaptee {
void specificRequest() {
System.out.println (“AAdaptee’s specifiek verzoek”);
}
}

// Target interface
interface Target {
void request();
}

// Adapter (using composition)
class Adapter implements Target {
private final Adaptee adaptee;

Adapter(Adaptee adaptee) {
    this.adaptee = adaptee;
}
@Override
public void request() {
    adaptee.specificRequest();
}

}

Class Adapter:
Requires multiple inheritance (not directly possible in Java).
We can achieve it using interfaces with default methods.
The adapter extends both the Target and the Adaptee classes.
Java

// Target interface
interface Target {
void request();
}

// Adaptee (existing class)
class Adaptee {
void specificRequest() {
System.out.println (“AAdaptee’s specifiek verzoek”);
}
}

// Adapter (using class inheritance)
class Adapter extends Adaptee implements Target {
@Override
public void request() {
specificRequest();
}
}
Benefits and Trade-Offs:
Class Adapter works well for one-to-one method mapping.
Object Adapter provides more flexibility and avoids code modification.

–Decoratorpatroon
The Decorator Pattern is a creational design pattern that allows you to dynamically add functionality and behavior to an object without
affecting the behavior of other existing objects within the same class. It’s particularly useful when you want to extend an object’s
capabilities without altering its structure.

Overview:
The Decorator Pattern provides an enhanced interface to the original object by wrapping it with additional functionality.
We prefer composition over inheritance to reduce subclassing overhead.
Decorators can be added at runtime, allowing flexibility.
Example Scenario: Suppose we have a ChristmasTree object, and we want to decorate it with various items like garland, tinsel, and bubble lights. We’ll follow the original Gang of Four design conventions:
Implementation:
First, create a ChristmasTree interface:
Java

public interface ChristmasTree {
String decorate();
}

Implement the interface with a basic tree:
Java

public class ChristmasTreeImpl implements ChristmasTree {
@Override
public String decorate() {
retour “Kerstboom”;
}
}

Next, create an abstract TreeDecorator class that implements ChristmasTree and holds the decorated tree:
Java

public abstract class TreeDecorator implements ChristmasTree {
private final ChristmasTree tree;

public TreeDecorator(ChristmasTree tree) {
    this.tree = tree;
}
@Override
public String decorate() {
    return tree.decorate();
}

}

Now create specific decorators. For example, BubbleLights:
Java

public class BubbleLights extends TreeDecorator {
public BubbleLights(ChristmasTree tree) {
super(tree);
}

@Override
public String decorate() {
    return super.decorate() + " with Bubble Lights";
}

}

public class Garland extends TreeDecorator {
public Garland(ChristmasTree tree) {
super(tree);
}

@Override
public String decorate() {
    return super.decorate() + " with Garland";
}

}
Usage:
Create decorated trees:
Java

public class DecoratorPatternDemo {
public static void main(String[] args) {
ChristmasTree tree1 = new Garland(new ChristmasTreeImpl());
Systeem.out.println(boom1.decorate()); // Uitvoer: “Kerstboom met slinger”

    ChristmasTree tree2 = new BubbleLights(new Garland(new Garland(new ChristmasTreeImpl())));
    System.out.println(tree2.decorate()); // Output: "Christmas tree with Garland with Garland with Bubble Lights"
}

}
The pattern allows adding decorators at runtime, giving flexibility to decorate as needed.
Remember, the Decorator Pattern is widely used in scenarios where you want to enhance an object’s behavior without modifying its core structure

— Gevelpatroon
The Facade Pattern is a structural design pattern that simplifies the interaction with a complex subsystem by providing a unified interface.
It acts as a “front door” to hide the underlying complexity and make it easier for clients to use the system

–Composiet
The Composite Pattern is a structural design pattern that allows you to compose objects into tree structures to represent part-whole hierarchies.
The main idea behind the Composite Pattern is to build a tree structure of objects, where individual objects and composite objects share a common interface.

Base Component (Department): We’ll define a simple Department interface as our base component:
Java

public interface Department {
void printDepartmentName();
}

Leaf Components (FinancialDepartment and SalesDepartment): Let’s create classes for financial and sales departments, both implementing the Department interface:
Java

public class FinancialDepartment implements Department {
// Implementation details (e.g., id, name)
public void printDepartmentName() {
System.out.println(getClass().getSimpleName());
}
}

public class SalesDepartment implements Department {
// Implementation details (e.g., id, name)
public void printDepartmentName() {
System.out.println(getClass().getSimpleName());
}
}

These leaf classes implement the printDepartmentName() method and don’t contain references to other Department objects.
Composite Element (HeadDepartment): As a composite class, let’s create a HeadDepartment that holds a collection of Department components:
Java

import java.util.ArrayList;
import java.util.List;

public class HeadDepartment implements Department {
private Integer id;
private String name;
private List childDepartments;

public HeadDepartment(Integer id, String name) {
    this.id = id;
    this.name = name;
    this.childDepartments = new ArrayList<>();
}
public void printDepartmentName() {
    childDepartments.forEach(Department::printDepartmentName);
}
public void addDepartment(Department department) {
    childDepartments.add(department);
}
public void removeDepartment(Department department) {
    childDepartments.remove(department);
}

}

The HeadDepartment class implements the printDepartmentName() method and provides methods for adding and removing child departments.
Usage: You can create instances of leaf departments (e.g., FinancialDepartment, SalesDepartment) and a composite department (e.g., HeadDepartment). Add leaf departments to the composite and print their names.
Java

public class Main {
public static void main(String[] args) {
Department finance = new FinancialDepartment();
Department sales = new SalesDepartment();

    HeadDepartment headDepartment = new HeadDepartment(1, "Company Departments");
    headDepartment.addDepartment(finance);
    headDepartment.addDepartment(sales);

    headDepartment.printDepartmentName();
}

}

Output:
FinancialDepartment
SalesDepartment

The Composite Pattern allows you to create flexible tree structures where
individual objects and compositions (composites) can be treated uniformly.

What is HASH Function !!!

Een hash-functie is een wiskundige functie die een invoer (of “message”) gebruikt en een reeks tekens met een vaste grootte retourneert,
dat is meestal een reeks cijfers en letters. Deze uitvoer wordt een “hash-waarde” of eenvoudigweg een “hash.” genoemd
Hash functions are commonly used in computer science and cryptography, and they have a few important properties:

=== How would you use hash function and how it works ?

Deterministic: The same input will always produce the same hash.

Fast: The function can quickly compute the hash value for any given input.
Uniek (bijna): twee verschillende invoergegevens moeten verschillende hashes produceren (dit staat bekend als het minimaliseren van “-botsingen”).
Irreversible: Given a hash, it should be computationally infeasible to determine the original input.
Uniform: The hash values are evenly distributed over the output space.

Hash functions are widely used in various applications, such as:

Gegevensintegriteit: Om ervoor te zorgen dat gegevens ’t zijn gewijzigd of vervalst, door hashwaarden te vergelijken.
Password Storage: Securely storing hashed passwords instead of the actual passwords.
Cryptography: Used in digital signatures and other cryptographic algorithms.
Hash Tables: For efficient data retrieval in programming.

=== Give me example of hash map, how would you use it ?

SHA (Secure Hash Algorithm):
Includes variants like SHA-1, SHA-256, SHA-384, and SHA-512.
SHA-256 and SHA-512 are widely used in cryptography and blockchain technology (e.g., Bitcoin).

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

public class HashExample {
public static void main(String[] args) {
try {
// The input string to be hashed
Stringinvoer = “Hallo wereld!”;

        // Create a MessageDigest instance for SHA-256
        MessageDigest digest = MessageDigest.getInstance("SHA-256");

        // Compute the hash
        byte[] hash = digest.digest(input.getBytes());

        // Convert the hash bytes to a hexadecimal string
        StringBuilder hexString = new StringBuilder();
        for (byte b : hash) {
            String hex = String.format("%02x", b);
            hexString.append(hex);
        }

        // Print the resulting hash
        System.out.println("SHA-256 Hash: " + hexString.toString());
    } catch (NoSuchAlgorithmException e) {
        System.err.println("Error: " + e.getMessage());
    }
}

}

Input Data: The input variable contains the data you want to hash.
Initialisatie van MessageDigest: de instantie MessageDigest wordt gemaakt met behulp van getInstance(“SHA-256”), dat het hash-algoritme SHA-256 specificeert.
Hashing: The digest method computes the hash of the input data.
Hexadecimal Conversion: Since the hash is in binary format, we use a loop to convert it into a more readable hexadecimal string.

Put and Patch ? When to use it ?

Both PUT and PATCH are HTTP methods used to update resources on a server, but they differ in how they handle updates:

PUT:
Full Update:
PUT is used to completely replace an existing resource.
The entire resource needs to be sent in the request, even if only a part of it is being changed.

Als de bron niet bestaat, maakt PUT deze vaak aan (hoewel dit gedrag kan variëren).

Idempotent:

Repeated PUT requests with the same data will always result in the same state of the resource.
Voorbeeld: een user’s-profiel bijwerken:

json
PUT /users/123
{
“naam”: “Velislav”,
“email”: OZYX2Zvelislav@example.comOZYX3Z,
“age”: 30
}
If only the name changes but the email and age remain the same, they must still be included in the request.

PATCH:
Partial Update:

PATCH is used to make a partial update to an existing resource.
Only the fields being changed need to be sent in the request.

Idempotent (Mostly):

Like PUT, repeated PATCH requests with the same data generally result in the same state of the resource.
However, behavior might depend on the server implementation.

Voorbeeld: alleen de naam user’s bijwerken:

json
PATCH /users/123
{
“naam”: “Velislav”
}
Here, only the name field is updated, leaving other fields unchanged.

Key Difference:
PUT replaces the entire resource, while PATCH modifies only specified fields of the resource.

HTTP methods with a short description.

GET: Used to retrieve data from the server without modifying it. Commonly used for fetching resources or information.
POST: Used to send data to the server, typically to create a new resource. For example, submitting a form or uploading a file.
PUT: Used to update or completely replace an existing resource on the server. If the resource doesn’t exist, it may be created.
PATCH: Used for partial updates to an existing resource, modifying only the specified fields.
DELETE: Used to delete a resource from the server.
HEAD: Similar to GET, used to retrieve headers without the body of a resource.
OPTIONS: It tells what HTTP methods are allowed.
TRACE: Used mainly for diagnostic purposes by echoing the request back to the client
CONNECT: Establishes a tunnel to the server, often used for SSL/TLS connections.

========== Functional Interface ====================================

A functional interface in Java is an interface that contains exactly one abstract method. These interfaces are used primarily in lambda expressions and method references, enabling more concise and readable functional programming.

Key Features:

1. Single Abstract Method: A functional interface has only one abstract method. This is the essence of its functionality.
2. Default and Static Methods: Functional interfaces can include default and static methods, but these do not count as the single abstract method.
3. @FunctionalInterface Annotation: While this annotation is optional, it helps by signaling that the interface is intended to be a functional one. If additional abstract methods are added to the interface, the compiler throws an error.

Voorbeeld:

@FunctionalInterface
interface Calculator {
    int calculate(int a, int b);
}
// Using lambda expression
public class Main {
    public static void main(String[] args) {
        // Implementing the calculate method using a lambda
        Calculator addition = (a, b) -> a + b;
        Calculator multiplication = (a, b) -> a * b;
        System.out.println("Addition: " + addition.calculate(5, 3));  // Output: 8
        System.out.println("Multiplication: " + multiplication.calculate(5, 3));  // Output: 15
    }
}

Use Case:

De Calculator interface in the example has a single abstract method calculate, making it a functional interface.
This allows us to use lambda expressions for brevity and elegance in implementation.

Common Functional Interfaces in Java:

Java provides several built-in functional interfaces in the java.util.function package, such as:

• Predicate: Takes an input and returns a boolean.
• Function: Takes an input and returns an output of type R.
• Supplier: Provides a value without input.
• Consumer: Accepts a value and performs an action.

Functional interfaces streamline operations, especially in scenarios like working with collections, streams, or asynchronous tasks.

They empower Java to adopt functional programming paradigms while maintaining its object-oriented nature.

================ higher-order function is =============================
Een functie van hogere orde is een functie die andere functies als argumenten gebruikt of een functie als resultaat retourneert. Met andere woorden, het werkt op functies en behandelt ze als eersteklas burgers.” Dit is een krachtig kenmerk in functionele programmeerparadigma's, dat abstractie, hergebruik van code en compositie mogelijk maakt.

Example of a Higher-Order Function in Java:

import java.util.function.Function;
public class Main {
    public static void main(String[] args) {
        // Higher-order function: applies a function to a value
        Function<Integer, Integer> squareFunction = x -> x * x;
        int result = applyFunction(5, squareFunction);
        System.out.println("Square of 5: " + result);  // Output: 25
    }
    public static int applyFunction(int value, Function<Integer, Integer> function) {
        return function.apply(value);
    }
}

In the example above:

• De applyFunction method is a higher-order function because it accepts another function (Function<Integer, Integer>) as a parameter.

Characteristics:

1. Accepts Functions as Arguments: Higher-order functions can take other functions as input to perform specific operations.
2. Returns Functions: They can generate and return new functions dynamically.
3. Encourages Code Reuse: Promotes modular and reusable code since functions can be passed around and composed together.

Use Case:

In Java, higher-order functions are commonly used in functional programming with streams, lambdas, and method references. For example:

List<String> names = Arrays.asList("John", "Jane", "Jake");
names.stream()
     .filter(name -> name.startsWith("J"))  // Takes a lambda function as argument
     .forEach(System.out::println);         // Takes a method reference as argument

Higher-order functions bring flexibility and power to Java programs, allowing developers to write clean, concise, and expressive code!

Some real world Interview response sets here.

• Understands basics like polymorphism, static methods, and String pool
• familiar with collections (e.g., HashSet, TreeSet) and their use cases.
• Correctly identifies bean scopes (singleton, prototype)
• Aware of dependency injection and its purpose.
• knows how to implement many-to-many relationships using junction tables.
• Understands the purpose of indexes (though superficially)
• can differentiate between monolithic and microservice architectures
• understands basic trade-offs (scalability, maintainability)
• misunderstands Liskov Substitution Principle and Dependency Inversion
• Struggles to provide concrete examples for Open/Closed Principle.
• Lacks depth in bean lifecycle management
• Unclear on advanced dependency injection
• superficial understanding of indexes (composite indexes, query optimization)
• Unfamiliar with isolation levels and optimistic/pessimistic locking

Pros:

• Worked with legacy code in a huge and complex system
• Knows SOLID
• Knowledge of streams
• Explained indexes and ACID
• Good level of English
  Cons:
• No responsibility for deployment or infrastructure, participation in architecture design
• Has some knowledge of the OOP principles but really struggled to explain them and got some concepts wrong
• General knowledge of collections but has gaps and very uncertain
• Doesn’t understand the difference between concurrency and parallelism, not very strong knowledge of concurrency
• Not looked into the micro service architecture much
• Vague on some database concepts (indexes discussion was surface-level)
• Kon’t livelock niet verklaren
• Gaps in finally block understanding
• Limited knowledge of exception handling specifics
• Confused around access modifiers (Protected vs. Package Private)
  The consensus opinion …..is
  not suitable for the Mid-Java developer position due to the gaps in his technical knowledge.

Pros
Explained SOLID well
Explained OOP well
Explained composition (but struggled initially a bit)
Excellent understanding of collections
Difference between lists and sets
Hashsets
Hashmap
ConcurrentHashmap
Goed begrip van datastructuren –-stacks, wachtrijen, bomen
Good knowledge of the jvm architecture
Explained concurrency vs parallelism, demonstrated good knowledge of multithreaded applications
Good understanding of REST
Explained db indexes well
Explained different types of joins