Add template method pattern with strategy integration (#15)

Author: darbyluv2code

section-04-behavioral-design-patterns/12-template/pom.xml

@@ -0,0 +1,17 @@
+<?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.luv2code</groupId>
+    <artifactId>java-design-patterns</artifactId>
+    <version>1.0</version>
+
+    <properties>
+        <maven.compiler.source>24</maven.compiler.source>
+        <maven.compiler.target>24</maven.compiler.target>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    </properties>
+
+</project>

section-04-behavioral-design-patterns/12-template/src/main/java/com/luv2code/designpatterns/behavioral/template/AbstractSortStrategy.java

@@ -0,0 +1,43 @@
+package com.luv2code.designpatterns.behavioral.template;
+
+import java.util.Comparator;
+import java.util.List;
+
+/**
+ * Abstract base class for sorting strategies.
+ *
+ * Provides direction support (ascending/descending) for all subclasses.
+ * Subclasses implement getComparator() to define their sorting criteria.
+ */
+public abstract class AbstractSortStrategy implements SortStrategy {
+
+    private final SortDirection direction;
+
+    // Default constructor
+    protected AbstractSortStrategy() {
+        this(SortDirection.ASCENDING);
+    }
+
+    // Parameterized constructor
+    protected AbstractSortStrategy(SortDirection direction) {
+        if (direction == null) {
+            throw new IllegalArgumentException("Sort direction must be non-null");
+        }
+        this.direction = direction;
+    }
+
+    @Override
+    public void sort(List<Course> courses) {
+        Comparator<Course> comparator = getComparator();
+
+        if (direction == SortDirection.DESCENDING) {
+            comparator = comparator.reversed();
+        }
+
+        courses.sort(comparator);
+    }
+
+    // Template method: subclasses provide the specific comparator
+    protected abstract Comparator<Course> getComparator();
+
+}

section-04-behavioral-design-patterns/12-template/src/main/java/com/luv2code/designpatterns/behavioral/template/Course.java

@@ -0,0 +1,52 @@
+package com.luv2code.designpatterns.behavioral.template;
+
+/**
+ * Role: Element
+ *
+ * The element we will sort on.
+ */
+public class Course {
+
+    private String name;
+    private double rating;
+    private int studentCount;
+
+    public Course(String name, double rating, int studentCount) {
+        this.name = name;
+        this.rating = rating;
+        this.studentCount = studentCount;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public double getRating() {
+        return rating;
+    }
+
+    public void setRating(double rating) {
+        this.rating = rating;
+    }
+
+    public int getStudentCount() {
+        return studentCount;
+    }
+
+    public void setStudentCount(int studentCount) {
+        this.studentCount = studentCount;
+    }
+
+    @Override
+    public String toString() {
+        return "Course{" +
+                "name='" + name + '\'' +
+                ", rating=" + rating +
+                ", studentCount=" + studentCount +
+                '}';
+    }
+}

section-04-behavioral-design-patterns/12-template/src/main/java/com/luv2code/designpatterns/behavioral/template/CourseSorter.java

@@ -0,0 +1,42 @@
+package com.luv2code.designpatterns.behavioral.template;
+
+import java.util.List;
+
+/**
+ * Role: Context
+ *
+ * Maintains a reference to a SortStrategy and delegates sorting to it.
+ * Allows clients to change sorting behavior by providing different strategies.
+ */
+public class CourseSorter {
+
+    private SortStrategy sortStrategy;
+
+    public CourseSorter(SortStrategy sortStrategy) {
+
+        if (sortStrategy == null) {
+            throw new IllegalArgumentException("Sort strategy must be non-null");
+        }
+
+        this.sortStrategy = sortStrategy;
+    }
+
+    public void setSortStrategy(SortStrategy sortStrategy) {
+
+        if (sortStrategy == null) {
+            throw new IllegalArgumentException("Sort strategy must be non-null");
+        }
+
+        this.sortStrategy = sortStrategy;
+    }
+
+    public void sort(List<Course> courses) {
+
+        if (courses == null) {
+            throw new IllegalArgumentException("Courses must be non-null");
+        }
+
+        sortStrategy.sort(courses);
+
+    }
+}

section-04-behavioral-design-patterns/12-template/src/main/java/com/luv2code/designpatterns/behavioral/template/MainApp.java

@@ -0,0 +1,117 @@
+package com.luv2code.designpatterns.behavioral.template;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Role: Client
+ *
+ * Demonstrates the Strategy pattern by sorting courses using different strategies.
+ * Shows how sorting behavior can be changed by providing different strategy implementations.
+ * Can even change sorting strategy at runtime.
+ */
+public class MainApp {
+
+    public static void main(String[] args) {
+
+        List<Course> courses = new ArrayList<>();
+
+        Course course1 = new Course("JavaScript for Beginners", 4.8, 9800);
+        Course course2 = new Course("Advanced Game Development", 4.5, 5000);
+        Course course3 = new Course("Building Scalable Cloud Solutions", 4.9, 5000);
+
+        courses.add(course1);
+        courses.add(course2);
+        courses.add(course3);
+
+        System.out.println("=== Before Sorting ===");
+        displayCourses(courses);
+
+        System.out.println();
+
+        // Create sorter with initial strategy (default ascending order)
+        CourseSorter courseSorter = new CourseSorter(new NameSortStrategy());
+
+        System.out.println("=== Sort by name (ascending - default) ===");
+        courseSorter.sort(courses);
+        displayCourses(courses);
+
+        System.out.println();
+
+        // Change strategy at runtime with explicit descending order
+        System.out.println("=== Sort by name (descending) ===");
+        courseSorter.setSortStrategy(new NameSortStrategy(SortDirection.DESCENDING));
+        courseSorter.sort(courses);
+        displayCourses(courses);
+
+        System.out.println();
+
+        // Change to different sorting criteria with default ascending
+        System.out.println("=== Sort by rating (ascending - default) ===");
+        courseSorter.setSortStrategy(new RatingSortStrategy());
+        courseSorter.sort(courses);
+        displayCourses(courses);
+
+        System.out.println();
+
+        // Change to descending
+        System.out.println("=== Sort by rating (descending) ===");
+        courseSorter.setSortStrategy(new RatingSortStrategy(SortDirection.DESCENDING));
+        courseSorter.sort(courses);
+        displayCourses(courses);
+
+        System.out.println();
+
+        // Sort by student count ascending
+        System.out.println("=== Sort by number of students (ascending - default) ===");
+        courseSorter.setSortStrategy(new StudentCountSortStrategy());
+        courseSorter.sort(courses);
+        displayCourses(courses);
+
+        System.out.println();
+
+        // Sort by student count descending
+        System.out.println("=== Sort by number of students (descending) ===");
+        courseSorter.setSortStrategy(new StudentCountSortStrategy(SortDirection.DESCENDING));
+        courseSorter.sort(courses);
+        displayCourses(courses);
+
+        System.out.println();
+
+        // Sort by student count AND rating (ascending)
+        System.out.println("=== Sort by number of students AND rating (ascending - default) ===");
+        courseSorter.setSortStrategy(new StudentCountAndRatingSortStrategy());
+        courseSorter.sort(courses);
+        displayCourses(courses);
+
+        System.out.println();
+
+        // Sort by student count AND rating (descending)
+        System.out.println("=== Sort by number of students AND rating (descending) ===");
+        courseSorter.setSortStrategy(new StudentCountAndRatingSortStrategy(SortDirection.DESCENDING));
+        courseSorter.sort(courses);
+        displayCourses(courses);
+
+    }
+
+    private static void displayCourses(List<Course> courses) {
+
+        for (Course course : courses) {
+            System.out.println(course);
+        }
+
+    }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+

section-04-behavioral-design-patterns/12-template/src/main/java/com/luv2code/designpatterns/behavioral/template/NameSortStrategy.java

@@ -0,0 +1,33 @@
+package com.luv2code.designpatterns.behavioral.template;
+
+import java.util.Comparator;
+
+/**
+ * Role: Concrete Strategy
+ *
+ * Sorts courses by name.
+ */
+public class NameSortStrategy extends AbstractSortStrategy {
+
+    public NameSortStrategy() {
+    }
+
+    public NameSortStrategy(SortDirection direction) {
+        super(direction);
+    }
+
+    @Override
+    protected Comparator<Course> getComparator() {
+        return Comparator.comparing(Course::getName);
+    }
+
+}
+
+
+
+
+
+
+
+
+

section-04-behavioral-design-patterns/12-template/src/main/java/com/luv2code/designpatterns/behavioral/template/RatingSortStrategy.java

@@ -0,0 +1,24 @@
+package com.luv2code.designpatterns.behavioral.template;
+
+import java.util.Comparator;
+
+/**
+ * Role: Concrete Strategy
+ *
+ * Sorts courses by rating.
+ */
+public class RatingSortStrategy extends AbstractSortStrategy {
+
+    public RatingSortStrategy() {
+    }
+
+    public RatingSortStrategy(SortDirection direction) {
+        super(direction);
+    }
+
+    @Override
+    protected Comparator<Course> getComparator() {
+        return Comparator.comparingDouble(Course::getRating);
+    }
+
+}

section-04-behavioral-design-patterns/12-template/src/main/java/com/luv2code/designpatterns/behavioral/template/SortDirection.java

@@ -0,0 +1,10 @@
+package com.luv2code.designpatterns.behavioral.template;
+
+/**
+ * Enum representing sort direction for sorting strategies.
+ * Used to specify whether sorting should be in ascending or descending order.
+ */
+public enum SortDirection {
+    ASCENDING,
+    DESCENDING
+}

section-04-behavioral-design-patterns/12-template/src/main/java/com/luv2code/designpatterns/behavioral/template/SortStrategy.java

@@ -0,0 +1,15 @@
+package com.luv2code.designpatterns.behavioral.template;
+
+import java.util.List;
+
+/**
+ * Role: Strategy
+ *
+ * Defines the interface for different sorting algorithms.
+ * Allows the sorting behavior to be selected at runtime.
+ */
+public interface SortStrategy {
+
+    void sort(List<Course> courses);
+
+}

section-04-behavioral-design-patterns/12-template/src/main/java/com/luv2code/designpatterns/behavioral/template/StudentCountAndRatingSortStrategy.java

@@ -0,0 +1,33 @@
+package com.luv2code.designpatterns.behavioral.template;
+
+import java.util.Comparator;
+
+/**
+ * Role: Concrete Strategy
+ *
+ * Sorts courses by student count, then by rating as a tiebreaker.
+ */
+public class StudentCountAndRatingSortStrategy extends AbstractSortStrategy {
+
+    public StudentCountAndRatingSortStrategy() {
+    }
+
+    public StudentCountAndRatingSortStrategy(SortDirection direction) {
+        super(direction);
+    }
+
+    @Override
+    protected Comparator<Course> getComparator() {
+        return Comparator.comparingInt(Course::getStudentCount)
+                .thenComparingDouble(Course::getRating);
+    }
+
+}
+
+
+
+
+
+
+
+