builder patterns

Author: meowpunch

README.md

@@ -1,17 +1,36 @@
 # Design Patterns in Java
-- hands on exercises following one [Udemy class](https://www.udemy.com/course/design-patterns-java/) and [Design Patterns book](https://en.wikipedia.org/wiki/Design_Patterns)
-    
-
+- Hands on exercises following belows 
+  - [udemy class](https://www.udemy.com/course/design-patterns-java/)
+  - [design patterns and principles paper](https://fi.ort.edu.uy/innovaportal/file/2032/1/design_principles.pdf)
+  - [design patterns book](https://en.wikipedia.org/wiki/Design_Patterns)
 
 ## SOLID
 
-### Single Responsibility Principle 
+### [Single Responsibility Principle](https://en.wikipedia.org/wiki/Single-responsibility_principle) 
 `There should never be more than one reason for a class to change.` i.e. every class should have only one responsibility.
 
-### Open Closed Principle (OCP)
+### [Open Closed Principle (OCP)](https://en.wikipedia.org/wiki/Open–closed_principle)
 `open for extension, but closed for modification.`
 - OCP + [Specification Pattern](https://en.wikipedia.org/wiki/Specification_pattern)
 
-### Liskov Substitution Principle
+### [Liskov Substitution Principle](https://en.wikipedia.org/wiki/Liskov_substitution_principle)
 `if S is a subtype of T, then objects of type T in a program may be replaced with objects of type S without altering any of the desirable properties of that program.` i.e. if S is a subtype of T, then objects of type T in a program may be replaced with objects of type S without altering any of the desirable properties of that program.
-- s
+- Circle / Ellipse Dilemma (can be Square / Rectangle Problem)
+
+### [Interface Segregation Principle](https://en.wikipedia.org/wiki/Interface_segregation_principle)
+`Many client-specific interfaces are better than one general-purpose interface.`
+
+### [Dependency Inversion Principle](https://en.wikipedia.org/wiki/Dependency_inversion_principle)
+`Depend upon abstractions, [not] concretions.`
+- High-level modules should not import anything from low-level modules. Both should depend on abstractions (e.g., interfaces).
+- Abstractions should not depend on details. Details (concrete implementations) should depend on abstractions
+
+## Creational Patterns
+### [Builder Pattern](https://en.wikipedia.org/wiki/Builder_pattern)
+- StringBuilder and HTMLBuilder
+
+## Structural Patterns
+
+## Behavioral Patterns
+
+## Concurrency Patterns

pom.xml

@@ -12,5 +12,6 @@
         <maven.compiler.source>17</maven.compiler.source>
         <maven.compiler.target>17</maven.compiler.target>
     </properties>
-    
+
+
 </project>

src/main/java/creational/builder/CodeBuilder.java

@@ -0,0 +1,39 @@
+package creational.builder;
+
+import java.util.ArrayList;
+import java.util.List;
+
+
+public class CodeBuilder {
+    private record Field(String name, String type) {
+    }
+
+    private final String className;
+    private final List<Field> fields = new ArrayList<>();
+    private final int indentSize = 4;
+
+
+    public CodeBuilder(String className) {
+        this.className = className;
+    }
+
+    public CodeBuilder addField(String name, String type) {
+        fields.add(new Field(name, type));
+        return this;
+    }
+
+    public String buildCode() {
+        final StringBuilder sb = new StringBuilder();
+        sb.append(String.format("public class %s\n", className));
+        sb.append("{\n");
+        fields.forEach(field -> sb.append(String.format("%" + indentSize + "s" + "public %s %s;\n", "", field.type, field.name)));
+        sb.append("}\n");
+
+        return sb.toString();
+    }
+
+    @Override
+    public String toString() {
+        return buildCode();
+    }
+}

src/main/java/creational/builder/Demo.java

@@ -0,0 +1,45 @@
+package creational.builder;
+
+
+public class Demo {
+
+    public static void main(String[] args) {
+        // we want to build a simple HTML paragraph
+        System.out.println("Testing");
+        String hello = "hello";
+        StringBuilder sb = new StringBuilder();
+        sb.append("<p>")
+                .append(hello)
+                .append("</p>"); // a builder!
+        System.out.println(sb);
+
+        // now we want to build a list with 2 words
+        String[] words = {"hello", "world"};
+        sb.setLength(0); // clear it
+        sb.append("<ul>\n");
+        for (String word : words) {
+            // indentation management, line breaks and other evils
+            sb.append(String.format("  <li>%s</li>\n", word));
+        }
+        sb.append("</ul>");
+        System.out.println(sb);
+
+        // ordinary non-fluent builder
+        HtmlBuilder builder = new HtmlBuilder("ul");
+        builder.addChild("li", "hello");
+        builder.addChild("li", "world");
+        System.out.println(builder);
+
+        // fluent builder
+        builder.clear();
+        builder.addChildFluent("li", "hello")
+                .addChildFluent("li", "world");
+        System.out.println(builder);
+
+
+
+        // Class Builder
+        CodeBuilder cb = new CodeBuilder("Person").addField("age", "int").addField("name", "String");
+        System.out.println(cb);
+    }
+}

src/main/java/creational/builder/HtmlBuilder.java

@@ -0,0 +1,34 @@
+package creational.builder;
+
+public class HtmlBuilder {
+    private String rootName;
+    private HtmlElement root = new HtmlElement();
+
+    public HtmlBuilder(String rootName) {
+        this.rootName = rootName;
+        root.name = rootName;
+    }
+
+    // not fluent
+    public void addChild(String childName, String childText) {
+        HtmlElement e = new HtmlElement(childName, childText);
+        root.elements.add(e);
+    }
+
+    public HtmlBuilder addChildFluent(String childName, String childText) {
+        HtmlElement e = new HtmlElement(childName, childText);
+        root.elements.add(e);
+        return this;
+    }
+
+    public void clear() {
+        root = new HtmlElement();
+        root.name = rootName;
+    }
+
+    // delegating
+    @Override
+    public String toString() {
+        return root.toString();
+    }
+}

src/main/java/creational/builder/HtmlElement.java

@@ -0,0 +1,42 @@
+package creational.builder;
+
+import java.util.ArrayList;
+import java.util.Collections;
+
+public class HtmlElement {
+    protected int p;
+    public String name, text;
+    public ArrayList<HtmlElement> elements = new ArrayList<>();
+    private final int indentSize = 2;
+    private final String newLine = System.lineSeparator();
+
+    public HtmlElement() {
+    }
+
+    public HtmlElement(String name, String text) {
+        this.name = name;
+        this.text = text;
+    }
+
+    private String toStringImpl(int indent) {
+        StringBuilder sb = new StringBuilder();
+        String i = String.join("", Collections.nCopies(indent * indentSize, " "));
+        sb.append(String.format("%s<%s>%s", i, name, newLine));
+        if (text != null && !text.isEmpty()) {
+            sb.append(String.join("", Collections.nCopies(indentSize * (indent + 1), " ")))
+                    .append(text)
+                    .append(newLine);
+        }
+
+        for (HtmlElement e : elements)
+            sb.append(e.toStringImpl(indent + 1));
+
+        sb.append(String.format("%s</%s>%s", i, name, newLine));
+        return sb.toString();
+    }
+
+    @Override
+    public String toString() {
+        return toStringImpl(0);
+    }
+}