🎯 Lecture 12 · The most important lecture for Q3

Design Patterns & Strategy Pattern

Question 3 (15-24 marks) في كل امتحان final بيكون عن Strategy Pattern. هتبني full UML diagram + write all Java code. ركز جداً.

← All Lectures 🎯 جرب أسئلة الامتحان

Chapters

GoF Patterns

⭐

Strategy = Q3

Exam Qs

Introduction to Design Patterns

الـ pattern = recurring solution لـ common problem في specific context.

📜 History & Origin

Based on work by Christopher Alexander (Architect) on building homes/towns.
Gang of Four (GoF) book — 1995, by Gamma, Helm, Johnson, Vlissides.
Described 23 recurring software designs.

"Each pattern describes a problem which occurs over and over again, and then describes the core of the solution, in such a way that you can use this solution a million times over, without ever doing it in the same way twice."
— Christopher Alexander, A Pattern Language, 1977

⚠️ Motivating Problem — Sort Method Evolution

تبدأ بكتابة ArrayList فيه sort() بـ bubble sort. تغيره لـ merge sort. تحاول الاتنين بـ if/else:

public class ArrayList<T> {
  public void sort(int sortChoice) {
    if (sortChoice == 1) { /* merge sort */ }
    if (sortChoice == 2) { /* bubble sort */ }
  }
}

🔴 What's wrong?

Violates OCP — for any new algorithm, you modify the class.
Every change affects all clients that use it.
What about future algorithms you don't know yet? You'll keep editing.

💡 Uncle Bob's wisdom"When writing a class, ensure that when you need to extend its behavior you don't have to change the class but to extend it."

GoF — 23 Design Patterns

تنقسم لـ 3 categories.

🏗️ Creational (5)

About object creation

Abstract Factory
Builder
Factory Method
Prototype
Singleton ⭐

🏛️ Structural (7)

About composition

Adapter ⭐ (Q3 Winter 2023)
Bridge
Composite
Decorator
Façade
Flyweight
Proxy

🎭 Behavioral (11)

About interaction

Chain of Responsibility
Command
Interpreter
Iterator
Mediator
Memento
Observer ⭐
State
Strategy ⭐⭐⭐
Template Method ⭐
Visitor

⚠️ اللي بيتسأل عليهم في الـ examsStrategy (Q3 in every exam), Observer / Publish-Subscribe (Q1.17 Fall 2021-22 / Winter 2021), Adapter (Q3 Winter 2023), Template Method (Q1.08 Winter 2025), Singleton (common interview question).

4 Essential Elements of a Pattern

كل design pattern له 4 essential elements.

1. Name

Handle لوصف problem · solution · consequences. Increases design vocabulary.

2. Problem

متى نطبق الـ pattern + the context + preconditions.

3. Solution

Elements: design · relationships · responsibilities · collaborations.

4. Consequences

الـ trade-offs والـ results من تطبيق الـ pattern.

Java GUI — Swing & AWT

الـ Java libraries للـ GUI. الـ AWT هي الأساس، الـ Swing بيرث منها.

🪟 Hierarchy

AWT (java.awt) — old, OS-dependent rendering.
Swing (javax.swing) — new, classes start with J (e.g., JFrame, JPanel, JButton).

Sample Java GUI Composition

JFrame (Window)

↓ contains

JPanel × N

↓ contains

J* Components (JButton, JLabel, ...)

+ organized by

LayoutManager (FlowLayout, GridLayout, BorderLayout)

+ react via

ActionListener

💻 Tic-Tac-Toe Example

public class TicTacToe1 extends JFrame {
  public TicTacToe1() {
    setTitle("Tic Tac Toe");
    setSize(310, 210);
    setLayout(new GridLayout(2, 1));

    JLabel messageLabel = new JLabel("It is X turn.");
    JPanel msgPanel = new JPanel(new FlowLayout());
    msgPanel.add(messageLabel);

    JPanel gamePanel = new JPanel(new GridLayout(3, 3));
    for (int i = 0; i < 9; i++) {
      gamePanel.add(new JButton(""));
    }
    add(msgPanel); add(gamePanel);
    setVisible(true);
  }
}

