Tudo sobre Delphi - Parte 1

Conceito de Programação Orientada a Objeto
Para compreendermos melhor a novo ambiente de desenvolvimento da Borland o Delphi é necessário que você, aprenda e, tenha em mente os conceitos de POO (Programação Orientada a Objetos), não confunda os conceitos com POE (Programação Orientada a Eventos) muito difundido com o Access 2.0 © (um ambiente baseado em Objetos), mas ao longo deste capítulo você vai notar as sensíveis diferenças que existem entre esses dois conceitos.
A POO e a POE são facilmente confundidas, mas lembre-se a POO contém a POE mas a POE não contém a POO, um objeto pode existir mesmo que não exista nenhum evento associado a ele, mas um evento não pode existir se não houver um objeto a ele associado. Outra característica que pode causar confusão são ambientes Orientados a Objetos e ambientes Baseados em Objetos. Em ambiente Orientado a Objetos consegue-se criar e manipular objetos enquanto que o Baseado em Objetos não é possivel a criação de objetos apenas a sua manipulação.
A POO é um conceito desenvolvido para facilitar o uso de códigos de desenvolvimento em interfaces gráficas. Sendo a Borland, uma das primeiras a entrar neste novo conceito, possui suas principais linguagens de programação (tais como Object Pascal e C++), totalmente voltadas para este tipo de programação. A POO atraiu muitos adeptos principalmente pelo pouco uso de código que o projeto (diferente de sistema) carrega no programa fonte, ao contrário das linguagens mais antigas como o Clipper’87 © muito utilizado no final da década de 90 e início da década de 90. O resultado desta “limpeza” no código resulta que a manutenção do projeto torna-se muito mais simples.
Orientação a Objeto
Antes de começarmos a falar realmente de linguagem orientada a objetos e necessário que você possua os conceitos básicos da orientação a objetos, são eles:


Objeto - é qualquer estrutura modular que faz parte de um produto. Uma janela por exemplo, é um objeto de uma casa, de um carro ou de um software com interface gráfica para o usuário.
Atributos - São as características do objeto, como cor e tamanho, a janela, por exemplo, tem atributos como o modelo, tamanho, abertura simples ou dupla, entre outros.
Encapsulação - é um mecanismo interno do objeto “escondido” do usuário. Uma pessoa pode abrir uma janela girando a tranca sem precisar saber o que há dentro dela.
Ação - é a operação efetuada pelo objeto. Todas as janelas, por exemplo, controlam a iluminação e temperatura ambiente, dependendo do seu design.
Herança - um objeto novo nem sempre é criado do zero. Ele pode “herdar” atributos e ações de outros já existentes. Um basculante herda atributos das janelas e das persianas.
Polimorfismo - é a capacidade de objetos diferentes reagirem segundo a sua função a uma ordem padrão. O comando “abre”, por exemplo, faz um objeto entrar em ação, seja ele uma janela, uma porta ou uma tampa de garrafa.
Ligação - é quando um objeto conecta a sua ação a outro. Um sensor de claridade, por exemplo, ativa o acendimento automático da iluminação de rua.
Embutimento - Permite a um objeto incorporar funções de outros, como um liqüidificador que mói carne com a mudança do tipo da lâmina.
Object Pascal
Object Pascal é uma linguagem Orientada a Objetos não pura mas híbrida por possuir características de programação não só visual mas também escrita, para os programadores que já conhecem técnicas de estruturas de programação, com o C, Basic, Pascal ou xBASE entre outras linguagens a Object Pascal providência uma migração de forma natural oferecendo um produto de maior complexibilidade. Object Pascal força a você executar passos lógicos isto torna mais fácil o desenvolvimento no ambiente Windows© de aplicações livres ou que utilizam banco de dados do tipo Cliente/Servidor, trabalha com o uso de ponteiros para a alocação de memória e todo o poder de um código totalmente compilável. Além disso possibilita a criação e reutilização (vantagem de re-uso tão sonhado com a Orientação a Objetos) de objetos e bibliotecas dinâmicas (Dynamic Link Libraries - DLL).
Object Pascal contém todo o conceito da orientação a objetos incluindo encapsulamento, herança e polimorfismo. Algumas extensões foram incluídas para facilitar o uso tais como conceitos de propriedades, particulares e públicas, e tipos de informações em modo run-time, manuseamento de exceções, e referências de classes. O resultado de toda esta junção faz com que Object Pascal consiga suportar as facilidades de um baixo nível de programação, tais como:
• Controle e acesso das subclasses do Windows© (API);
• Passar por cima das mensagens de loop do Windows©;
• Mensagens semelhantes as do Windows©;
• Código puro da linguagem Assembler.
Como deu para perceber a base de toda a programação Delphi é a linguagem Object Pascal, então neste capítulo trataremos exclusivamente deste tipo de programação.
Símbolos Especiais
A Object Pascal aceita os seguintes caracteres ASCII:
 Letras - do Alfabeto Inglês: A até Z e a até z.
 Dígitos - Decimal: 0 até 9 e HexaDecimal: 0 até 9 e A até F (ou a até f)
 Brancos - Espaço (ASCII 32) e todos os caracteres de controle ASCII (ASCII 0 até ASCII 31), incluindo final de linha e Enter (ASCII 13).
 Especiais - Caracteres: + - * / = < > [ ] . , ( ) : ; ^ @ { } $ #
 Símbolos - Caracteres: <= >= := .. (* *) (. .) //
 O colchetes esquerdo ( [ ) e equivalente ao (. e o colchetes direito ( ] ) e equivalente a .). A chave esquerda ( { ) e equivalente ao (* e a chave direita ( } ) e equivalente a *).
