Structural patterns (Adapter, Decorator, Facade) in Software Engineering - Step-by-Step Execution

Concept Flow - Structural patterns (Adapter, Decorator, Facade)

Start

↓

Identify need

↓

Adapter

↓

Convert

↓

interface

↓

Use adapted

↓

component

↓

End

This flow shows how to start from a need, choose one of the three structural patterns, and apply it to solve interface, behavior, or complexity problems.

Execution Sample

Software Engineering

class OldPrinter {
  print(text) { console.log(text); }
}

class PrinterAdapter {
  constructor(oldPrinter) { this.oldPrinter = oldPrinter; }
  printText(text) { this.oldPrinter.print(text); }
}

This code adapts an old printer's method to a new interface using the Adapter pattern.

Analysis Table

Step	Action	Object/Method Called	Result	Notes
1	Create OldPrinter instance	OldPrinter()	OldPrinter object created	OldPrinter has print(text) method
2	Create PrinterAdapter with OldPrinter	PrinterAdapter(oldPrinter)	PrinterAdapter object created	Adapter holds reference to OldPrinter
3	Call printText('Hello') on Adapter	PrinterAdapter.printText('Hello')	Calls oldPrinter.print('Hello')	Adapter converts printText to print
4	OldPrinter prints 'Hello'	OldPrinter.print('Hello')	Console outputs: Hello	OldPrinter does actual printing
5	End of flow	-	-	Adaptation successful

💡 Adapter pattern completes when the new interface method calls the old method successfully.

State Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
oldPrinter	null	OldPrinter instance	OldPrinter instance	OldPrinter instance	OldPrinter instance
adapter	null	null	PrinterAdapter instance (holds oldPrinter)	PrinterAdapter instance	PrinterAdapter instance

Key Insights - 3 Insights

Why does the Adapter need to hold a reference to the old object?

Because the Adapter calls the old object's methods internally to provide the new interface, as shown in execution_table step 3.

How does the Decorator add behavior without changing the original object?

The Decorator wraps the original object and adds extra actions before or after delegating calls, similar to how Adapter delegates but adds behavior.

What problem does the Facade solve compared to Adapter and Decorator?

Facade simplifies a complex system by providing a single interface, unlike Adapter which changes interfaces or Decorator which adds behavior.

Visual Quiz - 3 Questions

Look at the execution_table, what method does PrinterAdapter call internally at step 3?

A oldPrinter.print()

B oldPrinter.printText()

C PrinterAdapter.print()

D PrinterAdapter.printText()

💡 Hint

Check the 'Object/Method Called' column at step 3 in execution_table.

At which step does the actual printing to console happen?

A Step 2

B Step 3

C Step 4

D Step 5

💡 Hint

Look for the step where console outputs text in execution_table.

If the Adapter did not hold a reference to OldPrinter, what would happen at step 3?

A It would still print correctly

B It would cause an error because oldPrinter is undefined

C It would print twice

D It would skip printing

💡 Hint

Refer to variable_tracker to see the importance of adapter holding oldPrinter.

Concept Snapshot

Structural patterns help organize code structure.
Adapter changes an interface to match what client expects.
Decorator adds behavior without changing original object.
Facade provides a simple interface to a complex system.
Use Adapter for compatibility, Decorator for enhancements, Facade for simplicity.

Full Transcript

Structural patterns include Adapter, Decorator, and Facade. Adapter lets one interface work with another by converting calls. Decorator wraps an object to add new behavior without changing it. Facade offers a simple interface to a complex system, hiding details. The example shows Adapter wrapping an old printer to provide a new method. Step-by-step, the adapter calls the old printer's method to print text. Variables track the adapter holding the old printer instance. Key points include why the adapter holds the old object and how each pattern solves different problems. Quiz questions check understanding of method calls, execution steps, and variable roles.