👂 Event Listeners

الـ AWT/Swing components بتنشر events. الـ EventListeners بتشترك فيها.

Component	Event	Listener
JButton	ActionEvent	ActionListener
JComponent	MouseEvent	MouseListener
JComponent	KeyEvent	KeyListener

// Adding listener with anonymous inner class
JButton again = new JButton("New game");
again.addActionListener(new ActionListener() {
  public void actionPerformed(ActionEvent e) {
    newGame();
  }
});

JavaFX — Modern UI

Swing هو الـ Legacy. JavaFX هو الـ Modern Industry Standard.

⚖️ Swing vs JavaFX Comparison

Feature	Swing (Legacy)	JavaFX (Modern)
Top-Level Container	JFrame	Stage
Content	JPanel / ContentPane	Scene
Component Base	JComponent	Node
Hierarchy	Flat: Frame→Panel→Comp	Scene Graph: Stage→Scene→Root→Nodes
Layout	setLayout()	setRoot(newParent)
Styling	Java code	CSS
Graphics Engine	CPU (software)	GPU accelerated
Layout Strategy	FlowLayout, GridLayout, BorderLayout	HBox, VBox, GridPane, StackPane
Visual Design	Code only	FXML + Scene Builder
Multimedia	Limited	3D, Video, Audio, WebKit built-in
Events	Anonymous inner classes	Lambda expressions

Strategy Pattern ⭐⭐⭐

الـ Pattern الأهم في الـ course. Q3 في كل final fingerprint exam.

Behavioral Pattern · GoF

🎯 Strategy

📍 Context

Define a family of algorithms, encapsulate each one, and make them interchangeable. Strategy lets the algorithm vary independently from clients that use it.

❓ Problem

Allow different behaviors without changing the class of an object. Strategy/Algorithm can change at runtime within the same class.

✅ Solution

Represent each strategy by a separate class. Each strategy class implements the appropriate algorithm. At runtime, a class can change its strategy.

🎯 When to Use Strategy

Many related classes differ only in behavior.
You need different variants of an algorithm.
Algorithm uses data clients shouldn't know about.
A class has many behaviors as multiple conditional statements — move them into Strategy classes.

💡 Key Triggerلو في كود فيه if/else chain أو switch بيختار between behaviors → فكر في Strategy.

Strategy Pattern — UML Structure

3 elements: Context · Strategy interface · Concrete Strategies.

📐 UML Class Diagram

       ┌───────────────────┐         ┌────────────────────────┐
       │     Context       │ ◇─ ────→│  «interface» Strategy  │
       ├───────────────────┤ strategy├────────────────────────┤
       │ -strategy:Strategy│         │ +algorithm() :          │
       │ +contextOp()      │         └────────────────────────┘
       └───────────────────┘                    △
                                                │ implements
                          ┌─────────────────────┼─────────────────────┐
                          │                     │                     │
              ┌───────────────────┐  ┌───────────────────┐  ┌───────────────────┐
              │ ConcreteStrategyA │  │ ConcreteStrategyB │  │ ConcreteStrategyC │
              ├───────────────────┤  ├───────────────────┤  ├───────────────────┤
              │ +algorithm()      │  │ +algorithm()      │  │ +algorithm()      │
              └───────────────────┘  └───────────────────┘  └───────────────────┘

Context: holds reference to Strategy. Delegates algorithm work to it.
Strategy: interface/abstract class defining the algorithm signature.
ConcreteStrategies: each one implements a different variant of the algorithm.

📊 Sort Example (from motivation)

       ┌──────────────┐         ┌──────────────────────┐
       │  SortArray   │ ◇──────→│ «interface» SortStrategy │
       ├──────────────┤sortStrat├──────────────────────┤
       │ +sort()      │         │ +sort()              │
       └──────────────┘         └──────────────────────┘
                                          △
                          ┌───────────────┼───────────────┐
                  ┌───────────┐  ┌────────────┐  ┌──────────────┐
                  │ BubbleSort│  │ QuickSort  │  │ InsertionSort│
                  └───────────┘  └────────────┘  └──────────────┘