Palavras Reservadas
A Object Pascal se utiliza das seguintes palavras reservadas, não podendo as mesmas serem utilizadas ou redefinidas:
And Exports Library Set
Array File Mod Shl
As Finnaly Nil Shr
Asm For Not String
Begin Function Object Then
Case Goto Of To
Class If On Try
Const Implementation Or Type
Constructor In Packed Unit
Destructor Inherited Procedure Until
Div Initialization Program Uses
Do Inline Property Var
Downto Interface Raise While
Else Is Record With
End Label Repeat Xor
Except
Uma outra lista a seguir, apresenta as diretivas que são utilizadas em contextos de identificação de objetos:
Absolute Export Name Published
Abstract External Near Read
Assembler Far Nodefault Resident
At Forward Override Stored
Cdecl Index Private Virtual
Default Interrupt Protected Write
Dynamic Message Public
Números
É possível definir variáveis e constantes de tipos de Inteiro ou Real através de qualquer decimal ordinário ( 0 a 9 ), mas a Object Pascal também aceita a notação Hexadecimal utilizados com o prefixo dollar ( $ ) ou a notação científica ( E ).
Constantes
Uma constante é um identificador com valor(es) fixo(s). Um bloco de declarações constante possui a seguinte expressão:
[Declaração Constante] [Identificador] (=) [constante] (;)
A lista abaixo apresenta um conjunto de funções que podem ser utilizadas para a declaração das constantes:
Ab Length Ord SizeOf
Chr Lo Pred Succ
Hi Low Ptr Swap
High Odd Round Trunc
Alguns exemplos para a definição de Constantes:
const Min = 0;
Max = 100;
Centro = (Max - Min) div 2;
Beta = Chr(225);
NumLetras = Ord('Z') - Ord('A') + 1;
MensOla = 'Instrução inválida';
MensErro = ' Erro: ' + MensOla + '. ';
PosErr = 80 - Length(MensErro) div 2;
Ln10 = 2.302585092994045684;
Ln10R = 1 / Ln10;
DigNumericos = ['0'..'9'];
LetrasAlpha = ['A'..'Z', 'a'..'z'];
AlphaNum = LetrasAlpha + DigNumericos;
Expressões
As expressões em Object Pascal (como em qualquer linguagem) é formada por operadores e operandos; os operadores são divididos em quatro categorias básicas:
Únicos @, Not
Multiplicativos >, /, div, mod, and, shl, shr, as
Adicionais +, -, or, xor
Relacionais =, < >, <, >, < =, > =, in, is
As expressões obdecem as regras básicas de lógica para a precedência da execução das operações.
Identificadores
Identificadores podem ser constantes, tipos, variáveis, procedures, funções, unidades, programas e campos de registros.
Não existe limite de caracteres para o nome de um identificador mas apenas os 63 primeiros caracteres são significantes (não podendo ser idêntico ao nome das palavras reservadas). O nome de um identificador deve ser iniciado por Letras ou o carácter underscore ( _ ). O resto é formado por Letras, Dígitos, carácter underscore (ASCII $5F). Não é permitido a utilização de espaços para a formação do nome.
 Exemplo de identificadores válidos: Form1, SysUtils.StrLen, Label1.Caption
with... do...;
Delimita um determinado bloco de declarações para um identificador específico evitando a declaração deste identificador. A sintaxe do comando é: WITH {nome do identificador} DO {comandos};. Ex:

