function TServicoMinhaClasse.getMinhaClasseById(Id: Integer): TMinhaClasse;
var
   cls: TMinhaClasse;
begin
   cls := TMinhaClasse.Create;
   Result := cls;
end;

Esse seria um código legal, se a classe não tivesse atributos. Para piorar esses dados ficam guardados em banco de dados. Portanto, eu preciso criar a conexão (ou usar uma existente) e criar uma nova consulta ao banco, configurando o banco. Para o nosso exemplo, vamos imaginar que a MinhaClasse tenha código e descrição somente. O código da unit da classe ficaria como o abaixo:

unit unMinhaClasse;

interface

type
   TMinhaClasse = class(TObject)

   private
      FDescricao: String;
      FID: Integer;
      procedure SetID(const Value: Integer);
      procedure SetDescricao(const Value: String);
   public
      property ID: Integer read FID write SetID;
      property Descricao: String read FDescricao write SetDescricao;
   end;

implementation

{ TMinhaClasse }

procedure TMinhaClasse.SetID(const Value: Integer);
begin
  FID := Value;
end;

procedure TMinhaClasse.SetDescricao(const Value: String);
begin
  FDescricao := Value;
end;

end.

Assim, para preencher essas propriedades, vamos modificar o corpo da nossa função para algo assim:

(...)
var
   qry: TSQLQuery;
begin
   cls := TMinhaClasse.Create;

   qry := TSQLQuery.Create;

   try
      qry.Database    := dModule.Database;
      qry.Transaction := dModule.Transaction;
      qry.SQL.Add('select * from tabela where id = :id');
      qry.ParamByName('id').AsInteger := Id;
      qry.Open;

      if not qry.IsEmpty then
      begin
         cls.ID        := qry.FieldByName('id').AsInteger;
         cls.Descricao := qry.FieldByName('descricao').AsString;
      end
      else
      begin
         cls := nil;
      end;
   finally
      qry.Free;
   end;

   Result := cls;
end;

Ok, ficou bom, mas imagine a longo prazo. Para cada uma das vezes que eu precisar da classe, eu teria de criar uma nova instância de SQLQuery e configura-la. Isso pode (e quase sempre vai) me induzir a errar em algum momento, na hora que eu esquecer de passar algum parâmetro ou mesmo validar se o banco está conectado. Para evitar todos esses problemas, criaremos um Builder, que para nós será simplesmente um construtor melhor para nossa SQLQuery.

Esse construtor vai ser instanciado dentro do objeto de serviço que e será vinculado à esse. Assim, todas as querys serão filhas desse objeto e serão destruídas quando esse for. Nesse builder vou precisar de duas propriedades: BancoDeDados e Transação. Assim, no construtor desse meu builder eu já as preencho e garanto que todos as querys ali criadas saem já configuradas como deve ser.

Desse jeito, a classe builder fica assim:

unit unQueryBuilder;

interface

uses
  SysUtils, Classes, SqlExpr, DBXpress;

type
   TQueryBuilder = class(TObject)
   private
      FTransacao: TTransactionDesc;
      FBancoDeDados: TSQLConnection;
      procedure SetBancoDeDados(const Value: TSQLConnection);
      procedure SetTransacao(const Value: TTransactionDesc);
   public
      property BancoDeDados: TSQLConnection read FBancoDeDados write SetBancoDeDados;
      property Transacao: TTransactionDesc read FTransacao write SetTransacao;
      function NovaInstancia(Dono: TComponent): TSQLQuery;
      constructor Create(Base: TSQLConnection; Trans: TTransactionDesc);
   end;

implementation

{ TQueryBuilder }

constructor TQueryBuilder.Create(Base: TSQLConnection; Trans: TTransactionDesc);
begin
   Self.BancoDeDados := Base;
   Self.Transacao := Trans;
end;

function TQueryBuilder.NovaInstancia(Dono: TComponent): TSQLQuery;
var
   pdsNovo: TSQLQuery;
begin
   pdsNovo := TSQLQuery.Create(Dono);
   pdsNovo.Database    := Self.BancoDeDados;
   pdsNovo.Transaction := Self.Transacao;
   Result := pdsNovo;
end;

procedure TQueryBuilder.SetBancoDeDados(const Value: TSQLConnection);
begin
   FBancoDeDados := Value;
end;

procedure TQueryBuilder.SetTransacao(const Value: TTransactionDesc);
begin
   FTransacao := Value;
end;

end.