🪟 Java AWT LayoutManager = Strategy!

الـ Java AWT بيستخدم Strategy للـ Layout Managers. الـ Container = Context. الـ LayoutManager = Strategy.

Frame f = new Frame();
f.setLayout(new FlowLayout());    // strategy 1
// or:
f.setLayout(new GridLayout(2,3));  // strategy 2
// or:
f.setLayout(new BorderLayout());  // strategy 3

الـ Frame ما يعرفش إزاي بيتم الـ layout — هو بس يحفظ reference للـ LayoutManager. كل strategy class بينفّذ layout algorithm مختلف.

TextEditor Strategy — Q3 Exam Solution ⭐

الـ Question 3 في امتحانات Fall 2021-22 و Winter 2021. Practice these by heart.

📜 Original Code (before Strategy)

TextEditor.java — Bad design

public class TextEditor {
  private String text;

  public void formatText(int choice) {
    if (choice == 1) {
      text = text.toUpperCase();
    }
    else if (choice == 2) {
      text = text.toLowerCase();
    }
  }

  public void setText(String newText) { text = newText; }
  public String getText() { return text; }
}

public class Test {
  public static void main(String[] args) {
    TextEditor editor = new TextEditor();
    editor.setText("this Is My TeXt");
    editor.formatText(1);
    System.out.println(editor.getText());  // THIS IS MY TEXT
    editor.formatText(2);
    System.out.println(editor.getText());  // this is my text
  }
}

❓ The 3 Parts of Question 3

Part a (1 mark): What is the output of the code?
Answer: THIS IS MY TEXT on line 1, this is my text on line 2.
Part b (2 marks): How does adding a choice for formatting violate OCP and affect existing classes?
Answer: Code should be open for extensions, closed for modifications. But adding a new formatter requires modifying the existing class (add new if). This violates OCP. Also, all clients using the class must be updated.
Part c (5 marks for diagram + 7 marks for code): Apply Strategy Pattern. Draw UML + Write Java code.

📐 Solution — UML Class Diagram (5 marks)

   ┌─────────┐         ┌───────────────┐        ┌──────────────────────────────┐
   │  Test   │─────→─→│  TextEditor   │ ─◇────→│ «abstract» TextFormattingStrategy │
   ├─────────┤         ├───────────────┤        ├──────────────────────────────┤
   │  main() │         │ -text:String  │        │ +formatText(text:String):String │
   └─────────┘         │ -formatter    │        └──────────────────────────────┘
                       │ +setText()    │                       △
                       │ +getText()    │                       │ extends
                       │ +setFormatter()│         ┌─────────────┴──────────────┐
                       │ +formatText() │         │                            │
                       └───────────────┘  ┌──────────────────┐  ┌──────────────────┐
                                          │ UpperCaseFormatter│  │ LowerCaseFormatter│
                                          ├──────────────────┤  ├──────────────────┤
                                          │ +formatText(text):│  │ +formatText(text):│
                                          │   String         │  │   String         │
                                          └──────────────────┘  └──────────────────┘

☕ Solution — Java Code (7 marks)

1️⃣ TextEditor (Context)

public class TextEditor {
  private String text;
  private TextFormattingStrategy formatter;  // 1 mark

  public void setFormatter(TextFormattingStrategy formatter) {
    this.formatter = formatter;  // 1 mark
  }

  public void setText(String newText) { text = newText; }
  public String getText() { return text; }

  public void formatText() {
    text = formatter.formatText(text);  // 1 mark
  }
}

2️⃣ Abstract Strategy Class

abstract public class TextFormattingStrategy {
  abstract public String formatText(String text);
}

3️⃣ Concrete Strategies

public class LowerCaseFormatter extends TextFormattingStrategy {
  public String formatText(String text) {
    return text.toLowerCase();
  }
}

public class UpperCaseFormatter extends TextFormattingStrategy {
  public String formatText(String text) {
    return text.toUpperCase();
  }
}

4️⃣ Test Client

