Fundamentos do Object Pascal

Conceitos de Programação Orientada a Objetos

Antes de partir para a linguagem propriamente dita, vamos revisar alguns conceitos básicos de Programação Orientada a Objetos.

Classe: Definição de tipo dos objetos, modelo de objeto.

Objeto: Instância de classe, variável cujo tipo é uma classe.

Atributos: Variáveis de instância, são os dados de um objeto.

Métodos: Funções e procedimentos de um objeto.

Propriedades: Apelido usado para evitar o acesso direto aos atributos de um objeto, onde podemos especificar métodos que serão usados para ler e atribuir seus valores a esses atributos.

Mensagens: Chamada de métodos, leitura e atribuição de propriedades.

Encapsulamento: Conjunto de técnicas usadas para limitar o acesso aos atributos e métodos internos de um objeto.

Herança: Possibilidade de criar uma classe descendente de outra, aproveitando seus métodos, atributos e propriedades.

Ancestral: Super classe ou classe de base, a partir da qual outras classes podem ser criadas.

Descendente: Subclasse.

Hierarquia de Classes: Conjunto de classes ancestrais e descendentes, geralmente representadas em uma árvore hierárquica.

Polimorfismo: Capacidade de redefinir métodos e propriedades de uma classe em seus descendentes.

1.0 Estrutura de Units

Vamos examinar o código gerado para um novo Form, identificando as principais seções de uma Unit típica. Crie uma nova aplicação e observe na Unit principal as seguintes cláusulas.

Unit: A primeira declaração de uma unit é seu identificador, que é igual ao nome do arquivo.

Interface: Seção interface, onde ficam declarações que podem ser usadas por outras Units.

Uses: Na cláusula uses fica a Lista de Units usadas.

Type: Na cláusula type fica a definição de tipos, aqui temos a declaração da classe do Form.

Var: Na cláusula var são declaradas as variáveis, aqui temos a declaração da instância do Form.

Implementation: Na seção implementation ficam as definições dos métodos.

End: Toda Unit termina com um end a partir de onde qualquer texto é ignorado.

2.0 Variáveis

No Delphi, toda variável tem que ser declarada antes de ser utilizada. As declarações podem ser feitas após a palavra reservada var, onde são indicados o nome e o tipo da variável. Os nomes de variáveis não podem ter acentos, espaços ou caracteres especiais como &, $ ou % e o primeiro caractere de um nome de variável tem que ser uma letra ou um sublinhado. O Delphi ignora o caso das letras.

Variáveis Globais

As variáveis abaixo são globais, declaradas da Interface da Unit. Podem ser acessadas por qualquer Unit usuária.

var

I: Integer;

Usuario: string;

A, B, Soma: Double;

Ok: Boolean;

Variáveis Locais

As variáveis abaixo são locais ao método, ou seja elas só existem dentro do método, não podem ser acessadas de fora, mesmo que seja na mesma Unit. Na verdade essas variáveis são criadas quando o método é chamado e destruídas quando ele é encerrado, seu valor não é persistente.

procedure TFrmExemplo.BtnTrocarClick(Sender: TObject);

var

Aux: string;

begin

Aux := EdtA.Text;

EdtA.Text := EdtB.Text;

EdtB.Text := Aux;

end;

3.0 Atributos

Os atributos são variáveis de instância. Para declarar um atributo em uma classe basta definir o identificador e o tipo do atributo na declaração da classe, feita na seção type da Interface da Unit, como abaixo.

type

TFrmSomar = class(TForm)

private

{ Private declarations }

A, B: Double;

public

{ Public declarations }

Soma: Double;

end;

4.0 Encapsulamento

Os principais níveis de visibilidade dos atributos e métodos de uma classe são mostrados abaixo.

5.0 Classes

Classes são tipos de objetos, uma classe é declarada na cláusula type da seção interface e os métodos são definidos na seção implementation. Examine o código de um Form para identificar os elementos de sua classe.

interface

type

TFrmSomar = class(TForm)

EdtA: TEdit;

EdtB: TEdit;

BtnSoma: TButton;

procedure BtnSomaClick(Sender: TObject);

private

{ Private declarations }

public

{ Public declarations }

end;

implementation

procedure TFrmSoma.BtnSomaClick(Sender: TObject);

begin

ShowMessage(EdtA.Text + EditB.Text);

end;

6.0 Objetos

Um Objeto é tratado como uma variável cujo tipo é uma classe. A declaração de objetos é igual à declaração de uma variável simples, tendo no lugar do tipo a classe do objeto.

var

FrmSomar: TFrmSomar;

7.0 Literais

Valores literais são valores usados em atribuições e expressões. Cada tipo tem uma sintaxe diferente.

8.0 Constantes

São declaradas na seção const, podem ser usadas como variáveis, mas não podem ser alteradas. Geralmente o nome das constantes é escrito em letras maiúsculas e na declaração dessas constantes não é indicado o tipo.

