Structural Patterns

• Compose classes and objects into bigger structures; behaviour contracts stay unchanged
• Favour composition over inheritance
• Wrapper holds a reference to the wrapped object and forwards calls
• Patterns differ in intent, not in shape

• Client expects Target; existing Adaptee has an incompatible interface
• Adapter implements Target, translates each call to the Adaptee
• Object adapter: holds adaptee by composition, preferred, works with subclasses
• Class adapter: inherits adaptee via multiple inheritance, rare

class XmlToJsonAdapter implements JsonSource {
  constructor(private xml: XmlSource) {}
  read() { return toJson(this.xml.read()); }
}

object adapter: translates read()

• One simplified entry point over a complex subsystem
• VideoConverter.convert(file, 'mp4') hides codec, bitrate and audio classes
• Subsystem classes stay publicly usable

• Wraps an object with the same interface, adds work before or after delegating
• Decorators stack; the client picks the order
• Java: new BufferedReader(new FileReader(f))
• Python: @decorator adds logging or caching around a call

• Stand-in with the same interface that guards the real object
• Virtual: lazy-load the costly object
• Protection: permission check
• Remote: network stub
• Caching: reuse earlier results

• Order matters: compress then encrypt, since ciphertext barely compresses
• Proxy that swallows errors or breaks the interface
• Subclass per feature combination: class explosion, use decorators

• Component interface shared by Leaf and Composite
• Composite holds child Components, forwards calls
• Client treats one object and a tree alike

class File:
    def size(self): return self.bytes
class Folder:
    def size(self):
        return sum(c.size() for c in self.children)

Folder recurses; File is the base case

• add(), remove() on Composite: safe
• On Component: transparent, leaves fail
• Trade-off: transparency vs safety

• Abstraction and Implementor hierarchies joined by composition
• Shape with Renderer: Circle/Square x Vector/Raster
• M+N classes, not M×N

• Bridge when only one dimension varies
• Mixing up Strategy: it swaps an algorithm, Bridge a whole implementation hierarchy

• One implementation only: skip the pattern
• A plain function or direct call is enough: skip it

• Facade may use Adapters inside
• Composite tree may be wrapped by Decorators
• Proxy can front a Facade

• Proxy kinds: virtual, protection, remote, cache