Introdução - Object Pascal

É uma linguagem de programação declarativa, fortemente tipada.
Declarativa: Significa que cada declaração possui uma seção especifica para tal.
Contém todo o conceito da orientação a objetos:

• Abstração.


• Encapsulamento.


• Herança.


• Polimorfismo.

Algumas extensões foram incluídas para otmizar o uso tais como:

• Conceitos de propriedades, particulares e públicas.


• Tipos de informações em modo run-time: RTTI.


• Manuseamento de exceções, e referências de classes.

Além disso a Object Pascal consegue suportar as características de 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.

A base de toda a programação Delphi é a linguagem Object Pascal, hoje em dia rebatizada de Delphi Language. Neste artigo trataremos exclusivamente de uma introdução a esta linguagem de programação.

Símbolos Especiais

A ceita 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

Utiliza-se 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

Estruturas

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;

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... ; (OBS: Nunca usem isso)
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 <> 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;