const

G = 3.94851265E-19;

NUM_CHARS = '0123456789';

CR = #13;

SPACE = ' ';

MAX_VALUE = $FFFFFFFF;

Constantes Tipadas

Na verdade, constantes tipadas são variáveis inicializadas com valor persistente, que podem ser alteradas normalmente, como qualquer variável. A única diferença de sintaxe entre constantes tipadas e simples é que o tipo da constante é indicado explicitamente na declaração. Se uma constante tipada for declarada localmente, ela não será destruída quando o método for encerrado. Para diferenciar das constantes normais, costuma-se declarar estas com letras de caso variável, como abaixo.

const

Cont: Integer = 1;

Peso: Double = 50.5;

Empresa: string = 'SENAC';

9.0 Instruções

Os programas são compostos por instruções, que são linhas de código executável. Exemplos de instruções simples são atribuições, mensagens entre objetos, chamadas de procedimentos, funções e métodos, como mostradas abaixo. As instruções podem ser divididas em várias linhas, o que indica o fim de uma instrução é o ponto e vírgula no final. Quando uma instrução é quebrada, costuma-se dar dois espaços antes das próximas linhas, para melhorar a leitura do código.

Caption := 'Gabba Gabba Hey!';

Form2.ShowModal;

Application.MessageBox('Você executou uma operação ilegal, o programa será finalizado.',

'Falha geral', MB_ICONERROR);

Você pode usar várias instruções agrupadas em uma instrução composta, como se fosse uma só instrução. Uma instrução composta delimitada pelas palavras reservadas begin e end. Toda instrução, simples ou composta, é terminada com um ponto-e-vírgula.

if CheckBox1.Checked then

begin

ShowMessage('O CheckBox será desmarcado.');

CheckBox1.Checked := False;

end;

Estilo de Codificação

As instruções e todo o código de uma Unit devem ser distribuídos para facilitar o máximo a leitura. Para isso, podemos usar a indentação, geralmente de dois espaços para indicar os níveis de código. Procure criar um estilo próprio, que melhor se molde à sua realidade. Se for desenvolver em grupo, é melhor que todos usem o mesmo estilo para evitar confusões.

10.0 Comentários

Existem 3 estilos de comentário no Delphi, como mostrado abaixo.

(* Comentário do Pascal Padrão *)

{ Comentário do Turbo Pascal }

// Comentário de linha do C++

Cuidado com as diretivas de compilação, pois elas são delimitadas por chaves e podem ser confundidas com comentários. A diretiva de compilação mostrada abaixo é incluída em todas as Units de Forms.

{$R*.DFM}

11.0 Tipos de Dados Padrão

O Delphi trata vários tipos de dados padrão, segue uma descrição sucinta desses tipos.

Tipos Inteiros

São tipos numéricos exatos, sem casas decimais. O tipo Integer é o tipo inteiro padrão.

Tipos Reais

São tipos numéricos com casas decimais. O tipo Double é o tipo real padrão.

Tipos Texto

Os tipos texto podem operar com caracteres simples ou grupos de caracteres. O tipo texto padrão é o tipo string.

O operador + pode ser usado para concatenar strings e você pode usar uma variável do tipo string como uma lista de caracteres.

ShowMessage('5ª letra do título da janela: ' + Caption[5]);

Label1.Text := '2ª letra do Edit: ' + Edit1.Text[2];

Existem várias funções de manipulação de strings, veja algumas das mais importantes mostradas abaixo.

Por exemplo, para comparar o texto de dois Edits, poderíamos usar a função AnsiCompareText.

if AnsiCompareText(EdtA.Text, EdtB.Text) = 0 then

ShowMessage('O texto dos dois Edits são iguais.');

A função Format é especialmente útil na formatação de strings, veja alguns exemplos.

ShowMessage(Format('O número %d é a parte inteira do número %f.', [10, 10.5]));