begin
{ ... comandos iniciais ... }
with form1 do
begin
Caption := ‘Teste’;  Equivalente a Form1.Caption
BorderStyle := bsSizable;  Equivalente a Form1.BorderStyle
end;
end;
array [ ... ] of ...;
Define um conjunto de variáveis ou constantes de um mesmo tipo. A sintaxe do comando é: array [{quantidade de ocorrencias}] of {Tipo};. Os arrays são controlados por três funções:

Função Valor de Retorno
Low Primeiro elemento
High Aponta para o último elemento
SizeOf Tamanho do array
Ex:

const
t: array [1..50] of Char { Declara 50 elementos para o tipo Char }
var
s : array[1..100] of Real { Declara 100 elementos para o tipo real }
ind: Integer;
begin
for Ind := Low(s) to High(s) do s[Ind] := 0; { Zera os elementos do array S }
if SizeOf(t) = ‘C’ then exit; { Se o último elemento do array T for ‘C’ sai do bloco }
{ ... outros comandos... }
end;

Declarações
Declarações descrevem ações de um algorítmo a serem executadas.
begin... end;
Prende um conjunto de declarações em um bloco de comandos determinado. A sintaxe do comando é: BEGIN {comandos} END;. Ex:

begin
{ ... comandos iniciais ... }
begin
{ ... bloco 1 ... }
end;
begin
{ ... bloco 2 ... }
end;
{ ... comandos finais ... }
end;

if... then... else...;
Esta expressão escolhe entre o resultado de uma condição booleana o caminho verdadeiro (then) ou falso (else). A sintaxe do comando é: IF {condição} THEN {bloco de comandos} ELSE {bloco de comandos};. Ex:

begin
{ ... comandos iniciais ... }
if x > 2 then
{ ... Bloco verdadeiro ... }
else
{ ... Bloco falso ... };
end;

goto... ;
Transfere a execução de um programa para o ponto determinado pelo Label. A sintaxe do comando é: GOTO {Label};. Ex:

label
primeiro;
begin
{ ... comandos iniciais ... }
if x = 2 then
goto primeiro;
{ ... outros comandos ... }
Primeiro:
{ ... comandos do Primeiro ... }
end;

case... of... else... end;
Consiste de uma lista de declarações que satizfaz a condição de um seletor de expressões, se nenhuma parte da lista satisfizer ao seletor executa os comandos do sub-comando else. Para o seletor serão válidos os tipos definidos, tipo Inteiros ou LongInt. A sintaxe do comando é: CASE {seletor} OF {Expressão 1}: {comando da expressão 1}; {Expressão 2}: {comando da expressão 2}; {Expressão n}: {comando da expressão n} ELSE {comando}; end;. Ex:

begin
{ ... comandos iniciais ... }
case x of
1: { ... Bloco para x = 1 ... }
2, 3: { ... Bloco para x = 2 ou X = 3... }
4..6: { ... Bloco para 4 <= x <= 6 ... }
else
{ ... Bloco para x < 1 ou x > 6 ... };
end;
end;

repeat... until;
Repete um determinado bloco de declarações até a condição booleana do subcomando until ser satisfeita. A sintaxe do comando é: REPEAT {comandos}; until {condição};. Ex:

begin
{ ... comandos iniciais ... }
x := 0;
repeat
x := x + 1
until (x = 2);
end;

for... to (downto)... do...;
Incrementa em 1 uma determinada variável inteira, repetindo um bloco de comandos, até que esta atinja o valor final do intervalo, o subcomando downto realiza o incremento reverso. A sintaxe do comando é: FOR {variavel} := {valor inicial} to (downto) {valor final} do {bloco de comandos};. Ex:

begin
{ ... comandos iniciais ... }
for i := 1 to 10 do  Executa o [comandos A] para i = 1,2,3,4,5,6,7,8,9 e 10
{ ... Comandos A ... }
for s := 10 downto 1 do  Executa o [comandos B] para i = 10,9,8,7,6,5,4,3,2 e 1
{ ... Comandos B... }
end;

while... do...;
Repete um bloco de comandos enquanto que determinada condição booleana seja satisfeita. A sintaxe do comando é: WHILE {condição} DO {bloco de comandos};. Ex:

begin
{ ... comandos iniciais ... }
while i := 1 do  Repete o [Bloco de comandos] enquanto i = 1
{ ... Bloco de comandos ... }
end;

break; ou continue...;
O comando break interrompe um bloco de repetição for, while ou repeat saindo do bloco. A sintaxe do comando é: BREAK; enquanto que o comando continue retorna a primeira instrução do bloco de repetição for, while ou repeat. A sintaxe do comando é: CONTINUE;. Ex:

begin
{ ... comandos iniciais ... }
for i := 1 to 10 do
begin
if i = 8 then
break;  Salta para os [comandos C]
{... comandos A...}
if i = 5 then
continue;  Retorna para o comando for pulando os [comandos B]
{... comandos B ...}
end;
{... comandos C ...}
end;
Blocos de Procedimentos ou Funções
As procedures ou funções são declaradas na seção de tipos de declarações (abaixo do comando type) pertencendo ao objeto ou serem do tipo public (públicas - executadas por outras unidades) ou private (particulares - restritas a unidade local).
Procedure
procedure {cabeçalho}; var {declaração das variáveis}; {bloco de comandos};
O cabeçalho da procedure é composto pelo nome do procedimento e variáveis que serão recebidas (ou modificadas através da declaração var, ex: procedure teste(var x:string);).

procedure soma(a,b: integer);  Início enviando as variáveis A e B do tipo inteiro.
var  Declaração de variáveis locais.
c: integer;
begin  Corpo do procedimento.
c := a + b;
end;

Function
function {cabeçalho} : {resultado}; var {declaração das variáveis}; {bloco de comandos};
As funções se diferem dos procedimentos pela obrigatoriedade do retorno de um resultado, podendo este resultado ser retornado pela declação: {nome da função} := valor ou result := valor.

function soma(a,b: integer) : integer;  Início enviando as variáveis A e B do tipo inteiro.
begin  Corpo do procedimento.
soma := a + b;  ou result := a + b;
end;
 Junto com o Delphi 2.0 vem o manual de Object Pascal em formato .HLP, caso a linguagem seja novidade para você aconselho que você dê uma boa olhada (o Delphi 1.0 traz o mesmo manual, mas em formato .PDF), mas não se preocupe com o que foi explicado acima já está mais do que suficiente para uma boa inicialização com o Delphi.
Tudo o que vimos a cima é o que normalmente temos em outras linguagens comuns, mas o caracteriza realmente a linguagem Orientada em Objetos é o trabalho e a manipulação com os mesmos.
Características de Objetos
Mas afinal de contas, o que é um objeto ? Como foi dito anteriormente, um objeto é qualquer tipo de elemento, ou componente, que envolva dados e código dentro de um único pacote.
Uma vantagem de programar na POO e quanto a Herança dos objetos, este método faz com que seja possível um objeto ‘Filho’ poder herdar todas as características e conteúdos de um objeto ‘Pai’. Tirando um pouco do Pascal da geladeira (a partir do Pascal versão 7.0 a Borland tornou possível a utilização simplificada de todo o conceito de POO) aqui vai um código completo de declaração de dois objetos, o primeiro chamado de TPai e o segundo de Tfilho:

TPai = object
Nome: PChar;
constructor Init (P: PChar);
destructor Done;
procedure MudaNome(P: PChar);
procedure ShowName;
end;

TFilho = object(TPai)
procedure MudaNome(P: PChar);
end;

O segundo objeto TFilho herda do objeto TPai o ponteiro variável Nome, a constructor Init, o destructor Done e a procedure ShowName, apenas a procedure MudaNome terá o funcionamento como uma característica única para cada objeto. O Delphi possui inúmeros “pais” (classes de objetos) prontos para serem usados por você, tais como:
TForm: Centro das aplicações Delphi, utilizados na criação de janelas, caixas de diálogo entre outros.
TMenu: Responsável pela concepção de menus e menu popup.
TButtonControl: Simplifica o refinamento do controle da janela serve de base para os componentes como: Botões, Check Box e Radio Box.
Programando com objetos Delphi
Quando iniciado o Delphi, é criado automaticamente um novo projeto e um objeto formulário (derivado da classe TForm) para o suporte dos demais objetos. Explorando o Editor de Códigos (Code Editor) você poderá observar a declaração do novo objeto da classe TForm que foi produzido automaticamente com a criação do novo formulário. Examinando o conteúdo deste código criado para o objeto, teremos:

unit Unit1;  Abertura de uma nova unidade

interface  Parâmetros do obejetos

uses
SysUtils, WinTypes, WinProcs, Messages, Classes, Graphics, Controls,  Uso de outras unidades
Forms, Dialogs;

type
TForm1 = class(TForm)  A declaração do objeto inicia aqui
private
{ Private declarations }
public
{ Public declarations }
end;  Aqui é o final da declaração

var
Form1: TForm1;  Atribui a variável Form1 as características do objeto TForm1