Assim, toda vez que instanciar o novo serviço, devemos criar uma variável (ou propriedade) que armazene esse objeto Builder, mais ou menos assim:

   FabricaQuery := TQueryFactory.Create(Base, Trans);

Refatorando a chamada da função, teremos isso:

function TServicoMinhaClasse.getMinhaClasseById(Id: Integer): TMinhaClasse;
var
   qry: TSQLQuery;
   cls: TMinhaClasse;
begin
   qry := FabricaQuery.NovaInstancia(nil);

   try
      qry.SQL.Add('select * from tabela where id = :id');
      qry.ParamByName('id').AsInteger := Id;
      qry.Open;

      if not qry.IsEmpty then
      begin
         cls.ID        := qry.FieldByName('id').AsInteger;
         cls.Descricao := qry.FieldByName('descricao').AsString;
      end
      else
      begin
         cls := nil;
      end;
   finally
      qry.Free;
   end;

   result := cls;
end;

Talvez ainda tenha muito mais a melhorar, mas já está melhor do que inicial. Embora, aparentemente, o ganho tenha sido pouco, a vantagem desse padrão só seria sentida se não o utilizássemos. As propriedades poderiam ser preenchidas incorretamente e mais validações poderiam deixar de ser executadas. Dá para aprimorar muito mais. Mas eu vou até aqui, o resto deixo com vocês.

Pessoal, esse código pode gerar alguns erros. Ele foi originalmente escrito para a empresa que trabalho e por isso, muito do que era usado aqui foi substituído por componentes genéricos.

Segue o material do nosso último treinamento, sobre como usar o Delphi, orientado à objetos.
Embora pareça que estamos trabalhando com OO desde sempre, afinal instanciamos objetos baseados em classes, isso não é inteiramente verdade.
Como me disse um professor certa vez: “Seu sistema é orientado à objetos? Ótimo. Me mostre a sua classe NotaFiscalSaída.”

Assim achei por bem usar um exemplo bem simples, estados e cidades para mostrar o poder que o Delphi tem e de quebra demonstrar que o que está errada é a maneira como programamos e não a linguagem que usamos, seja ela qual for.

Primeiramente, começamos com alguns paralelos. No Delphi, para criarmos uma classe, precisamos cria-la como um componente, para mais tarde, criar instancias dele. Usando o Delphi 2006, eu vou em File > New > Package. Então no Project Manager eu clico sobre o pacote com o botão direito e escolho Add New > Other…

A janela que se abrirá me dá várias opções, a que vamos usar está em Delphi Projects > Delphi Files > Component. No Wizard seguinte escolhemos de qual componente o nosso irá herdar suas características (não vou explicar herança aqui). Nesse momento escolheremos TComponent, para pegar somente o mínimo necessário. Na próxima tela, escolha o nome do componente em Class Name, para nós será TCidade (o “T” é padrão do Delphi, use sem questionar). Escolha a Pallete Page que deseja ou digite uma nova, lembre que esse campo é Case Sensitive, portanto atenção ao digitar. Preencha os demais campos se precisar.

A classe cidade:

unit cidade;

interface

uses
  SysUtils, Classes, Estado;

type
  TCidade = class(TComponent)
  private
    Fcid_nome: string;
    Fcid_codigo: integer;
    Festado: TEstado;
    procedure Setcid_codigo(const Value: integer);
    procedure Setcid_nome(const Value: string);
    procedure Setestado(const Value: TEstado);
    { Private declarations }
  protected
    { Protected declarations }
  public
    { Public declarations }
  published
    { Published declarations }
    property cid_codigo: integer read Fcid_codigo write Setcid_codigo;
    property cid_nome: string read Fcid_nome write Setcid_nome;
    property estado: TEstado read Festado write Setestado;
  end;

procedure Register;

implementation

procedure Register;
begin
  RegisterComponents('Objetos Produtec', [TCidade]);
end;

{ TCidade }

procedure TCidade.Setcid_codigo(const Value: integer);
begin
  Fcid_codigo := Value;
end;

procedure TCidade.Setcid_nome(const Value: string);
begin
  Fcid_nome := Value;
end;

procedure TCidade.Setestado(const Value: TEstado);
begin
  Festado := Value;
end;

end.

Vamos falar um pouco da classe cidade. Nela eu coloquei os principais atributos de uma cidade, somente para exemplo. Percebam que os mesmos foram criados baseado na seguinte estrutura:

private
    Fcid_nome: string;
published
    property cid_nome: string read Fcid_nome write Setcid_nome;

(…)

