Pattern pattern pattern: classi astratte e delegazione dell'interfaccia

Il modello del metodo di modello viene comunemente implementato con classi astratte.

interface Algorithm 
{
    void perform();
}

abstract class AlgorithmBase implements Algorithm
{
    abstract void step1();
    abstract void step2();

    private void finalStep()
    {
        // common implementation
    }

    // Template method 
    public final void perform() 
    {
        step1();
        step2();
        finalStep();
    }
}

public class AlgorithmA extends AlgorithmBase
{
    void step1()
    {
        // step 1 implementation
    }

    void step2()
    {
        // step 2 implementation
    }
} 

utilizzando

  Algorithm a = new AlgorithmA();
  a.perform();

Ma alcuni linguaggi (come Swift) non supportano le classi astratte. L'implementazione del modello di metodo template viene eseguita tramite la delega dell'interfaccia.

protocol Algorithm
{
    func perform()
}

protocol AlgorithmSteps
{
    func step1()
    func step2()
}

class AlgorithmBase: Algorithm
{
    var delegate: AlgorithmSteps

    init(delegate: AlgorithmSteps)
    {
        self.delegate = delegate
    }

    private func finalStep()
    {
        // common implementation
    }

    // Template method
    final func perform()
    {
        delegate.step1()
        delegate.step2()
        finalStep()
    }
}

class AlgorithmA : AlgorithmSteps
{
    func step1()
    {
        // step 1 implementation
    }

    func step2()
    {
        // step 2 implementation
    }
}

let a : Algorithm = AlgorithmBase(delegate: AlgorithmA())
a.perform()

Ovviamente se la lingua non supporta le classi astratte l'unica strada da percorrere è l'utilizzo della delega dell'interfaccia, ma cosa succede se lo fa? Quindi, il modello di metodo del modello può essere implementato in entrambi i modi.

La seconda implementazione ha qualche vantaggio in termini di buone pratiche OOP rispetto al primo?