implementation  Início da parte a ser implementada

{$R *.DFM}  Diretiva de compilação que agrega o desenho da tela (em .DFM) com o mesmo nome da unidade
end.  Final da parte implementada

Um novo tipo de objeto TForm1, é declarado derivado da classe TForm, que também é um outro objeto. Relembre um objeto é um tipo de elemento capaz de guardar dados e código dentro de um único pacote. Até agora, o tipo TForm1 não contém campos ou métodos, isso acontecerá com a adição de alguns componentes neste objeto.
Observando o código, notamos que existe uma variável declarada com o nome Form1 para o novo tipo de objeto TForm1:
var
Form1: TForm1;

Form1 é a chamada de instância ao tipo TForm1. Esta variável refere-se ao formulário em si, aonde será adicionado componentes e desenhado a interface entre o computador e o usuário que for operar o sistema. É sempre notado declarações de uma ou mais instâncias referidas ao tipo de objeto. Futuramente será mostrado o poder deste tipo de declarações quando falarmos sobre janela MDI (Multiple Document Interface - Interface de documento múltiplos) gerenciando várias “janelas filhas”, não permitindo que estas “janelas filhas” saiam do espaço criado pela “janela pai”.
Adicionando alguns componentes ao formulário, veremos como o Delphi completará a aplicação escrevendo automaticamente o código, e permitindo que ao final tornar-se-á possível a compilação (lembra-se do Clipper©, com .EXE), execução e distribuição da aplicação.
Em nosso formulário, colocaremos um botão que, em tempo de execução, ao ser dado um clique com o mouse sobre este objeto, o formulário mude sua cor. Aperte a tecla F12 para retornar a visão do formulário e na palheta de objetos (Componnent Pallete) clique no objeto (button localizado na página Standard) e clique no formulário. Na janela da Object Inspector clique na página Events e clique duas vezes sobre a ação OnClick e insira o seguinte código:

procedure TForm1.Button1Click(Sender: TObject);
begin
Form1.Color := clGreen;
end;
Reparando no código completo da aplicação, veremos:

unit Unit1;

interface

uses
SysUtils, WinTypes, WinProcs, Messages, Classes, Graphics, Controls,
Forms, Dialogs;

type
TForm1 = class(TForm)
Button1: TButton;  Um novo dado foi aqui inserido
procedure Button1Click(Sender: TObject);  Declarado um novo método
private
{ Private declarations }
public
{ Public declarations }
end;

var
Form1: TForm1;

implementation

{$R *.DFM}

procedure TForm1.Button1Click(Sender: TObject);  O código do novo método
begin
Form1.Color := clGreen;
end;

end.
O novo objeto TForm1 agora apresenta um campo Button1 - o botão que você adicionou ao formulário. TButton e o tipo do objeto, e Button1 é o objeto botão propriamente dito. Com o tempo você colocará novos componentes ao formulário.
Rode o projeto, clicando no botão (Run), dê um clique no botão e veja o que acontece. Pare a aplicação fechando a janela com Alt+F4.
 Só por curiosidade, salve este arquivo, feche-o e abra o arquivo UNIT1.DFM (com a opção File | Open File...) notaremos que o Delphi criou um arquivo com todas as propriedades dos objetos criados e que a declaração do objeto Form1 engloba todos os outros, noções de Encapsulamento.
Renomeando os objetos e os componentes
Você sempre deve utilizar a janela do Object Inspector para renomear os objetos criados. Por exemplo, o nome padrão do formulário e Form1 mude a propriedade Name para fCores. O Delphi se encarregará de mudar qualquer referência que existia ao Form1. Então o código apresentará a seguinte modificações:

unit Unit1;

interface

uses
SysUtils, WinTypes, WinProcs, Messages, Classes, Graphics, Controls,
Forms, Dialogs;

type
TfCores = class(TForm)  Aqui foi modificado
Button1: TButton;
procedure Button1Click(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;

var
fCores: TfCores;  Aqui foi modificado

implementation

{$R *.DFM}

procedure TfCores.Button1Click(Sender: TObject);  Aqui foi modificado
begin
Form1.Color := clGreen;  Aqui não !!!
end;

end.
 O Delphi modificará apenas os códigos gerados automaticamente pôr ele. Os códigos para a ação OnClick foram gerados por você e o Delphi não os modificará. Cabe a você a manutenção neste caso. Isto foi idealizado para preservar o conteúdo original do seu código.

procedure TfCores.Button1Click(Sender: TObject);
begin
fCores.Color := clGreen;
end;