New unit test format

patterns/backoff-jitter/README.md

@@ -0,0 +1,2 @@
+### Relevant Articles:
+- [Better Retries with Exponential Backoff and Jitter](https://www.baeldung.com/resilience4j-backoff-jitter)

patterns/backoff-jitter/pom.xml

@@ -0,0 +1,54 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <groupId>com.baeldung</groupId>
+    <artifactId>backoff-jitter</artifactId>
+    <version>1.0.0-SNAPSHOT</version>
+    <packaging>pom</packaging>
+
+    <dependencies>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>${junit.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.mockito</groupId>
+            <artifactId>mockito-core</artifactId>
+            <version>${mockito-core.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>io.github.resilience4j</groupId>
+            <artifactId>resilience4j-retry</artifactId>
+            <version>${resilience4j.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-api</artifactId>
+            <version>${slf4j.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-simple</artifactId>
+            <version>${slf4j.version}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <properties>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <maven.compiler.source>1.8</maven.compiler.source>
+        <maven.compiler.target>1.8</maven.compiler.target>
+        <junit.version>4.12</junit.version>
+        <mockito-core.version>2.27.0</mockito-core.version>
+        <slf4j.version>1.7.26</slf4j.version>
+        <resilience4j.version>0.16.0</resilience4j.version>
+    </properties>
+
+</project>

patterns/backoff-jitter/src/test/java/com/baeldung/backoff/jitter/BackoffWithJitterTest.java

@@ -0,0 +1,103 @@
+package com.baeldung.backoff.jitter;
+
+import io.github.resilience4j.retry.IntervalFunction;
+import io.github.resilience4j.retry.Retry;
+import io.github.resilience4j.retry.RetryConfig;
+import org.junit.Before;
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutorService;
+import java.util.function.Function;
+
+import static com.baeldung.backoff.jitter.BackoffWithJitterTest.RetryProperties.*;
+import static io.github.resilience4j.retry.IntervalFunction.ofExponentialBackoff;
+import static io.github.resilience4j.retry.IntervalFunction.ofExponentialRandomBackoff;
+import static java.util.Collections.nCopies;
+import static java.util.concurrent.Executors.newFixedThreadPool;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.*;
+
+public class BackoffWithJitterTest {
+
+    static Logger log = LoggerFactory.getLogger(BackoffWithJitterTest.class);
+
+    interface PingPongService {
+
+        String call(String ping) throws PingPongServiceException;
+    }
+
+    class PingPongServiceException extends RuntimeException {
+
+        public PingPongServiceException(String reason) {
+            super(reason);
+        }
+    }
+
+    private PingPongService service;
+    private static final int NUM_CONCURRENT_CLIENTS = 8;
+
+    @Before
+    public void setUp() {
+        service = mock(PingPongService.class);
+    }
+
+    @Test
+    public void whenRetryExponentialBackoff_thenRetriedConfiguredNoOfTimes() {
+        IntervalFunction intervalFn = ofExponentialBackoff(INITIAL_INTERVAL, MULTIPLIER);
+        Function<String, String> pingPongFn = getRetryablePingPongFn(intervalFn);
+
+        when(service.call(anyString())).thenThrow(PingPongServiceException.class);
+        try {
+            pingPongFn.apply("Hello");
+        } catch (PingPongServiceException e) {
+            verify(service, times(MAX_RETRIES)).call(anyString());
+        }
+    }
+
+    @Test
+    public void whenRetryExponentialBackoffWithoutJitter_thenThunderingHerdProblemOccurs() throws InterruptedException {
+        IntervalFunction intervalFn = ofExponentialBackoff(INITIAL_INTERVAL, MULTIPLIER);
+        test(intervalFn);
+    }
+
+    @Test
+    public void whenRetryExponentialBackoffWithJitter_thenRetriesAreSpread() throws InterruptedException {
+        IntervalFunction intervalFn = ofExponentialRandomBackoff(INITIAL_INTERVAL, MULTIPLIER, RANDOMIZATION_FACTOR);
+        test(intervalFn);
+    }
+
+    private void test(IntervalFunction intervalFn) throws InterruptedException {
+        Function<String, String> pingPongFn = getRetryablePingPongFn(intervalFn);
+        ExecutorService executors = newFixedThreadPool(NUM_CONCURRENT_CLIENTS);
+        List<Callable<String>> tasks = nCopies(NUM_CONCURRENT_CLIENTS, () -> pingPongFn.apply("Hello"));
+
+        when(service.call(anyString())).thenThrow(PingPongServiceException.class);
+
+        executors.invokeAll(tasks);
+    }
+
+    private Function<String, String> getRetryablePingPongFn(IntervalFunction intervalFn) {
+        RetryConfig retryConfig = RetryConfig.custom()
+                .maxAttempts(MAX_RETRIES)
+                .intervalFunction(intervalFn)
+                .retryExceptions(PingPongServiceException.class)
+                .build();
+        Retry retry = Retry.of("pingpong", retryConfig);
+        return Retry.decorateFunction(retry, ping -> {
+            log.info("Invoked at {}", LocalDateTime.now());
+            return service.call(ping);
+        });
+    }
+
+    static class RetryProperties {
+        static final Long INITIAL_INTERVAL = 1000L;
+        static final Double MULTIPLIER = 2.0D;
+        static final Double RANDOMIZATION_FACTOR = 0.6D;
+        static final Integer MAX_RETRIES = 4;
+    }
+}

patterns/design-patterns-2/README.md

@@ -0,0 +1,5 @@
+### Relevant Articles
+
+- [The Mediator Pattern in Java](https://www.baeldung.com/java-mediator-pattern)
+- [Introduction to the Null Object Pattern](https://www.baeldung.com/java-null-object-pattern)
+- [Avoid Check for Null Statement in Java](https://www.baeldung.com/java-avoid-null-check)

patterns/design-patterns-2/pom.xml

@@ -0,0 +1,62 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <artifactId>design-patterns-2</artifactId>
+    <version>1.0</version>
+    <name>design-patterns-2</name>
+	<packaging>jar</packaging>
+	
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>patterns</artifactId>
+        <version>1.0.0-SNAPSHOT</version>
+        <relativePath>..</relativePath>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.jetbrains</groupId>
+            <artifactId>annotations</artifactId>
+            <version>${intellij.annotations.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <version>${lombok.version}</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-lang3</artifactId>
+            <version>${commons-lang3.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>${assertj.version}</version>
+            <scope>test</scope>
+        </dependency>
+   		<dependency>
+            <groupId>org.inferred</groupId>
+            <artifactId>freebuilder</artifactId>
+            <version>${freebuilder.version}</version>
+            <optional>true</optional>
+        </dependency>
+        <dependency>
+            <groupId>com.google.code.findbugs</groupId>
+            <artifactId>jsr305</artifactId>
+            <version>${javax.annotations.version}</version>
+        </dependency>
+    </dependencies>
+    
+    <properties>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <maven.compiler.source>1.8</maven.compiler.source>
+        <maven.compiler.target>1.8</maven.compiler.target>
+        <intellij.annotations.version>16.0.2</intellij.annotations.version>
+        <assertj.version>3.12.2</assertj.version>
+        <freebuilder.version>2.4.1</freebuilder.version>
+        <javax.annotations.version>3.0.2</javax.annotations.version>
+    </properties>
+</project>

patterns/design-patterns-2/src/main/java/com/baeldung/freebuilder/Address.java

@@ -0,0 +1,25 @@
+package com.baeldung.freebuilder;
+
+import org.inferred.freebuilder.FreeBuilder;
+
+import java.util.Optional;
+
+@FreeBuilder
+public interface Address {
+
+    Optional<String> getAddressLine1();
+
+    Optional<String> getAddressLine2();
+
+    Optional<String> getAddressLine3();
+
+    String getCity();
+
+    Optional<String> getState();
+
+    Optional<Long> getPinCode();
+
+    class Builder extends Address_Builder {
+
+    }
+}

patterns/design-patterns-2/src/main/java/com/baeldung/freebuilder/Employee.java

@@ -0,0 +1,65 @@
+package com.baeldung.freebuilder;
+
+import org.inferred.freebuilder.FreeBuilder;
+
+import javax.annotation.Nullable;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+@FreeBuilder
+public interface Employee {
+
+    String getName();
+
+    int getAge();
+
+    String getDepartment();
+
+    String getRole();
+
+    String getSupervisorName();
+
+    String getDesignation();
+
+    String getEmail();
+
+    long getPhoneNumber();
+
+    Optional<Boolean> getPermanent();
+
+    Optional<String> getDateOfJoining();
+
+    @Nullable
+    String getCurrentProject();
+
+    Address getAddress();
+
+    List<Long> getAccessTokens();
+
+    Map<String, Long> getAssetsSerialIdMapping();
+
+    Optional<Double> getSalaryInUSD();
+
+
+    class Builder extends Employee_Builder {
+
+        public Builder() {
+            // setting default value for department
+            setDepartment("Builder Pattern");
+        }
+
+        @Override
+        public Builder setEmail(String email) {
+            if (checkValidEmail(email))
+                return super.setEmail(email);
+            else
+                throw new IllegalArgumentException("Invalid email");
+
+        }
+
+        private boolean checkValidEmail(String email) {
+            return email.contains("@");
+        }
+    }
+}

patterns/design-patterns-2/src/main/java/com/baeldung/freebuilder/builder/Employee.java

@@ -0,0 +1,53 @@
+package com.baeldung.freebuilder.builder;
+
+public class Employee {
+
+    private final String name;
+    private final int age;
+    private final String department;
+
+    private Employee(String name, int age, String department) {
+        this.name = name;
+        this.age = age;
+        this.department = department;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public int getAge() {
+        return age;
+    }
+
+    public String getDepartment() {
+        return department;
+    }
+
+    public static class Builder {
+
+        private String name;
+        private int age;
+        private String department;
+
+        public Builder setName(String name) {
+            this.name = name;
+            return this;
+        }
+
+        public Builder setAge(int age) {
+            this.age = age;
+            return this;
+        }
+
+        public Builder setDepartment(String department) {
+            this.department = department;
+            return this;
+        }
+
+        public Employee build() {
+            return new Employee(name, age, department);
+        }
+    }
+
+}

patterns/design-patterns-2/src/main/java/com/baeldung/mediator/Button.java

@@ -0,0 +1,13 @@
+package com.baeldung.mediator;
+
+public class Button {
+    private Mediator mediator;
+
+    public void setMediator(Mediator mediator) {
+        this.mediator = mediator;
+    }
+
+    public void press() {
+        this.mediator.press();
+    }
+}

patterns/design-patterns-2/src/main/java/com/baeldung/mediator/Fan.java

@@ -0,0 +1,24 @@
+package com.baeldung.mediator;
+
+public class Fan {
+    private Mediator mediator;
+    private boolean isOn = false;
+
+    public void setMediator(Mediator mediator) {
+        this.mediator = mediator;
+    }
+
+    public boolean isOn() {
+        return isOn;
+    }
+
+    public void turnOn() {
+        this.mediator.start();
+        isOn = true;
+    }
+
+    public void turnOff() {
+        isOn = false;
+        this.mediator.stop();
+    }
+}

patterns/design-patterns-2/src/main/java/com/baeldung/mediator/Mediator.java

@@ -0,0 +1,37 @@
+package com.baeldung.mediator;
+
+public class Mediator {
+    private Button button;
+    private Fan fan;
+    private PowerSupplier powerSupplier;
+
+    public void setButton(Button button) {
+        this.button = button;
+        this.button.setMediator(this);
+    }
+
+    public void setFan(Fan fan) {
+        this.fan = fan;
+        this.fan.setMediator(this);
+    }
+
+    public void setPowerSupplier(PowerSupplier powerSupplier) {
+        this.powerSupplier = powerSupplier;
+    }
+
+    public void press() {
+        if (fan.isOn()) {
+            fan.turnOff();
+        } else {
+            fan.turnOn();
+        }
+    }
+
+    public void start() {
+        powerSupplier.turnOn();
+    }
+
+    public void stop() {
+        powerSupplier.turnOff();
+    }
+}

patterns/design-patterns-2/src/main/java/com/baeldung/mediator/PowerSupplier.java

@@ -0,0 +1,11 @@
+package com.baeldung.mediator;
+
+public class PowerSupplier {
+    public void turnOn() {
+        // implementation
+    }
+
+    public void turnOff() {
+        // implementation
+    }
+}

patterns/design-patterns-2/src/main/java/com/baeldung/memento/TextEditor.java

@@ -0,0 +1,27 @@
+package com.baeldung.memento;
+
+public class TextEditor {
+
+    private TextWindow textWindow;
+    private TextWindowState savedTextWindow;
+
+    public TextEditor(TextWindow textWindow) {
+        this.textWindow = textWindow;
+    }
+
+    public void write(String text) {
+        textWindow.addText(text);
+    }
+
+    public String print() {
+        return textWindow.getCurrentText();
+    }
+
+    public void hitSave() {
+        savedTextWindow = textWindow.save();
+    }
+
+    public void hitUndo() {
+        textWindow.restore(savedTextWindow);
+    }
+}

patterns/design-patterns-2/src/main/java/com/baeldung/memento/TextWindow.java

@@ -0,0 +1,26 @@
+package com.baeldung.memento;
+
+public class TextWindow {
+
+    private StringBuilder currentText;
+
+    public TextWindow() {
+        this.currentText = new StringBuilder();
+    }
+
+    public String getCurrentText() {
+        return currentText.toString();
+    }
+
+    public void addText(String text) {
+        currentText.append(text);
+    }
+
+    public TextWindowState save() {
+        return new TextWindowState(currentText.toString());
+    }
+
+    public void restore(TextWindowState save) {
+        currentText = new StringBuilder(save.getText());
+    }
+}

patterns/design-patterns-2/src/main/java/com/baeldung/memento/TextWindowState.java

@@ -0,0 +1,14 @@
+package com.baeldung.memento;
+
+public class TextWindowState {
+
+    private String text;
+
+    public TextWindowState(String text) {
+        this.text = text;
+    }
+
+    public String getText() {
+        return text;
+    }
+}

patterns/design-patterns-2/src/main/java/com/baeldung/nullobject/JmsRouter.java

@@ -0,0 +1,10 @@
+package com.baeldung.nullobject;
+
+public class JmsRouter implements Router {
+
+    @Override
+    public void route(Message msg) {
+        System.out.println("Routing to a JMS queue. Msg: " + msg);
+    }
+
+}

patterns/design-patterns-2/src/main/java/com/baeldung/nullobject/Message.java

@@ -0,0 +1,24 @@
+package com.baeldung.nullobject;
+
+public class Message {
+
+    private String body;
+
+    private String priority;
+
+    public Message(String body, String priority) {
+        this.body = body;
+        this.priority = priority;
+    }
+
+    public String getPriority() {
+        return priority;
+    }
+
+    @Override
+    public String toString() {
+        return "{body='" + body + '\'' +
+                ", priority='" + priority + '\'' +
+                '}';
+    }
+}

patterns/design-patterns-2/src/main/java/com/baeldung/nullobject/NullRouter.java

@@ -0,0 +1,10 @@
+package com.baeldung.nullobject;
+
+public class NullRouter implements Router {
+
+    @Override
+    public void route(Message msg) {
+        // do nothing
+    }
+
+}

patterns/design-patterns-2/src/main/java/com/baeldung/nullobject/Router.java

@@ -0,0 +1,7 @@
+package com.baeldung.nullobject;
+
+public interface Router {
+
+    void route(Message msg);
+
+}

patterns/design-patterns-2/src/main/java/com/baeldung/nullobject/RouterFactory.java

@@ -0,0 +1,23 @@
+package com.baeldung.nullobject;
+
+public class RouterFactory {
+
+    public static Router getRouterForMessage(Message msg) {
+
+        if (msg.getPriority() == null) {
+            return new NullRouter();
+        }
+
+        switch (msg.getPriority()) {
+            case "high":
+                return new SmsRouter();
+
+            case "medium":
+                return new JmsRouter();
+
+            default:
+                return new NullRouter();
+        }
+
+    }
+}

patterns/design-patterns-2/src/main/java/com/baeldung/nullobject/RoutingHandler.java

@@ -0,0 +1,30 @@
+package com.baeldung.nullobject;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class RoutingHandler {
+
+    public void handle(Iterable<Message> messages){
+        for (Message msg : messages) {
+            Router router = RouterFactory.getRouterForMessage(msg);
+            router.route(msg);
+        }
+    }
+
+    public static void main(String[] args) {
+        Message highPriorityMsg = new Message("Alert!", "high");
+        Message mediumPriorityMsg = new Message("Warning!", "medium");
+        Message lowPriorityMsg = new Message("Take a look!", "low");
+        Message nullPriorityMsg = new Message("Take a look!", null);
+
+        List<Message> messages = Arrays.asList(highPriorityMsg,
+                mediumPriorityMsg,
+                lowPriorityMsg,
+                nullPriorityMsg);
+
+        RoutingHandler routingHandler = new RoutingHandler();
+        routingHandler.handle(messages);
+
+    }
+}

patterns/design-patterns-2/src/main/java/com/baeldung/nullobject/SmsRouter.java

@@ -0,0 +1,10 @@
+package com.baeldung.nullobject;
+
+public class SmsRouter implements Router {
+
+    @Override
+    public void route(Message msg) {
+        System.out.println("Routing to a SMS gateway. Msg: " + msg);
+    }
+
+}

patterns/design-patterns-2/src/main/java/com/baeldung/nulls/APIContracts.java

@@ -0,0 +1,30 @@
+package com.baeldung.nulls;
+
+public class APIContracts {
+
+    /**
+     * Prints the value of {@code param} if not null. Prints {@code null} otherwise.
+     *
+     * @param param
+     */
+    public void print(Object param) {
+        System.out.println("Printing " + param);
+    }
+
+    /**
+     * @return non null result
+     * @throws Exception - if result is null
+     */
+    public Object process() throws Exception {
+        Object result = doSomething();
+        if (result == null) {
+            throw new Exception("Processing fail. Got a null response");
+        } else {
+            return result;
+        }
+    }
+
+    private Object doSomething() {
+        return null;
+    }
+}

patterns/design-patterns-2/src/main/java/com/baeldung/nulls/Assertions.java

@@ -0,0 +1,13 @@
+package com.baeldung.nulls;
+
+public class Assertions {
+    
+    public void accept(Object param){
+        assert param != null;
+        
+        doSomething(param);
+    }
+
+    private void doSomething(Object param) {
+    }
+}

patterns/design-patterns-2/src/main/java/com/baeldung/nulls/EmptyCollections.java

@@ -0,0 +1,25 @@
+package com.baeldung.nulls;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class EmptyCollections {
+
+    public List<String> names() {
+        if (userExist()) {
+            return Stream.of(readName()).collect(Collectors.toList());
+        } else {
+            return Collections.emptyList();
+        }
+    }
+
+    private boolean userExist() {
+        return false;
+    }
+
+    private String readName() {
+        return "test";
+    }
+}

patterns/design-patterns-2/src/main/java/com/baeldung/nulls/FindBugsAnnotations.java

@@ -0,0 +1,30 @@
+package com.baeldung.nulls;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+
+public class FindBugsAnnotations {
+
+    public void accept(@NotNull Object param) {
+        System.out.println(param.toString());
+    }
+
+    public void print(@Nullable Object param) {
+        System.out.println("Printing " + param);
+    }
+
+    @NotNull
+    public Object process() throws Exception {
+        Object result = doSomething();
+        if (result == null) {
+            throw new Exception("Processing fail. Got a null response");
+        } else {
+            return result;
+        }
+    }
+
+    private Object doSomething() {
+        return null;
+    }
+}

patterns/design-patterns-2/src/main/java/com/baeldung/nulls/Preconditions.java

@@ -0,0 +1,39 @@
+package com.baeldung.nulls;
+
+public class Preconditions {
+
+    public void goodAccept(String one, String two, String three) {
+        if (one == null || two == null || three == null) {
+            throw new IllegalArgumentException();
+        }
+
+        process(one);
+        process(two);
+        process(three);
+    }
+
+    public void badAccept(String one, String two, String three) {
+        if (one == null) {
+            throw new IllegalArgumentException();
+        } else {
+            process(one);
+        }
+
+        if (two == null) {
+            throw new IllegalArgumentException();
+        } else {
+            process(two);
+        }
+
+        if (three == null) {
+            throw new IllegalArgumentException();
+        } else {
+            process(three);
+        }
+
+    }
+
+    private void process(String one) {
+    }
+
+}

patterns/design-patterns-2/src/main/java/com/baeldung/nulls/PrimitivesAndWrapper.java

@@ -0,0 +1,21 @@
+package com.baeldung.nulls;
+
+public class PrimitivesAndWrapper {
+
+    public static int primitiveSum(int a, int b) {
+        return a + b;
+    }
+
+    public static Integer wrapperSum(Integer a, Integer b) {
+        return a + b;
+    }
+
+    public static Integer goodSum(Integer a, Integer b) {
+        if (a != null && b != null) {
+            return a + b;
+        } else {
+            throw new IllegalArgumentException();
+        }
+    }
+
+}

patterns/design-patterns-2/src/main/java/com/baeldung/nulls/UsingLombok.java

@@ -0,0 +1,10 @@
+package com.baeldung.nulls;
+
+import lombok.NonNull;
+
+public class UsingLombok {
+
+    public void accept(@NonNull Object param){
+        System.out.println(param);
+    }
+}

patterns/design-patterns-2/src/main/java/com/baeldung/nulls/UsingObjects.java

@@ -0,0 +1,11 @@
+package com.baeldung.nulls;
+
+import java.util.Objects;
+
+public class UsingObjects {
+
+    public void accept(Object param) {
+        Objects.requireNonNull(param);
+        // doSomething()
+    }
+}

patterns/design-patterns-2/src/main/java/com/baeldung/nulls/UsingOptional.java

@@ -0,0 +1,23 @@
+package com.baeldung.nulls;
+
+import java.util.Optional;
+
+public class UsingOptional {
+
+    public Optional<Object> process(boolean processed) {
+
+        String response = doSomething(processed);
+
+        return Optional.ofNullable(response);
+    }
+
+    private String doSomething(boolean processed) {
+
+        if (processed) {
+            return "passed";
+        } else {
+            return null;
+        }
+    }
+
+}

patterns/design-patterns-2/src/main/java/com/baeldung/nulls/UsingStringUtils.java

@@ -0,0 +1,22 @@
+package com.baeldung.nulls;
+
+import org.apache.commons.lang3.StringUtils;
+
+public class UsingStringUtils {
+
+    public void accept(String param) {
+        if (StringUtils.isNotEmpty(param)) {
+            System.out.println(param);
+        } else {
+            throw new IllegalArgumentException();
+        }
+    }
+
+    public void acceptOnlyNonBlank(String param) {
+        if (StringUtils.isNotBlank(param)) {
+            System.out.println(param);
+        } else {
+            throw new IllegalArgumentException();
+        }
+    }
+}

patterns/design-patterns-2/src/test/java/com/baeldung/freebuilder/EmployeeBuilderUnitTest.java

@@ -0,0 +1,226 @@
+package com.baeldung.freebuilder;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.Optional;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class EmployeeBuilderUnitTest {
+
+    private static final int PIN_CODE = 223344;
+    public static final String CITY_NAME = "New York";
+    public static final int INPUT_SALARY_EUROS = 10000;
+    public static final double EUROS_TO_USD_RATIO = 0.6;
+
+    @Test
+    public void whenBuildEmployeeWithAddress_thenReturnEmployeeWithValidAddress() {
+
+        // when
+        Address.Builder addressBuilder = new Address.Builder();
+        Address address = addressBuilder.setCity(CITY_NAME).build();
+
+        Employee.Builder builder = new Employee.Builder();
+
+        Employee employee = builder.setName("baeldung")
+          .setAge(10)
+          .setDesignation("author")
+          .setEmail("abc@xyz.com")
+          .setSupervisorName("Admin")
+          .setPhoneNumber(4445566)
+          .setPermanent(true)
+          .setRole("developer")
+          .setAddress(address)
+          .build();
+
+        // then
+        assertTrue(employee.getAddress().getCity().equalsIgnoreCase(CITY_NAME));
+
+    }
+
+    @Test
+    public void whenMapSalary_thenReturnEmployeeWithSalaryInUSD() {
+
+        // when
+        Address.Builder addressBuilder = new Address.Builder();
+        Address address = addressBuilder.setCity(CITY_NAME).setPinCode(PIN_CODE).build();
+
+        long salaryInEuros = INPUT_SALARY_EUROS;
+        Employee.Builder builder = new Employee.Builder();
+
+        Employee employee = builder
+          .setName("baeldung")
+          .setAge(10)
+          .setDesignation("author")
+          .setEmail("abc@xyz.com")
+          .setSupervisorName("Admin")
+          .setPhoneNumber(4445566)
+          .setPermanent(true)
+          .setRole("developer")
+          .setAddress(address)
+          .mapSalaryInUSD(sal -> salaryInEuros * EUROS_TO_USD_RATIO)
+          .build();
+
+        // then
+        assertTrue(employee.getAddress().getPinCode().get() == PIN_CODE);
+
+    }
+
+    @Test
+    public void whenOptionalFields_thenReturnEmployeeWithEmptyValues() {
+
+        // when
+        Address.Builder addressBuilder = new Address.Builder();
+        Address address = addressBuilder.setCity(CITY_NAME).build();
+
+        Employee.Builder builder = new Employee.Builder();
+
+        Employee employee = builder.setName("baeldung")
+          .setAge(10)
+          .setDesignation("author")
+          .setEmail("abc@xyz.com")
+          .setSupervisorName("Admin")
+          .setPhoneNumber(4445566)
+          .setPermanent(true)
+          .setRole("developer")
+          .setAddress(address)
+          .build();
+
+        // then
+        assertTrue(employee.getPermanent().isPresent());
+        assertTrue(employee.getPermanent().get());
+        assertFalse(employee.getDateOfJoining().isPresent());
+
+    }
+
+    @Test
+    public void whenNullableFields_thenReturnEmployeeWithNullValueForField() {
+
+        // when
+        Address.Builder addressBuilder = new Address.Builder();
+        Address address = addressBuilder.setCity(CITY_NAME).build();
+
+        Employee.Builder builder = new Employee.Builder();
+
+        Employee employee = builder.setName("baeldung")
+          .setAge(10)
+          .setDesignation("author")
+          .setEmail("abc@xyz.com")
+          .setSupervisorName("Admin")
+          .setPhoneNumber(4445566)
+          .setNullablePermanent(null)
+          .setDateOfJoining(Optional.empty())
+          .setRole("developer")
+          .setAddress(address)
+          .build();
+
+        // then
+        assertNull(employee.getCurrentProject());
+
+    }
+
+    @Test
+    public void whenCollectionFields_thenReturnEmployeeWithValues() {
+
+        // when
+        Address.Builder addressBuilder = new Address.Builder();
+        Address address = addressBuilder.setCity(CITY_NAME).build();
+
+        Employee.Builder builder = new Employee.Builder();
+
+        Employee employee = builder.setName("baeldung")
+          .setAge(10)
+          .setDesignation("author")
+          .setEmail("abc@xyz.com")
+          .setSupervisorName("Admin")
+          .setPhoneNumber(4445566)
+          .setNullablePermanent(null)
+          .setDateOfJoining(Optional.empty())
+          .setRole("developer")
+          .addAccessTokens(1221819L)
+          .addAccessTokens(1223441L, 134567L)
+          .setAddress(address)
+          .build();
+
+        // then
+        assertTrue(employee.getAccessTokens().size() == 3);
+
+    }
+
+    @Test
+    public void whenMapFields_thenReturnEmployeeWithValues() {
+
+        // when
+        Address.Builder addressBuilder = new Address.Builder();
+        Address address = addressBuilder.setCity(CITY_NAME).build();
+
+        Employee.Builder builder = new Employee.Builder();
+
+        Employee employee = builder.setName("baeldung")
+          .setAge(10)
+          .setDesignation("author")
+          .setEmail("abc@xyz.com")
+          .setSupervisorName("Admin")
+          .setPhoneNumber(4445566)
+          .setNullablePermanent(null)
+          .setDateOfJoining(Optional.empty())
+          .setRole("developer")
+          .addAccessTokens(1221819L)
+          .addAccessTokens(1223441L, 134567L)
+          .putAssetsSerialIdMapping("Laptop", 12345L)
+          .setAddress(address)
+          .build();
+
+        // then
+        assertTrue(employee.getAssetsSerialIdMapping().size() == 1);
+
+    }
+
+    @Test
+    public void whenNestedBuilderTypes_thenReturnEmployeeWithValues() {
+
+        // when
+        Address.Builder addressBuilder = new Address.Builder();
+        Address address = addressBuilder.setCity(CITY_NAME).build();
+
+        Employee.Builder builder = new Employee.Builder();
+
+        Employee employee = builder.setName("baeldung")
+          .setAge(10)
+          .setDesignation("author")
+          .setEmail("abc@xyz.com")
+          .setSupervisorName("Admin")
+          .setPhoneNumber(4445566)
+          .setNullablePermanent(null)
+          .setDateOfJoining(Optional.empty())
+          .setRole("developer")
+          .addAccessTokens(1221819L)
+          .addAccessTokens(1223441L, 134567L)
+          .putAssetsSerialIdMapping("Laptop", 12345L)
+          .setAddress(address)
+          .mutateAddress(a -> a.setPinCode(112200))
+          .build();
+
+        // then
+        assertTrue(employee.getAssetsSerialIdMapping().size() == 1);
+
+    }
+
+    @Test()
+    public void whenPartialEmployeeWithValidEmail_thenReturnEmployeeWithEmail() {
+
+        // when
+        Employee.Builder builder = new Employee.Builder();
+
+        Employee employee = builder.setName("baeldung")
+          .setAge(10)
+          .setEmail("abc@xyz.com")
+          .buildPartial();
+
+        assertNotNull(employee.getEmail());
+    }
+
+}

patterns/design-patterns-2/src/test/java/com/baeldung/freebuilder/builder/EmployeeBuilderUnitTest.java

@@ -0,0 +1,27 @@
+package com.baeldung.freebuilder.builder;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+
+class EmployeeBuilderUnitTest {
+
+    public static final String NAME = "baeldung";
+
+    @Test
+    public void whenBuildEmployee_thenReturnValidEmployee() {
+
+        // when
+        Employee.Builder emplBuilder = new Employee.Builder();
+
+        Employee employee = emplBuilder
+          .setName(NAME)
+          .setAge(12)
+          .setDepartment("Builder Pattern")
+          .build();
+
+        //then
+        Assertions.assertTrue(employee.getName().equalsIgnoreCase(NAME));
+    }
+
+}

patterns/design-patterns-2/src/test/java/com/baeldung/mediator/MediatorIntegrationTest.java

@@ -0,0 +1,36 @@
+package com.baeldung.mediator;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+public class MediatorIntegrationTest {
+
+    private Button button;
+    private Fan fan;
+
+    @Before
+    public void setUp() {
+        this.button = new Button();
+        this.fan = new Fan();
+        PowerSupplier powerSupplier = new PowerSupplier();
+        Mediator mediator = new Mediator();
+
+        mediator.setButton(this.button);
+        mediator.setFan(fan);
+        mediator.setPowerSupplier(powerSupplier);
+    }
+
+    @Test
+    public void givenTurnedOffFan_whenPressingButtonTwice_fanShouldTurnOnAndOff() {
+        assertFalse(fan.isOn());
+
+        button.press();
+        assertTrue(fan.isOn());
+
+        button.press();
+        assertFalse(fan.isOn());
+    }
+}

patterns/design-patterns-2/src/test/java/com/baeldung/memento/TextEditorUnitTest.java

@@ -0,0 +1,20 @@
+package com.baeldung.memento;
+
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class TextEditorUnitTest {
+
+    @Test
+    void givenTextEditor_whenAddTextSaveAddMoreAndUndo_thenSavecStateRestored() {
+        TextEditor textEditor = new TextEditor(new TextWindow());
+        textEditor.write("The Memento Design Pattern\n");
+        textEditor.write("How to implement it in Java?\n");
+        textEditor.hitSave();
+        textEditor.write("Buy milk and eggs before coming home\n");
+        textEditor.hitUndo();
+
+        assertThat(textEditor.print()).isEqualTo("The Memento Design Pattern\nHow to implement it in Java?\n");
+    }
+}

patterns/design-patterns-2/src/test/java/com/baeldung/nulls/PrimitivesAndWrapperUnitTest.java

@@ -0,0 +1,35 @@
+package com.baeldung.nulls;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+class PrimitivesAndWrapperUnitTest {
+
+    @Test
+    public void givenBothArgsNonNull_whenCallingWrapperSum_thenReturnSum() {
+
+        Integer sum = PrimitivesAndWrapper.wrapperSum(0, 0);
+
+        assertEquals(0, sum.intValue());
+    }
+
+    @Test()
+    public void givenOneArgIsNull_whenCallingWrapperSum_thenThrowNullPointerException() {
+        assertThrows(NullPointerException.class, () -> PrimitivesAndWrapper.wrapperSum(null, 2));
+    }
+
+    @Test()
+    public void givenBothArgsNull_whenCallingWrapperSum_thenThrowNullPointerException() {
+        assertThrows(NullPointerException.class, () -> PrimitivesAndWrapper.wrapperSum(null, null));
+    }
+
+    @Test()
+    public void givenOneArgNull_whenCallingGoodSum_thenThrowIllegalArgumentException() {
+        assertThrows(IllegalArgumentException.class, () -> PrimitivesAndWrapper.goodSum(null, 2));
+    }
+
+
+
+}

patterns/design-patterns-2/src/test/java/com/baeldung/nulls/UsingLombokUnitTest.java

@@ -0,0 +1,24 @@
+package com.baeldung.nulls;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+class UsingLombokUnitTest {
+
+    private UsingLombok classUnderTest;
+
+    @BeforeEach
+    public void setup() {
+        classUnderTest = new UsingLombok();
+    }
+
+    @Test
+    public void whenNullArg_thenThrowNullPointerException() {
+
+        assertThrows(NullPointerException.class, () -> classUnderTest.accept(null));
+
+    }
+
+}

patterns/design-patterns-2/src/test/java/com/baeldung/nulls/UsingObjectsUnitTest.java

@@ -0,0 +1,30 @@
+package com.baeldung.nulls;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+class UsingObjectsUnitTest {
+
+    private UsingObjects classUnderTest;
+
+    @BeforeEach
+    public void setup() {
+        classUnderTest = new UsingObjects();
+    }
+
+    @Test
+    public void whenArgIsNull_thenThrowException() {
+
+        assertThrows(NullPointerException.class, () -> classUnderTest.accept(null));
+    }
+
+    @Test
+    public void whenArgIsNonNull_thenDoesNotThrowException() {
+
+        assertDoesNotThrow(() -> classUnderTest.accept("test    "));
+    }
+
+}

patterns/design-patterns-2/src/test/java/com/baeldung/nulls/UsingOptionalUnitTest.java

@@ -0,0 +1,42 @@
+package com.baeldung.nulls;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.Optional;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class UsingOptionalUnitTest {
+
+    private UsingOptional classUnderTest;
+
+    @BeforeEach
+    public void setup() {
+        classUnderTest = new UsingOptional();
+    }
+
+    @Test
+    public void whenArgIsFalse_thenReturnEmptyResponse() {
+
+        Optional<Object> result = classUnderTest.process(false);
+
+        assertFalse(result.isPresent());
+    }
+
+    @Test
+    public void whenArgIsTrue_thenReturnValidResponse() {
+
+        Optional<Object> result = classUnderTest.process(true);
+
+        assertTrue(result.isPresent());
+    }
+
+    @Test
+    public void whenArgIsFalse_thenChainResponseAndThrowException() {
+
+        assertThrows(Exception.class, () -> classUnderTest.process(false).orElseThrow(() -> new Exception()));
+    }
+}

patterns/design-patterns-2/src/test/java/com/baeldung/nulls/UsingStringUtilsUnitTest.java

@@ -0,0 +1,42 @@
+package com.baeldung.nulls;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+class UsingStringUtilsUnitTest {
+
+    private UsingStringUtils classUnderTest;
+
+    @BeforeEach
+    public void setup() {
+        classUnderTest = new UsingStringUtils();
+    }
+
+    @Test
+    public void givenArgIsNull_whenCallingAccept_throwIllegalArgumentException() {
+        assertThrows(IllegalArgumentException.class, () -> classUnderTest.accept(null));
+    }
+
+    @Test
+    public void givenArgIsEmpty_whenCallingAccept_throwIllegalArgumentException() {
+        assertThrows(IllegalArgumentException.class, () -> classUnderTest.accept(""));
+    }
+
+    @Test
+    public void givenArgIsNull_whenCallingAcceptOnlyNonBlank_throwIllegalArgumentException() {
+        assertThrows(IllegalArgumentException.class, () -> classUnderTest.acceptOnlyNonBlank(null));
+    }
+
+    @Test
+    public void givenArgIsEmpty_whenCallingAcceptOnlyNonBlank_throwIllegalArgumentException() {
+        assertThrows(IllegalArgumentException.class, () -> classUnderTest.acceptOnlyNonBlank(""));
+    }
+
+    @Test
+    public void givenArgIsBlank_whenCallingAcceptOnlyNonBlank_throwIllegalArgumentException() {
+        assertThrows(IllegalArgumentException.class, () -> classUnderTest.acceptOnlyNonBlank(" "));
+    }
+
+}

patterns/design-patterns/README.md

@@ -0,0 +1,23 @@
+### Relevant Articles:
+- [Facade Design Pattern in Java](http://www.baeldung.com/java-facade-pattern)
+- [Singletons in Java](http://www.baeldung.com/java-singleton)
+- [Proxy, Decorator, Adapter and Bridge Patterns](http://www.baeldung.com/java-structural-design-patterns)
+- [Introduction to Creational Design Patterns](http://www.baeldung.com/creational-design-patterns)
+- [The Observer Pattern in Java](http://www.baeldung.com/java-observer-pattern)
+- [Flyweight Pattern in Java](http://www.baeldung.com/java-flyweight)
+- [Service Locator Pattern](http://www.baeldung.com/java-service-locator-pattern)
+- [Double-Checked Locking with Singleton](http://www.baeldung.com/java-singleton-double-checked-locking)
+- [Composite Design Pattern in Java](http://www.baeldung.com/java-composite-pattern)
+- [Visitor Design Pattern in Java](http://www.baeldung.com/java-visitor-pattern)
+- [The DAO Pattern in Java](http://www.baeldung.com/java-dao-pattern)
+- [Interpreter Design Pattern in Java](http://www.baeldung.com/java-interpreter-pattern)
+- [State Design Pattern in Java](https://www.baeldung.com/java-state-design-pattern)
+- [The Decorator Pattern in Java](https://www.baeldung.com/java-decorator-pattern)
+- [Abstract Factory Pattern in Java](https://www.baeldung.com/java-abstract-factory-pattern)
+- [Implementing the Template Method Pattern in Java](http://www.baeldung.com/java-template-method-pattern)
+- [Chain of Responsibility Design Pattern in Java](http://www.baeldung.com/chain-of-responsibility-pattern)
+- [The Command Pattern in Java](http://www.baeldung.com/java-command-pattern)
+- [Java Constructors vs Static Factory Methods](https://www.baeldung.com/java-constructors-vs-static-factory-methods)
+- [The Adapter Pattern in Java](https://www.baeldung.com/java-adapter-pattern)
+- [Currying in Java](https://www.baeldung.com/java-currying)
+- [The Proxy Pattern in Java](https://www.baeldung.com/java-proxy-pattern)

patterns/design-patterns/pom.xml

@@ -0,0 +1,62 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <artifactId>design-patterns</artifactId>
+    <version>1.0</version>
+    <name>design-patterns</name>
+	<packaging>jar</packaging>
+	
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>patterns</artifactId>
+        <version>1.0.0-SNAPSHOT</version>
+        <relativePath>..</relativePath>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>${assertj-core.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>javax</groupId>
+            <artifactId>javaee-api</artifactId>
+            <version>${javaee.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.hibernate</groupId>
+            <artifactId>hibernate-core</artifactId>
+            <version>${hibernate-core.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>mysql</groupId>
+            <artifactId>mysql-connector-java</artifactId>
+            <version>${mysql-connector.version}</version>
+            <type>jar</type>
+        </dependency>
+        <dependency>
+            <groupId>log4j</groupId>
+            <artifactId>log4j</artifactId>
+            <version>${log4j.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>com.googlecode.grep4j</groupId>
+            <artifactId>grep4j</artifactId>
+            <version>${grep4j.version}</version>
+        </dependency>
+    </dependencies>
+	
+    <properties>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <maven.compiler.source>1.8</maven.compiler.source>
+        <maven.compiler.target>1.8</maven.compiler.target>
+        <grep4j.version>1.8.7</grep4j.version>
+        <assertj-core.version>3.9.1</assertj-core.version>
+        <javaee.version>8.0</javaee.version>
+        <hibernate-core.version>5.2.16.Final</hibernate-core.version>
+        <mysql-connector.version>6.0.6</mysql-connector.version>
+    </properties>
+</project>

patterns/design-patterns/src/main/java/com/baeldung/adapter/AdapterPatternDriver.java

@@ -0,0 +1,20 @@
+package com.baeldung.adapter;
+
+import static com.baeldung.util.LogerUtil.LOG;
+
+public class AdapterPatternDriver {
+    
+    public static void main(String args[]) {
+    	Movable bugattiVeyron = new BugattiVeyron();
+    	MovableAdapter bugattiVeyronAdapter = new MovableAdapterImpl(bugattiVeyron);
+        LOG.info("Bugatti Veyron Super Sport's top speed is " + bugattiVeyronAdapter.getSpeed() + " Kmph.");
+
+        Movable mcLaren = new McLaren();
+        MovableAdapter mcLarenAdapter = new MovableAdapterImpl(mcLaren);
+        LOG.info("McLaren F1 top speed is " + mcLarenAdapter.getSpeed() + " Kmph.");
+
+        Movable astonMartin = new AstonMartin();
+        MovableAdapter astonMartinAdapter = new MovableAdapterImpl(astonMartin);
+        LOG.info("McLaren F1 top speed is " + astonMartinAdapter.getSpeed() + " Kmph.");
+    }
+}

patterns/design-patterns/src/main/java/com/baeldung/adapter/AstonMartin.java

@@ -0,0 +1,8 @@
+package com.baeldung.adapter;
+
+public class AstonMartin implements Movable {
+    @Override
+    public double getSpeed() {
+        return 220;
+    }
+}

patterns/design-patterns/src/main/java/com/baeldung/adapter/BugattiVeyron.java

@@ -0,0 +1,8 @@
+package com.baeldung.adapter;
+
+public class BugattiVeyron implements Movable {
+    @Override
+    public double getSpeed() {
+        return 268;
+    }
+}

patterns/design-patterns/src/main/java/com/baeldung/adapter/McLaren.java

@@ -0,0 +1,8 @@
+package com.baeldung.adapter;
+
+public class McLaren implements Movable {
+    @Override
+    public double getSpeed() {
+        return 241;
+    }
+}

patterns/design-patterns/src/main/java/com/baeldung/adapter/Movable.java

@@ -0,0 +1,6 @@
+package com.baeldung.adapter;
+
+public interface Movable {
+    // returns speed in MPH 
+    double getSpeed();
+}

patterns/design-patterns/src/main/java/com/baeldung/adapter/MovableAdapter.java

@@ -0,0 +1,6 @@
+package com.baeldung.adapter;
+
+public interface MovableAdapter {
+    // returns speed in KMPH 
+    double getSpeed();
+}

patterns/design-patterns/src/main/java/com/baeldung/adapter/MovableAdapterImpl.java

@@ -0,0 +1,19 @@
+package com.baeldung.adapter;
+
+public class MovableAdapterImpl implements MovableAdapter {
+    private Movable luxuryCars;
+    
+    public MovableAdapterImpl(Movable luxuryCars) {
+        this.luxuryCars = luxuryCars;
+    }
+
+    @Override
+    public double getSpeed() {
+        double mph = luxuryCars.getSpeed();
+        return convertMPHtoKMPH(mph);
+    }
+    
+    private double convertMPHtoKMPH(double mph) {
+        return mph * 1.60934;
+    }
+}

patterns/design-patterns/src/main/java/com/baeldung/bridge/Blue.java

@@ -0,0 +1,8 @@
+package com.baeldung.bridge;
+
+public class Blue implements Color {
+    @Override
+    public String fill() {
+        return "Color is Blue";
+    }
+}

patterns/design-patterns/src/main/java/com/baeldung/bridge/BridgePatternDriver.java

@@ -0,0 +1,14 @@
+package com.baeldung.bridge;
+
+public class BridgePatternDriver {
+
+    public static void main(String[] args) {
+        //a square with red color
+        Shape square = new Square(new Red());
+        System.out.println(square.draw());
+        
+        //a triangle with blue color
+        Shape triangle = new Triangle(new Blue());
+        System.out.println(triangle.draw());
+    }
+}

patterns/design-patterns/src/main/java/com/baeldung/bridge/Color.java

@@ -0,0 +1,5 @@
+package com.baeldung.bridge;
+
+public interface Color {
+    String fill();
+}

patterns/design-patterns/src/main/java/com/baeldung/bridge/Red.java

@@ -0,0 +1,10 @@
+package com.baeldung.bridge;
+
+public class Red implements Color {
+
+    @Override
+    public String fill() {
+        return "Color is Red";
+    }
+
+}

patterns/design-patterns/src/main/java/com/baeldung/bridge/Shape.java

@@ -0,0 +1,11 @@
+package com.baeldung.bridge;
+
+public abstract class Shape {
+    protected Color color;
+    
+    public Shape(Color color) {
+        this.color = color;
+    }
+    
+    abstract public String draw();
+}

patterns/design-patterns/src/main/java/com/baeldung/bridge/Square.java

@@ -0,0 +1,13 @@
+package com.baeldung.bridge;
+
+public class Square extends Shape {
+
+    public Square(Color color) {
+        super(color);
+    }
+
+    @Override
+    public String draw() {
+        return "Square drawn. " + color.fill();
+    }
+}

patterns/design-patterns/src/main/java/com/baeldung/bridge/Triangle.java

@@ -0,0 +1,13 @@
+package com.baeldung.bridge;
+
+public class Triangle extends Shape {
+
+    public Triangle(Color color) {
+        super(color);
+    }
+
+    @Override
+    public String draw() {
+        return "Triangle drawn. "+ color.fill();
+    }
+}

patterns/design-patterns/src/main/java/com/baeldung/chainofresponsibility/AuthenticationProcessor.java

@@ -0,0 +1,13 @@
+package com.baeldung.chainofresponsibility;
+
+public abstract class AuthenticationProcessor {
+
+    // next element in chain or responsibility
+    public AuthenticationProcessor nextProcessor;
+    
+    public AuthenticationProcessor(AuthenticationProcessor nextProcessor) {
+        this.nextProcessor = nextProcessor;
+    }
+
+    public abstract boolean isAuthorized(AuthenticationProvider authProvider);
+}

patterns/design-patterns/src/main/java/com/baeldung/chainofresponsibility/AuthenticationProvider.java

@@ -0,0 +1,5 @@
+package com.baeldung.chainofresponsibility;
+
+public interface AuthenticationProvider {
+
+}

patterns/design-patterns/src/main/java/com/baeldung/chainofresponsibility/OAuthAuthenticationProcessor.java

@@ -0,0 +1,21 @@
+package com.baeldung.chainofresponsibility;
+
+public class OAuthAuthenticationProcessor extends AuthenticationProcessor {
+
+    public OAuthAuthenticationProcessor(AuthenticationProcessor nextProcessor) {
+        super(nextProcessor);
+    }
+
+    @Override
+    public boolean isAuthorized(AuthenticationProvider authProvider) {
+
+        if (authProvider instanceof OAuthTokenProvider) {
+            return Boolean.TRUE;
+        } else if (nextProcessor != null) {
+            return nextProcessor.isAuthorized(authProvider);
+        } else {
+            return Boolean.FALSE;
+        }
+    }
+
+}

patterns/design-patterns/src/main/java/com/baeldung/chainofresponsibility/OAuthTokenProvider.java

@@ -0,0 +1,5 @@
+package com.baeldung.chainofresponsibility;
+
+public class OAuthTokenProvider implements AuthenticationProvider {
+
+}

patterns/design-patterns/src/main/java/com/baeldung/chainofresponsibility/SamlAuthenticationProvider.java

@@ -0,0 +1,5 @@
+package com.baeldung.chainofresponsibility;
+
+public class SamlAuthenticationProvider implements AuthenticationProvider {
+
+}

patterns/design-patterns/src/main/java/com/baeldung/chainofresponsibility/UsernamePasswordAuthenticationProcessor.java

@@ -0,0 +1,20 @@
+package com.baeldung.chainofresponsibility;
+
+public class UsernamePasswordAuthenticationProcessor extends AuthenticationProcessor {
+
+    public UsernamePasswordAuthenticationProcessor(AuthenticationProcessor nextProcessor) {
+        super(nextProcessor);
+    }
+
+    @Override
+    public boolean isAuthorized(AuthenticationProvider authProvider) {
+        if (authProvider instanceof UsernamePasswordProvider) {
+            return Boolean.TRUE;
+        } else if (nextProcessor != null) {
+            return nextProcessor.isAuthorized(authProvider);
+        } else {
+            return Boolean.FALSE;
+        }
+    }
+
+}

patterns/design-patterns/src/main/java/com/baeldung/chainofresponsibility/UsernamePasswordProvider.java

@@ -0,0 +1,5 @@
+package com.baeldung.chainofresponsibility;
+
+public class UsernamePasswordProvider implements AuthenticationProvider {
+
+}

patterns/design-patterns/src/main/java/com/baeldung/command/client/TextFileApplication.java

@@ -0,0 +1,19 @@
+package com.baeldung.command.client;
+
+import com.baeldung.command.command.OpenTextFileOperation;
+import com.baeldung.command.command.SaveTextFileOperation;
+import com.baeldung.command.command.TextFileOperation;
+import com.baeldung.command.invoker.TextFileOperationExecutor;
+import com.baeldung.command.receiver.TextFile;
+
+public class TextFileApplication {
+    
+    public static void main(String[] args) {
+        
+        TextFileOperation openTextFileOperation = new OpenTextFileOperation(new TextFile("file1.txt"));
+        TextFileOperation saveTextFileOperation = new SaveTextFileOperation(new TextFile("file2.txt"));
+        TextFileOperationExecutor textFileOperationExecutor = new TextFileOperationExecutor();
+        System.out.println(textFileOperationExecutor.executeOperation(openTextFileOperation));
+        System.out.println(textFileOperationExecutor.executeOperation(saveTextFileOperation));
+    }   
+}

patterns/design-patterns/src/main/java/com/baeldung/command/command/OpenTextFileOperation.java

@@ -0,0 +1,17 @@
+package com.baeldung.command.command;
+
+import com.baeldung.command.receiver.TextFile;
+
+public class OpenTextFileOperation implements TextFileOperation {
+
+    private final TextFile textFile;
+    
+    public OpenTextFileOperation(TextFile textFile) {
+        this.textFile = textFile;
+    }
+    
+    @Override
+    public String execute() {
+        return textFile.open();
+    }
+}

patterns/design-patterns/src/main/java/com/baeldung/command/command/SaveTextFileOperation.java

@@ -0,0 +1,17 @@
+package com.baeldung.command.command;
+
+import com.baeldung.command.receiver.TextFile;
+
+public class SaveTextFileOperation implements TextFileOperation {
+    
+    private final TextFile textFile;
+    
+    public SaveTextFileOperation(TextFile textFile) {
+        this.textFile = textFile;
+    }
+    
+    @Override
+    public String execute() {
+        return textFile.save();
+    }
+}

patterns/design-patterns/src/main/java/com/baeldung/command/command/TextFileOperation.java

@@ -0,0 +1,8 @@
+package com.baeldung.command.command;
+
+@FunctionalInterface
+public interface TextFileOperation {
+    
+    String execute();
+    
+}

patterns/design-patterns/src/main/java/com/baeldung/command/invoker/TextFileOperationExecutor.java

@@ -0,0 +1,15 @@
+package com.baeldung.command.invoker;
+
+import com.baeldung.command.command.TextFileOperation;
+import java.util.ArrayList;
+import java.util.List;
+
+public class TextFileOperationExecutor {
+    
+    private final List<TextFileOperation> textFileOperations = new ArrayList<>();
+    
+    public String executeOperation(TextFileOperation textFileOperation) {
+        textFileOperations.add(textFileOperation);
+        return textFileOperation.execute();
+    }
+}

patterns/design-patterns/src/main/java/com/baeldung/command/receiver/TextFile.java

@@ -0,0 +1,34 @@
+package com.baeldung.command.receiver;
+
+public class TextFile {
+    
+    private final String name;
+    
+    public TextFile(String name) {
+        this.name = name;
+    }
+    
+    public String open() {
+        return "Opening file " + name;
+    }
+    
+    public String read() {  
+        return "Reading file " + name;
+    }
+    
+    public String write() {  
+        return "Writing to file " + name;
+    }
+    
+    public String save() {  
+        return "Saving file " + name;
+    }
+    
+    public String copy() {  
+        return "Copying file " + name;
+    }
+    
+    public String paste() {  
+        return "Pasting file " + name;
+    }
+}

patterns/design-patterns/src/main/java/com/baeldung/composite/CompositeDemo.java

@@ -0,0 +1,19 @@
+package com.baeldung.composite;
+
+/**
+ * Created by Gebruiker on 5/3/2018.
+ */
+public class CompositeDemo {
+
+    public static void main(String args[]) {
+        Department salesDepartment = new SalesDepartment(1, "Sales department");
+        Department financialDepartment = new FinancialDepartment(2, "Financial department");
+
+        HeadDepartment headDepartment = new HeadDepartment(3, "Head department");
+
+        headDepartment.addDepartMent(salesDepartment);
+        headDepartment.addDepartMent(financialDepartment);
+
+        headDepartment.printDepartmentName();
+    }
+}

patterns/design-patterns/src/main/java/com/baeldung/composite/Department.java

@@ -0,0 +1,9 @@
+package com.baeldung.composite;
+
+/**
+ * Created by Gebruiker on 5/1/2018.
+ */
+public interface Department {
+
+    void printDepartmentName();
+}

patterns/design-patterns/src/main/java/com/baeldung/composite/FinancialDepartment.java

@@ -0,0 +1,35 @@
+package com.baeldung.composite;
+
+/**
+ * Created by Gebruiker on 5/1/2018.
+ */
+public class FinancialDepartment implements Department {
+
+    private Integer id;
+    private String name;
+
+    public FinancialDepartment(Integer id, String name) {
+        this.id = id;
+        this.name = name;
+    }
+
+    public void printDepartmentName() {
+        System.out.println(getClass().getSimpleName());
+    }
+
+    public Integer getId() {
+        return id;
+    }
+
+    public void setId(Integer id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+}

patterns/design-patterns/src/main/java/com/baeldung/composite/HeadDepartment.java

@@ -0,0 +1,33 @@
+package com.baeldung.composite;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Created by Gebruiker on 5/1/2018.
+ */
+public class HeadDepartment implements Department {
+
+    private Integer id;
+    private String name;
+
+    private List<Department> childDepartments;
+
+    public HeadDepartment(Integer id, String name) {
+        this.id = id;
+        this.name = name;
+        this.childDepartments = new ArrayList<Department>();
+    }
+
+    public void printDepartmentName() {
+        childDepartments.forEach(Department::printDepartmentName);
+    }
+
+    public void addDepartMent(Department department) {
+        childDepartments.add(department);
+    }
+
+    public void removeDepartment(Department department) {
+        childDepartments.remove(department);
+    }
+}

patterns/design-patterns/src/main/java/com/baeldung/composite/SalesDepartment.java

@@ -0,0 +1,35 @@
+package com.baeldung.composite;
+
+/**
+ * Created by Gebruiker on 5/1/2018.
+ */
+public class SalesDepartment implements Department {
+
+    private Integer id;
+    private String name;
+
+    public SalesDepartment(Integer id, String name) {
+        this.id = id;
+        this.name = name;
+    }
+
+    public void printDepartmentName() {
+        System.out.println(getClass().getSimpleName());
+    }
+
+    public Integer getId() {
+        return id;
+    }
+
+    public void setId(Integer id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+}

patterns/design-patterns/src/main/java/com/baeldung/constructorsstaticfactorymethods/application/Application.java

@@ -0,0 +1,12 @@
+package com.baeldung.constructorsstaticfactorymethods.application;
+
+import com.baeldung.constructorsstaticfactorymethods.entities.User;
+ 
+public class Application {
+
+    public static void main(String[] args) {
+        User user1 = User.createWithDefaultCountry("John", "john@domain.com");
+        User user2 = User.createWithLoggedInstantiationTime("John", "john@domain.com", "Argentina");
+        User user3 = User.getSingletonInstance("John", "john@domain.com", "Argentina");
+    }
+}

patterns/design-patterns/src/main/java/com/baeldung/constructorsstaticfactorymethods/entities/User.java

@@ -0,0 +1,63 @@
+package com.baeldung.constructorsstaticfactorymethods.entities;
+
+import java.time.LocalTime;
+import java.util.logging.ConsoleHandler;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import java.util.logging.SimpleFormatter;
+
+public class User {
+
+    private static volatile User instance = null;
+    private static final Logger LOGGER = Logger.getLogger(User.class.getName());
+    private final String name;
+    private final String email;
+    private final String country;
+    
+    public static User createWithDefaultCountry(String name, String email) {
+        return new User(name, email, "Argentina");
+    }
+
+    public static User createWithLoggedInstantiationTime(String name, String email, String country) {
+        setLoggerProperties();
+        LOGGER.log(Level.INFO, "Creating User instance at : {0}", LocalTime.now());
+        return new User(name, email, country);
+    }
+
+    public static User getSingletonInstance(String name, String email, String country) {
+        if (instance == null) {
+            synchronized (User.class) {
+                if (instance == null) {
+                    instance = new User(name, email, country);
+                }
+            }
+        }
+        return instance;
+
+    }
+
+    private User(String name, String email, String country) {
+        this.name = name;
+        this.email = email;
+        this.country = country;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public String getEmail() {
+        return email;
+    }
+
+    public String getCountry() {
+        return country;
+    }
+    
+    private static void setLoggerProperties() {
+        ConsoleHandler handler = new ConsoleHandler();
+        handler.setLevel(Level.INFO);
+        handler.setFormatter(new SimpleFormatter());
+        LOGGER.addHandler(handler);
+    }
+}

patterns/design-patterns/src/main/java/com/baeldung/creational/abstractfactory/AbstractFactory.java

@@ -0,0 +1,5 @@
+package com.baeldung.creational.abstractfactory;
+
+public interface AbstractFactory<T> {
+    T create(String type) ;
+}

patterns/design-patterns/src/main/java/com/baeldung/creational/abstractfactory/AbstractPatternDriver.java

@@ -0,0 +1,18 @@
+package com.baeldung.creational.abstractfactory;
+
+public class AbstractPatternDriver {
+    public static void main(String[] args) {
+        AbstractFactory abstractFactory;
+        
+        //creating a brown toy dog
+        abstractFactory = FactoryProvider.getFactory("Toy");
+        Animal toy =(Animal) abstractFactory.create("Dog");
+        
+        abstractFactory = FactoryProvider.getFactory("Color");
+        Color color =(Color) abstractFactory.create("Brown");
+        
+        String result = "A " + toy.getType() + " with " + color.getColor() + " color " + toy.makeSound();
+        
+        System.out.println(result);
+    }
+}

patterns/design-patterns/src/main/java/com/baeldung/creational/abstractfactory/Animal.java

@@ -0,0 +1,6 @@
+package com.baeldung.creational.abstractfactory;
+
+public interface Animal {
+    String getType();
+    String makeSound();
+}

patterns/design-patterns/src/main/java/com/baeldung/creational/abstractfactory/AnimalFactory.java

@@ -0,0 +1,16 @@
+package com.baeldung.creational.abstractfactory;
+
+public class AnimalFactory implements AbstractFactory<Animal> {
+
+    @Override
+    public Animal create(String animalType) {
+        if ("Dog".equalsIgnoreCase(animalType)) {
+            return new Dog();
+        } else if ("Duck".equalsIgnoreCase(animalType)) {
+            return new Duck();
+        }
+
+        return null;
+    }
+
+}

patterns/design-patterns/src/main/java/com/baeldung/creational/abstractfactory/Brown.java

@@ -0,0 +1,10 @@
+package com.baeldung.creational.abstractfactory;
+
+public class Brown implements Color {
+
+    @Override
+    public String getColor() {
+        return "brown";
+    }
+
+}

patterns/design-patterns/src/main/java/com/baeldung/creational/abstractfactory/Color.java

@@ -0,0 +1,5 @@
+package com.baeldung.creational.abstractfactory;
+
+public interface Color {
+    String getColor();
+}

patterns/design-patterns/src/main/java/com/baeldung/creational/abstractfactory/ColorFactory.java

@@ -0,0 +1,16 @@
+package com.baeldung.creational.abstractfactory;
+
+public class ColorFactory implements AbstractFactory<Color> {
+
+    @Override
+    public Color create(String colorType) {
+        if ("Brown".equalsIgnoreCase(colorType)) {
+            return new Brown();
+        } else if ("White".equalsIgnoreCase(colorType)) {
+            return new White();
+        }
+
+        return null;
+    }
+
+}

patterns/design-patterns/src/main/java/com/baeldung/creational/abstractfactory/Dog.java

@@ -0,0 +1,15 @@
+package com.baeldung.creational.abstractfactory;
+
+public class Dog implements Animal {
+
+    @Override
+    public String getType() {
+        return "Dog";
+    }
+
+    @Override
+    public String makeSound() {
+        return "Barks";
+    }
+
+}

patterns/design-patterns/src/main/java/com/baeldung/creational/abstractfactory/Duck.java

@@ -0,0 +1,15 @@
+package com.baeldung.creational.abstractfactory;
+
+public class Duck implements Animal {
+
+    @Override
+    public String getType() {
+        return "Duck";
+    }
+
+    @Override
+    public String makeSound() {
+        return "Squeks";
+    }
+
+}

patterns/design-patterns/src/main/java/com/baeldung/creational/abstractfactory/FactoryProvider.java

@@ -0,0 +1,15 @@
+package com.baeldung.creational.abstractfactory;
+
+public class FactoryProvider {
+    public static AbstractFactory getFactory(String choice){
+        
+        if("Toy".equalsIgnoreCase(choice)){
+            return new AnimalFactory();
+        }
+        else if("Color".equalsIgnoreCase(choice)){
+            return new ColorFactory();
+        }
+        
+        return null;
+    }
+}

patterns/design-patterns/src/main/java/com/baeldung/creational/abstractfactory/White.java

@@ -0,0 +1,10 @@
+package com.baeldung.creational.abstractfactory;
+
+public class White implements Color {
+
+    @Override
+    public String getColor() {
+        return "White";
+    }
+
+}

patterns/design-patterns/src/main/java/com/baeldung/creational/builder/BankAccount.java

@@ -0,0 +1,64 @@
+package com.baeldung.creational.builder;
+
+public class BankAccount {
+    private String name;
+    private String accountNumber;
+    private String email;
+    private boolean newsletter;
+
+    //The constructor that takes a builder from which it will create object
+    //the access to this is only provided to builder
+    private BankAccount(BankAccountBuilder builder) {
+        this.name = builder.name;
+        this.accountNumber = builder.accountNumber;
+        this.email = builder.email;
+        this.newsletter = builder.newsletter;
+    }
+    
+    public static class BankAccountBuilder {
+        private String name;
+        private String accountNumber;
+        private String email;
+        private boolean newsletter;
+        
+        //All Mandatory parameters goes with this constructor
+        public BankAccountBuilder(String name, String accountNumber) {
+            this.name = name;
+            this.accountNumber = accountNumber;
+        }
+
+        //setters for optional parameters which returns this same builder
+        //to support fluent design
+        public BankAccountBuilder withEmail(String email) {
+            this.email = email;
+            return this;
+        }
+
+        public BankAccountBuilder wantNewsletter(boolean newsletter) {
+            this.newsletter = newsletter;
+            return this;
+        }
+        
+        //the actual build method that prepares and returns a BankAccount object
+        public BankAccount build() {
+            return new BankAccount(this);
+        }
+    }
+
+    //getters
+    public String getName() {
+        return name;
+    }
+
+    public String getAccountNumber() {
+        return accountNumber;
+    }
+
+    public String getEmail() {
+        return email;
+    }
+
+    public boolean isNewsletter() {
+        return newsletter;
+    }
+}

patterns/design-patterns/src/main/java/com/baeldung/creational/builder/BuilderPatternDriver.java

@@ -0,0 +1,16 @@
+package com.baeldung.creational.builder;
+
+public class BuilderPatternDriver {
+    public static void main(String[] args) {
+        BankAccount newAccount = new BankAccount
+          .BankAccountBuilder("Jon", "22738022275")
+          .withEmail("jon@example.com")
+          .wantNewsletter(true)
+          .build();
+
+        System.out.println("Name: " + newAccount.getName());
+        System.out.println("AccountNumber:" + newAccount.getAccountNumber());
+        System.out.println("Email: " + newAccount.getEmail());
+        System.out.println("Want News letter?: " + newAccount.isNewsletter());
+    }
+}

patterns/design-patterns/src/main/java/com/baeldung/creational/factory/FactoryDriver.java

@@ -0,0 +1,16 @@
+package com.baeldung.creational.factory;
+
+public class FactoryDriver {
+    public static void main(String[] args) {
+        Polygon p;
+        PolygonFactory factory = new PolygonFactory();
+        
+        //get the shape which has 4 sides
+        p = factory.getPolygon(4);
+        System.out.println("The shape with 4 sides is a " + p.getType());
+        
+        //get the shape which has 4 sides
+        p = factory.getPolygon(8);
+        System.out.println("The shape with 8 sides is a " + p.getType());
+    }
+}

patterns/design-patterns/src/main/java/com/baeldung/creational/factory/Heptagon.java

@@ -0,0 +1,10 @@
+package com.baeldung.creational.factory;
+
+public class Heptagon implements Polygon {
+
+    @Override
+    public String getType() {
+        return "Heptagon";
+    }
+
+}

patterns/design-patterns/src/main/java/com/baeldung/creational/factory/Octagon.java

@@ -0,0 +1,10 @@
+package com.baeldung.creational.factory;
+
+public class Octagon implements Polygon {
+
+    @Override
+    public String getType() {
+        return "Octagon";
+    }
+
+}

patterns/design-patterns/src/main/java/com/baeldung/creational/factory/Pentagon.java

@@ -0,0 +1,10 @@
+package com.baeldung.creational.factory;
+
+public class Pentagon implements Polygon {
+
+    @Override
+    public String getType() {
+        return "Pentagon";
+    }
+
+}

patterns/design-patterns/src/main/java/com/baeldung/creational/factory/Polygon.java

@@ -0,0 +1,5 @@
+package com.baeldung.creational.factory;
+
+public interface Polygon {
+    String getType();
+}

patterns/design-patterns/src/main/java/com/baeldung/creational/factory/PolygonFactory.java

@@ -0,0 +1,22 @@
+package com.baeldung.creational.factory;
+
+public class PolygonFactory {
+    public Polygon getPolygon(int numberOfSides) {
+        if(numberOfSides == 3) {
+            return new Triangle();
+        }
+        if(numberOfSides == 4) {
+            return new Square();
+        }
+        if(numberOfSides == 5) {
+            return new Pentagon();
+        }
+        if(numberOfSides == 7) {
+            return new Heptagon();
+        }
+        else if(numberOfSides == 8) {
+            return new Octagon();
+        }
+        return null;
+    }
+}

patterns/design-patterns/src/main/java/com/baeldung/creational/factory/Square.java

@@ -0,0 +1,10 @@
+package com.baeldung.creational.factory;
+
+public class Square implements Polygon {
+
+    @Override
+    public String getType() {
+        return "Square";
+    }
+
+}

patterns/design-patterns/src/main/java/com/baeldung/creational/factory/Triangle.java

@@ -0,0 +1,10 @@
+package com.baeldung.creational.factory;
+
+public class Triangle implements Polygon {
+
+    @Override
+    public String getType() {
+        return "Triangle";
+    }
+
+}

patterns/design-patterns/src/main/java/com/baeldung/creational/singleton/Singleton.java

@@ -0,0 +1,13 @@
+package com.baeldung.creational.singleton;
+
+public class Singleton  {    
+    private Singleton() {}
+    
+    private static class SingletonHolder {    
+        public static final Singleton instance = new Singleton();
+    }    
+
+    public static Singleton getInstance() {    
+        return SingletonHolder.instance;    
+    }    
+}

patterns/design-patterns/src/main/java/com/baeldung/creational/singleton/SingletonDriver.java

@@ -0,0 +1,8 @@
+package com.baeldung.creational.singleton;
+
+public class SingletonDriver {
+    public static void main(String[] args) {
+        Singleton instance = Singleton.getInstance();
+        System.out.println(instance.toString());
+    }
+}