Essential Java Design Patterns Implementation

Posted on Mar 5, 2026 in Computer Engineering

Composite Pattern

interface AComponent { int size(); }

public class File implements AComponent { private String name; private int size; public File(String name, int size) { super(); this.name = name; this.size = size; } public int size() { return size; } }

public class Directory implements AComponent { private List<AComponent> children; public Directory(String name) { children = new LinkedList<>(); } public int size() { int result = 0; for (AComponent child : children) result = result + child.size(); return result; } }

Strategy Pattern

public interface Strategy { int doOperation(int num1, int num2); }

public class Context { private Strategy strategy; public Context(Strategy strategy) { this.strategy = strategy; } public int executeStrategy(int num1, int num2) { return strategy.doOperation(num1, num2); } }

public class OperationAdd implements Strategy { @Override public int doOperation(int num1, int num2) { return num1 + num2; } }

Adapter Pattern

public class Usb { public int getPower() { return 1; } }

public class CigaretteLighterReceptacle { public int getEnergy() { return 2; } }

public class UsbToCarAdapter extends Usb { private CigaretteLighterReceptacle carInterface; public UsbToCarAdapter(CigaretteLighterReceptacle carInterface) { this.carInterface = carInterface; } public int getPower() { return carInterface.getEnergy(); } }

Iterator Pattern

public interface Container { public Iterator getIterator(); }

interface Iterator { boolean hasNext(); Object next(); }

public class NameRepository implements Container { public String[] names = {“Robert”, “John”, “Julie”, “Lora”}; @Override public Iterator getIterator() { return new NameIterator(); } private class NameIterator implements Iterator { int index; @Override public boolean hasNext() { return index < names.length; } @Override public Object next() { if (this.hasNext()) { return names[index++]; } return null; } } }

Observer Pattern

interface Observer { void update(int newValue); }

public class Subject { private List<Observer> observers = new ArrayList<>(); public void setState(int state) { this.state = state; notifyAllObservers(state); } public void attach(Observer observer) { observers.add(observer); } public void notifyAllObservers(int state) { for (Observer observer : observers) { observer.update(state); } } }

Abstract Factory Pattern

interface Boton { void pintar(); } interface Ventana { void abrir(); }

class BotonWindows implements Boton { } class VentanaWindows implements Ventana { }

class BotonLinux implements Boton { } class VentanaLinux implements Ventana { }

interface GUIFactory { Boton crearBoton(); Ventana crearVentana(); }

Visitor Pattern

interface Person { void accept(TaxiVisitor v); } interface TaxiVisitor { void visit(HastyPerson e); void visit(LeisurelyPerson e); }

State Pattern

public interface PackageState { void next(Package pkg); void prev(Package pkg); void printStatus(); }