procedure TCidade.Setcid_nome(const Value: string);
begin
  Fcid_nome := Value;
end;

Traduzindo, teremos uma propriedade com o nome cid_nome, do tipo string (notem que sem tamanho definido) que lê o valor para uma variável Fcid_nome e grava através de uma procedure chamada como Setcid_nome. Ótimo, mas o que ganhamos com isso? Para que esconder o real valor de uma variável ao invés de simplesmente torná-la pública? E para que criar um procedimento para atribuir o valor, se a mudança da visibilidade já resolveria? Parece tudo uma grande perda de tempo, mas é um foco na segurança e no reuso.
Imaginem que em determinado momento, nós precisaremos delimitar o tamanho da cidade para o máximo de caracteres que existem no banco de dados, que para o nosso exemplo é de 60 caracteres. Alterando o procedimento SetCid_Nome todo, eu disse TODO, o sistema passa a respeitar a nova regra, sem precisar avisar a nenhuma outra parte do sistema que isso aconteceu. Vejam como ficaria:

procedure TCidade.Setcid_nome(const Value: string);
begin
   if Length(Value) < 60 then
      Fcid_nome := Value;
end;

Viram que simples? Poderíamos melhorar ainda, criando uma mensagem de erro (exceção) que poderia ser tratada pela tela que realizou a chamada ou simplesmente exibida diretamente em tela. Algo mais ou menos assim:

procedure TCidade.Setcid_nome(const Value: string);
begin
   if Length(Value) < 60 then
      Fcid_nome := Value
   else
      raise Exception.Create('O nome da cidade não pode conter mais do que 60 caracteres.');
end;

Várias validações ou procedimentos poderiam ser feitos no momento em que a propriedade é atribuída, como preencher uma outra propriedade, carregar outros componentes em tela, enfim, o limite fica por conta da necessidade do programador.
Se eu não disse antes, o nome desse método chama-se encapsulamento, pois os atributos ficam protegidos (encapsulados) em métodos que lêem e escrevem nas variáveis.
Isso é meio caminho para um estereótipo usado em UML chamado JavaBean, que os meninos que mexem com Java devem conhecer bem.

Ai você me pergunta:

Pô Juliano, então você está me dizendo que eu to jogando meu dinheiro fora? Que se eu quiser realmente aprender vou ter de me virar?

Bom, é e não é. Nesse momento em que estou do curso faço a seguinte avaliação: estamos num curso de programação para a web e o que os alunos mais reclamam é que não conseguem aprender programação. Gente, pelo divino, o curso é de programação. Ou aprendem isso ou saiam. Não estou expulsando ninguém, mas poxa, basta um mínimo de dedicação que a coisa flui. Nós estamos atrasados 3 bimestres com a matéria de PHP. Já deveríamos estar estudando Flex e ainda estamos em Javascript. Isso é completamente inaceitável.

Não estou generalizando. Vi excelentes iniciativas de pessoas que foram atrás, pagaram professores particulares, procuram alunos que saibam programar e conseguem melhorar o seu desempenho. Isso é salutar.

Esse post tem o seguinte intuito. Dar uma sacudida em todos vocês que esperam que a faculdade ensine todas as informações que você precisa para vida profissional.

No pain, no gain.

De outro lado, professores, não perguntem se não querem ouvir a resposta. Ontem um professor deixou um espaço aberto para que os alunos questionassem a prova e ficou furioso com o que ouviu. Mil desculpas, mas você perguntou. Citar referências externas para que alunos que querem se dedicar a isso possam ampliar seus conhecimentos é excelente. Falar que só porque essas referências foram citadas elas são matéria de prova, é ridículo.

Caros professores, temos uma vida fora da faculdade. Não somos máquinas de estudar bem como vocês não são máquinas de ensinar. Não cobre conhecimentos profundos de orientação à objetos se para muitos é a primeira vez que veem isso na vida.

Espero não ter sido muito ofensivo ou irritante, o espaço, como sempre, fica aberto para quem quiser se pronunciar. Abraços

Ontem depois de uma aula com o professor que ficou magoado com nossas notas, tivemos uma excelente aula introdutória (ui) sobre JavaScript. Aula interessante e bem básica, para se entender os conceitos fundamentais dessa “linguagem”.

Nosso querido professor, Ramazotti, disponibilizou alguns materiais na sua área, que eu estou replicando-os aqui. Espero ajudar. Parafraseando o Rodrigo:

programar é gostoso, morrer queimado é melhor ainda.

Apostila de Javascript e Apostila de Prototype