策略

type
  //the algorithm is swappable
  IStrategy = interface
    function DoOperation(
      A, B: Integer): Integer;
  end;

  TAddStrategy = class(TInterfacedObject,
    IStrategy)
    function DoOperation(
      A, B: Integer): Integer;
  end;

  TSubtractStrategy = class(
    TInterfacedObject, IStrategy)
    function DoOperation(
      A, B: Integer): Integer;
  end;

  //context holds a strategy and
  //only calls it
  TCalc = class
  private
    FStrategy: IStrategy;
  public
    function Execute(
      A, B: Integer): Integer;
    procedure SetStrategy(
      const Strategy: IStrategy);
  end;

function TAddStrategy.DoOperation(
  A, B: Integer): Integer;
begin
  Result := A + B;
end;

function TSubtractStrategy.DoOperation(
  A, B: Integer): Integer;
begin
  Result := A - B;
end;

function TCalc.Execute(
  A, B: Integer): Integer;
begin
  if FStrategy = nil then
    Result := 0
  else
    Result := FStrategy.DoOperation(A, B);
end;

procedure TCalc.SetStrategy(
  const Strategy: IStrategy);
begin
  FStrategy := Strategy;
end;

var
  Calc: TCalc;
begin
  Calc := TCalc.Create;
  WriteLn('result1 is ', Calc.Execute(5, 3));
  //result1 is 0

  Calc.SetStrategy(TAddStrategy.Create);
  WriteLn('result2 is ', Calc.Execute(5, 3));
  //result2 is 8

  Calc.SetStrategy(TSubtractStrategy.Create);
  WriteLn('result3 is ', Calc.Execute(5, 3));
  //result3 is 2
end.