ShowMessage(Format('Este texto%sfoi formatado%susando o caractere #%d.', [#13, #13, 13]));

ShowMessage(Format('O preço do livro %s é %m.', ['Como Programar em Delphi', 50.7]));

Um detalhe que deve ser observado é que as propriedades dos objetos não podem ser usadas como variáveis em funções. Veja a declaração do procedimento Delete no help.

procedure Delete(var S: string; Index, Count:Integer);

Digamos que você deseje apagar as 5 primeiras letras de um Edit, como a string do Delete é variável, não poderia usar o código abaixo.

Delete(Edit1.Text, 1, 5);

Para você poder fazer a operação desejada, teria que usar uma variável como variável auxiliar.

var

S: string;

begin

S := Edit1.Text;

Delete(S, 1, 5);

Edit1.Text := S;

end;

Tipos Ordinais

Tipos ordinais são tipos que tem uma seqüência incremental, ou seja, você sempre pode dizer qual o próximo valor ou qual o valor anterior a um determinado valor desses tipos. São tipos ordinais o Char, os tipos inteiros, o Boolean e os tipos enumerados. Algumas rotinas para ordinais são mostradas abaixo.

Por exemplo, use o código abaixo no evento OnKeyPress de um Edit e veja o resultado.

Inc(Key);

Boolean

Variáveis do tipo Boolean podem receber os valores lógicos True ou False, verdadeiro ou falso. Uma variável Boolean ocupa 1 byte de memória.

TDateTime

O tipo TDateTime guarda data e hora em uma estrutura interna igual ao tipo Double, onde a parte inteira é o número de dias desde 31/12/1899 e a parte decimal guarda a hora, minuto, segundo e milissegundo. As datas podem ser somadas ou subtraídas normalmente.

Existem várias rotinas de manipulação de datas e horas, usadas com o tipo TDateTime, veja algumas abaixo.

No help de cada uma das funções acima você vai encontrar alguns exemplos, veja os colocados abaixo.

if DayOfWeek(Date) = 1 then

ShowMessage('Hoje é Domingo, pé de cachimbo!')

else

ShowMessage('Hoje não é Domingo, pé de cachimbo!');

var

A, M, D: Word;

begin

DecodeDate(Date, A, M, D);

ShowMessage(Format('Dia %.2d do mês %.2d de %d.', [D, M, A]));

end;

Variant

Tipo genérico, que pode atribuir e receber valores de qualquer outro tipo. Evite usar variáveis do tipo Variant, pois o uso dessas variáveis podem prejudicar a performance do programa, além de diminuir a legibilidade do código fonte e a integridade do executável, veja o trecho de código abaixo e note como esse tipo de variável tem um comportamento estranho.

var

V1, V2, V3: Variant;

begin

V1 := True;

V2 := 1234.5678;

V3 := Date;

ShowMessage(V1 + V2 + V3);

end;

12.0 Conversões de Tipo

Freqüentemente você vai precisar converter um tipo de dado em outro, como um número em uma string. Para essas conversões você pode usar duas técnicas, o TypeCasting e as rotinas de conversão de tipos.

TypeCasting

TypeCast é uma conversão direta de tipo, usando o identificador do tipo destino como se fosse uma função. Como o Delphi não faz nenhuma verificação se a conversão é válida, você deve tomar um certo cuidado ao usar um TypeCast para não criar programas instáveis.

var

I: Integer;

C: Char;

B: Boolean;

begin

I := Integer('A');

C := Char(48);

B := Boolean(0);

Application.MessageBox(PChar('Linguagem de Programação' + #13 + 'Delphi 3'), 'SENAC',

MB_ICONEXCLAMATION);

end;

Rotinas de Conversão

As principais rotinas de conversão estão listadas na tabela abaixo. Caso você tente usar uma dessas rotinas em uma conversão inválida, pode ser gerada uma exceção.

Veja alguns exemplos de como usar essas rotinas. Conversão de dados é uma operação muito comum na programação em Object Pascal, seeria interessante dar uma olhada no help de cada uma das funções acima.

var

I: Integer;

D: Double;

S1, S2: string;

begin

D := 10.5;

I := Trunc(D);

S1 := FloatToStr(D);

S2 := IntToStr(I);

ShowMessage(S1 + #13 + S2);

end;

var

A, B, Soma: Bouble;

begin

A := StrToFloat(EdtA.Text);

B := StrToFloat(EdtB.Text);

Soma := A + B;

ShowMessage(Format('%f + %f = %f', [A, B, Soma]);

end;

13.0 Expressões

Uma expressão é qualquer combinação de operadores, variáveis, constantes, valores literais e chamadas de funções que resultem em um valor de determinado tipo. Uma expressão é usada sempre que precisamos de uma valor que possa ser obtido por uma expressão.

A + 12 * C

Date - 4

StrToInt(Edit1.Text + Edit2.Text)

StrToDate(Edit2.Text) - StrToDate(Edit1.Text)

12 * A / 100

A < B

14.0 Operadores

Os operadores são usados em expressões e a ordem em que as expressões são executadas depende da precedência desses operadores. Veja abaixo a lista de operadores em ordem descendente de precedência.

Voltar

• Menu Principal
• Sobre nós
• Contacte-nos
• Comentários
• Notícias
• Galeria de Fotos
• Livro de Visitas
• Blog
• Nossa Equipe
• Calendário de Eventos
• Portfolio

Contacto

Walmirofj

walmirofj@gmail.com

Procurar no site

Procurar:

---

© 2011 Todos os direitos reservados à Walmiro Fabiano Júnior.

Crie o seu site grátisWebnode

 

Gostou deste website?
Crie o seu próprio site gratuito em 5 minutos!

Experimente!

Operador	Descrição
Operadores Unários
@	Endereço
not	Não booleano ou bit voltado para não
Operadores Multiplicativos e de direção de Bit
*	Multiplicação ou interseção de conjuntos
/	Divisão de Real
div