public class Test {
  public static void main(String[] args) {
    TextEditor editor = new TextEditor();
    editor.setText("this Is My TeXt");

    editor.setFormatter(new UpperCaseFormatter());  // 0.5
    editor.formatText();
    System.out.println(editor.getText());  // THIS IS MY TEXT

    editor.setFormatter(new LowerCaseFormatter());  // 0.5
    editor.formatText();
    System.out.println(editor.getText());  // this is my text
  }
}

💡 Benefits achieved

OCP satisfied — add new formatter without touching TextEditor.
Polymorphism — TextEditor doesn't know which formatter is used.
Open for extension — create new ConcreteStrategy classes (e.g., TitleCaseFormatter).

🎯

Exam Bank — Lecture 12

8 أسئلة من الـ exams الحقيقية. Strategy, Observer, Template Method, MVC.

Question 1 Practice — Strategy

A class has multiple algorithms selected via switch. Which design pattern would best refactor this?

A Observer

B Strategy

C Singleton

D Adapter

✅ الإجابة الصح: B — Strategy Strategy pattern encapsulates each algorithm in its own class. الـ switch بيتم استبداله بـ polymorphism. ده classic refactor الـ Strategy.

Question 2 Fall 2021–22 / Winter 2021 · Q1.17

A water company has a CRM system, billing system, and messaging system. When a customer is created in CRM, billing & messaging systems need to be notified and get a copy of customer data. Which design pattern suits this case?

A GoF pattern (any)

B Publish-Subscribe (Observer)

C Strategy

D MVC

✅ الإجابة الصح: B — Publish-Subscribe (Observer) الـ CRM ينشر event ("new customer"). Billing & Messaging يشتركوا ويتم notify عند الحدث. Each subscriber يحصل على copy. Classic Pub-Sub / Observer pattern.

A — too generic. · C (Strategy) — للـ swap algorithms. · D (MVC) — UI pattern.

Question 3 Fall 2021–22 / Winter 2021 · Q1.18

In the MVC pattern shown with components @Observable (1), @EventListener (2), @Observer (3) — what are classes 1, 2, and 3 in order?

A View, Controller, Model

B Model, View, Controller

C Model, Controller, View

D Controller, View, Model

✅ الإجابة الصح: C — Model, Controller, View

الـ Model = @Observable (الـ source للـ data changes)
الـ Controller = @EventListener (يستجيب لـ events)
الـ View = @Observer (يتم notify عند changes)

Question 4 Winter 2025 · Q1.08

A class ReportBuilder has a buildReport() method that calls gatherData(), formatReport(), printReport() in order. formatReport() is abstract. SalesReport extends ReportBuilder overrides specific methods. Which pattern is this?

A Observer

B Strategy

C MVC

D Template Method

✅ الإجابة الصح: D — Template Method Template Method = الـ base class defines a fixed algorithm (sequence) with some abstract steps. Subclasses override the abstract steps. الـ structure هنا exactly that.

A (Observer) — مفيش notification mechanism. · B (Strategy) — Strategy = composition (HAS-A); Template = inheritance (IS-A) with hooks. · C (MVC) — مش UI pattern.

Question 5 Practice — Strategy benefits

Which SOLID principle is most directly satisfied by Strategy Pattern?

A Open-Close Principle

B Liskov Substitution

C Interface Segregation

D Single Responsibility

✅ الإجابة الصح: A — OCP Strategy = open for extension (add new strategy classes), closed for modification (Context class doesn't change). ده exact embodiment للـ OCP.

Question 6 Practice — Strategy structure

In Strategy Pattern, which class holds the reference to the current strategy?

A Strategy interface

B ConcreteStrategy

C Context

D Test/Client

✅ الإجابة الصح: C — Context Context = the class الـ delegating the algorithm (e.g., TextEditor, SortArray). It HAS-A Strategy as a field, calls strategy.algorithm() in its operation.

Question 7 Practice — Real-world Strategy

Which Java AWT/Swing component uses the Strategy Pattern internally?

A ActionListener

B Container with LayoutManager

C JComboBox

D JFrame

✅ الإجابة الصح: B — Container with LayoutManager Container = Context. LayoutManager = Strategy interface. FlowLayout, GridLayout, BorderLayout = ConcreteStrategies. container.setLayout(new FlowLayout()) = swap strategy at runtime!

A (ActionListener) — closer to Observer pattern (event listener).

Question 8 Practice — GoF

Strategy belongs to which GoF category?

A Creational

B Structural

C Architectural

D Behavioral

✅ الإجابة الصح: D — Behavioral Behavioral patterns deal with object interaction and responsibility distribution. Strategy + Observer + Template Method + Command + Iterator etc. كلهم behavioral.

📋

Cheat Sheet

Design Patterns + Strategy complete reference.

📚 GoF Categories

Creational (5)

Abstract Factory · Builder · Factory Method · Prototype · Singleton

Structural (7)

Adapter · Bridge · Composite · Decorator · Façade · Flyweight · Proxy

Behavioral (11)

CoR · Command · Iterator · Mediator · Memento · Observer · State · Strategy · Template Method · Visitor · Interpreter

🎯 Strategy Pattern (Q3)

🔄 Pattern → Use Case

Strategy

Multiple algorithms (sort, format, layout)

Observer

Notify many objects of state change

Adapter

Make incompatible interfaces work together

Template Method

Fixed algorithm steps + customizable parts

Singleton

Ensure ONE instance only

MVC

Separate Model · View · Controller

📝 4 Elements of Pattern

1. Name

Vocabulary handle

2. Problem

When to apply + context

3. Solution

Design + relationships

4. Consequences

Trade-offs & results

🪟 Java GUI

Old

AWT (java.awt)

Standard

Swing (javax.swing) — starts with J

Modern

JavaFX — Stage, Scene, Node

Strategy in Java

setLayout(new FlowLayout())

⏰ Q3 Exam Strategy

1 mark

Read code output

2 marks

Explain OCP violation

5 marks

Draw UML (Context + abstract + 2 concretes)

7 marks

Java code (4 classes minimum)

Total Q3

15-24 marks

⚡

Rapid Revision

Flashcards · Mistakes · Doctor favorites.

3 GoF categories؟

tap

Creational · Structural · Behavioral

Strategy = ?

tap

Family of algorithms, interchangeable

Strategy structure؟

tap

Context + Strategy interface + ConcreteStrategies

Observer / Pub-Sub use case؟

tap

Notify multiple systems of state change

Template Method vs Strategy؟

tap

Template = inheritance + hooks. Strategy = composition + swap

Java AWT example of Strategy؟

tap

setLayout() with FlowLayout/GridLayout/BorderLayout

MVC roles؟

tap

Model · View · Controller

GoF book year؟

tap

1995 (Gamma, Helm, Johnson, Vlissides)

Strategy → which SOLID؟

tap

OCP + DIP

🚨 Common Mistakes

1. Strategy vs Template MethodStrategy uses composition (Context HAS-A Strategy). Template Method uses inheritance (Subclass IS-A Base, overrides hooks).

2. Forgetting Test class in Q3 codeالـ exam بيدي 7 marks للـ code. لازم اربعة classes: Context · Abstract Strategy · 2 Concrete Strategies · Test (which uses them).

3. Strategy as ObserverStrategy = swap behavior. Observer = notify changes. مختلفين بالكامل.

4. لو UML بدون Concrete StrategiesUML للـ Strategy لازم تضم 2+ concrete strategy classes — مش بس Context + abstract.

⭐ What Dr. El-Ramly Loves (Q3)

🔥 Q3 Pattern (every exam)

"What is the output?" — قرّاء الكود وحدد output الـ println.
"Explain OCP violation" — code with if/else for behavior = OCP violation.
"Draw UML" — Context + abstract Strategy + 2 concrete strategies.
"Write Java code" — full implementation of 4 classes.
التركيز على TextEditor formatText بشكل أساسي.
Winter 2023 Q3 was bigger: Observer + DIP + Adapter (24 marks total).

🎯 Final Tipاحفظ TextEditor Strategy implementation by heart. لو جا في الـ exam بأي شكل، تقدر تكتبه في 10 دقايق. الـ 15 mark دول guaranteed.