Delphi1 Prof. Evandro César Freiberger

Prévia do material em texto

Linguagem Comercial – Parte01 
 
Indice 
 
AMBIENTE INTEGRADO DE DESENVOLVIMENTO DO DELPHI ( IDE ) .......................................................3 
ELEMENTOS DO AMBIENTE .............................................................................................................................................3 
BARRA DE BOTÕES DE ATALHO ......................................................................................................................................5 
INSPETOR DE OBJETOS ....................................................................................................................................................6 
PERSONALIZANDO A BARRA DE BOTÕES DE ATALHO .....................................................................................................6 
MANIPULANDO UM PROJETO EM DELPHI.........................................................................................................8 
ARQUIVOS DE UM PROJETO DELPHI ................................................................................................................................8 
ARQUIVOS CRIADOS PELO COMPILADOR E LINKEDITOR .................................................................................................8 
CRIANDO UM NOVO PROJETO ..........................................................................................................................................8 
SALVANDO UM PROJETO NOVO EM DELPHI .....................................................................................................................8 
SALVANDO UM PROJETO COM OUTRO NOME .................................................................................................................10 
SALVANDO UM ARQUIVO ( UNIT, FORM) COM OUTRO NOME........................................................................................10 
SALVANDO UM PROJETO EM UM DISQUETE PARA TRANSPORTE....................................................................................10 
ESTRUTURA DE UMA UNIT.....................................................................................................................................11 
CABEÇALHO DE UMA UNIT ...........................................................................................................................................11 
CLÁUSULA INTERFACE..................................................................................................................................................11 
CLÁUSULA IMPLEMENTATION.......................................................................................................................................12 
CLÁUSULA INITIALIZATION...........................................................................................................................................13 
CLÁUSULA FINALIZATION.............................................................................................................................................13 
EXEMPLO DE UMA UNIT ................................................................................................................................................13 
OBJECT PASCAL.........................................................................................................................................................15 
PALAVRAS RESERVADAS ..............................................................................................................................................15 
EXPRESSÕES .................................................................................................................................................................15 
IDENTIFICADORES .........................................................................................................................................................16 
CONSTANTES ................................................................................................................................................................16 
VARIÁVEIS....................................................................................................................................................................16 
TIPOS DE DADOS DO OBJECT PASCAL............................................................................................................................17 
Tipos de Dados Numéricos Inteiros.........................................................................................................................17 
Tipos de Dados Numéricos Reais ............................................................................................................................17 
Tipos de Dados Lógicos...........................................................................................................................................17 
Tipos de Dados Caracter .........................................................................................................................................17 
Tipos Ordinais .........................................................................................................................................................18 
Tipo Variant .............................................................................................................................................................18 
Tipo Enumerado.......................................................................................................................................................18 
Tipo SubArange .......................................................................................................................................................19 
Tipo Conjuntos.........................................................................................................................................................20 
OPERADORES ................................................................................................................................................................20 
Operador de Atribuição...........................................................................................................................................20 
Operadores Aritméticos ...........................................................................................................................................21 
Operadores Lógicos.................................................................................................................................................21 
Operadores de Conjunto..........................................................................................................................................21 
Operadores de Classe ..............................................................................................................................................21 
TIPOS DE DADOS HOMEGÊNEOS ....................................................................................................................................21 
Array Unidimensional..............................................................................................................................................21 
Array Multidimensional ...........................................................................................................................................22 
TIPOS DE DADOS HETEROGÊNEOS .................................................................................................................................22 
Curso de Programação em Delphi – Componentes Básicos do Delphi 
 Prof. Evandro César Freiberger Página 2 
Record ......................................................................................................................................................................22 
ESTRUTURAS DE CONTROLE EM OBJECT PASCAL .........................................................................................................24Comentários.............................................................................................................................................................24 
Bloco De Comandos “Begin... End” .......................................................................................................................24 
Estrutura Condicional Simples “If-Then”...............................................................................................................24 
Estrutura Condicional Composta “If-Then-Else” ..................................................................................................25 
Estrutura Condicional “Case-Of”...........................................................................................................................25 
Estrutura de Repetição “For-To, For-Downto”......................................................................................................26 
Estrutura de Repetição “While-Do”........................................................................................................................26 
Estrutura “Repeat-Untill” .......................................................................................................................................27 
SUBPROGRAMAS...........................................................................................................................................................27 
Funções ....................................................................................................................................................................27 
Procedimentos..........................................................................................................................................................27 
Passagem De Parâmetros........................................................................................................................................28 
PROGRAMAÇÃO ORIENTADA A OBJETOS COM DELPHI .............................................................................29 
O QUE É POO?..............................................................................................................................................................29 
CLASSES .......................................................................................................................................................................29 
Exemplo de definição de classe ...............................................................................................................................29 
ENCAPSULAMENTO .......................................................................................................................................................32 
Tipos de Encapsulamento ........................................................................................................................................32 
Atributo de Visibilidade Private...............................................................................................................................33 
Atributo de Visibilidade Protected...........................................................................................................................33 
Atributo de Visibilidade Public................................................................................................................................33 
Atributo de Visibilidade Published ..........................................................................................................................33 
HERANÇA .....................................................................................................................................................................34 
 
Curso de Programação em Delphi – Componentes Básicos do Delphi 
 Prof. Evandro César Freiberger Página 3 
Ambiente Integrado de Desenvolvimento do Delphi ( IDE ) 
 
Elementos do Ambiente 
 
Menu principal / Barra de Botões de Atalho / Barra de Componentes 
 
 
 
Formulário ( Construção da Interface ) Imagem Gráfica 
 
 
 
Codificação da imagem gráfica ( arquivo DFM ) – acesso 
através do botão direito do mouse sobre o formulário, opção 
View as Text. Para voltar, botão direito no texto, opção View 
as Form. 
 
 Inspetor de Objetos (Configuração 
de propriedades e eventos dos 
componentes do formulário) 
 
 
 
Configuração de propriedades em 
tempo de projeto. 
Curso de Programação em Delphi – Componentes Básicos do Delphi 
 Prof. Evandro César Freiberger Página 4 
 
 
 
Arquivo que contém o código fonte associado ao formulário – declara uma nova classe herdando as características 
da classe Tform. Irá conter todos os procedimentos manipuladores dos eventos associados aos componentes do 
formulário em questão. Para acessa-lo, selecione o formulário e pressione F12, para retornar, novamente F12. 
 
Curso de Programação em Delphi – Componentes Básicos do Delphi 
 Prof. Evandro César Freiberger Página 5 
Tempo de Projeto 
 
 
Tempo de Execução 
 
 
 
 
Barra de Botões de Atalho 
 
 
 
Primeira linha de botões da esquerda para a direita 
 
− New – novo objeto ( unit, formulário, etc) 
− Abrir arquivos ( *.pas, *.dpr, *.dpk,) 
− Salvar arquivo selecionado 
− Salvar todos os arquivos do projeto 
− Abrir projeto ( *.dpr, *.bpg ) 
− Adicionar um arquivo já existente ao projeto 
− Remover um arquivo do projeto 
− Ajuda do Delphi 
 Segunda Linha 
 
− Lista de Unit que pertencem ao 
projeto em questão 
− Lista de formulários que 
pertencem ao formulário 
− Alternar entre formulário e Unit 
− Novo formulário 
− Executar aplicação 
− Executar passo a passo, 
entrando em sub-rotinas 
− Executar passo a passo, não 
entrando em sub-rotinas 
 
 
 
 
 
Curso de Programação em Delphi – Componentes Básicos do Delphi 
 Prof. Evandro César Freiberger Página 6 
Inspetor de Objetos 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Personalizando a Barra de Botões de Atalho 
 
Para personalizar a barra de botões dê um clique com o botão direito do mouse sobre a barra de botões e 
escolha a opção Custumize, será apresentada a tela abaixo que possui três guias, conforme figura. 
 
 
 
Nessa guia você poderá escolher quais barras de botões serão 
exibidas, assinalando os check’s 
 
 
 
Nessa guia você poderá escolher quais botões irão 
fazer parte da barra de botões. Para adicionar, 
selecione a categoria e em seguida escolha o botão e 
arraste-o até o local desejado na barra de botões. Para 
remover um botão existente na barra, arraste-o no 
sentido da barra para a tela de configuração. 
 
Na última guia, Options você poderá optar por exibir a legenda dos botões quando você passa com o mouse sobre os 
botões e também se deseja exibir as teclas de atalhos que existem para tais botões. 
Página de 
Propriedades 
Página de 
 Eventos 
Propriedades Valores 
 
Eventos 
Seletor de Objetos 
Curso de Programação em Delphi – Componentes Básicos do Delphi 
 Prof. Evandro César Freiberger Página 7 
Project Manager 
 
 
 
 
Acesse através do menu View / Project Manager, nele 
você poderá incluir, remover elementos do projeto ( 
unit’s, form’s ) e selecionar o projeto que deseja 
trabalhar, caso esteja trabalhando com mais deum 
projeto ao mesmo tempo. 
 
 
Browser 
 
 
 
 
Acesse através do menu View / 
Browser, porém só terá acesso 
depois de ter compilado pelo 
menos uma vez o projeto. 
Nessa tela podemos visualizar a 
hierarquia de objetos do projeto 
em questão. 
 
Arquivo DPR 
 
 
 
Nesse arquivo são referenciados as 
unidades e formulários pertencentes ao 
projeto em questão. 
 
Para as unidades que não possuem 
formulário associado somente será 
exibido o nome da unidade e o arquivo 
que foi armazenada. 
 
 
 
Curso de Programação em Delphi – Componentes Básicos do Delphi 
 Prof. Evandro César Freiberger Página 8 
 
Manipulando um Projeto em Delphi 
 
Arquivos de um Projeto Delphi 
 
Arquivo de Projeto ( .DPR ) - é usado para manter informações sobre formulários e unidades que compõem o 
projeto. Possui também código de inicialização do projeto. 
 
Arquivo de Unidade ( .PAS ) - é o código fonte do projeto. As unidades podem estar associadas a formulários 
ou apenas armazenar funções e procedimentos usados na aplicação. 
 
Arquivo de Formulário ( .DFM ) - é um arquivo binário criado pelo Delphi para armazenar informações 
sobre cada formulário. Cada arquivo de formulário possui um arquivo de unidade correspondente. 
 
Arquivo de Opções de Projeto ( .DOF e .CFG ) - armazenam ajustes de opções de um projeto (configurações 
de compilação e linkedição ). 
 
Arquivos de Recursos ( .RES ) - são arquivos binários que contém ícones, imagens e tabelas de strings da 
aplicação. Normalmente o arquivo de Recurso do Projeto, contém apenas o ícone da aplicação. Não é 
aconselhável alterar esse arquivo, pois o Delphi altera constantemente durante o projeto. 
 
Arquivos de Backup ( .~DP, .~DF, .~PA ) são arquivos de Backup dos arquivos de projeto, formulário e 
unidades respectivamente. 
 
Arquivos Criados pelo Compilador e Linkeditor 
 
Arquivos de Objetos de Unidade ( .DCU ) - é a versão Compilada do Arquivo ( .PAS ). 
 
Arquivos de Biblioteca de Ligação Dinâmica ( .DLL ) - contém código executável, mas precisa ser chamado 
por um arquivo executável ( .EXE ). 
 
Arquivos Executáveis - é a aplicação propriamente dita. É um arquivo independente e que será instalado no 
local de uso da aplicação. Caso o arquivo executável fizer uso de DLLs ou OCXs será necessário levar esses 
arquivos junto com o executável. 
 
Criando um novo projeto 
 
Quando iniciamos o Delphi, um novo projeto é sugerido, dessa forma podemos a partir desse iniciarmos 
a construção do novo projeto. Outra forma é acessar o menu File / New Aplication. 
 
Salvando um projeto novo em Delphi 
 
Como já vimos, um projeto desenvolvido em Delphi possui vários arquivos, para salvarmos pela 
primeira vez um projeto em Delphi devemos acessar a opção Save All, através do menu File ou através do botão 
, em seguida será apresentada a seguinte tela: 
 
Curso de Programação em Delphi – Componentes Básicos do Delphi 
 Prof. Evandro César Freiberger Página 9 
 
 
1. Crie uma pasta para armazenar o novo projeto. Evite criar pastas para projetos dentro das pastas 
de instalação do Delphi. 
2. Selecione a nova pasta criada, através da caixa Salvar em: 
3. Configure o nome do arquivo que irá conter a Unit. É bom ter um padrão de nomes para a unit, 
exemplo: UcadastroProduto, Unit_Relatório_Clientes, etc. 
4. Clique no botão Salvar, e será apresenta a tela a seguir: 
 
 
 
 
1. Nessa tela iremos salvar o arquivo de projeto (.dpr), é conveniente manter a mesma pasta onde 
foi salva a unit ( tela anterior ). 
2. Configure o nome do projeto, na caixa Nome do arquivo. Da mesma forma é conveniente manter 
um padrão de nomenclatura para os arquivos de projeto, ex: ProjetoControleEstoque, 
PcontroleFinanceiro, etc. 
3. Por fim pressione o botão Salvar. Com isso o novo projeto foi salvo. 
 
 
 
Curso de Programação em Delphi – Componentes Básicos do Delphi 
 Prof. Evandro César Freiberger Página 10 
Obs: É recomendado que o projeto seja salvo antes mesmo que o desenvolvimento 
propriamente dito seja iniciado, e que a cada novo arquivo que for inserido no projeto, este seja 
salvo novamente. 
 
 
Salvando um Projeto com outro nome 
 
Acesse o menu File e opção Save Project As..., em seguida informe um nome diferente para o projeto, 
veja que você poderá mudar também a localização do arquivo de projeto, escolhendo uma nova localização na 
caixa Salvar Em. 
 
Obs: esse procedimento somente salvará os arquivos ( DPR, RES, CFG, DOF) com nome e/ou 
localização diferente, os formulário e unit’s continuarão iguais. 
 
Salvando um Arquivo ( Unit, Form) com outro nome 
 
Selecione o arquivo desejado e em seguida acesse a opção de menu File/ Salve As... e informe o novo 
nome e ou a nova localização do arquivo em questão. 
 
Salvando um Projeto em um Disquete para Transporte 
 
Pelo fato de existirem vários arquivos que compõem um projeto, não vale a pena usar a opção Save 
As..., visto que esse procedimento deverá ser repetido para o arquivo de projeto e todos os formulário e unidades 
que compõem o projeto. Com isso o caminho menos trabalhoso e seguro é copiar a pasta onde o projeto foi 
salvo, usando o Windows Explorer. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Curso de Programação em Delphi – Componentes Básicos do Delphi 
 Prof. Evandro César Freiberger Página 11 
Estrutura de uma Unit 
 
Units são os arquivos que o Delphi usa para implementar as classes de objetos, procedimentos e 
funções. Uma Unit pode ou não estar associada a um formulário, sendo que um formulário sempre terá uma Unit 
associada. 
 
Estrutura: 
 
Unit <nome da unit>; 
Interface 
 Uses <lista de unidades referenciadas> 
 Const <lista de constantes declaradas> 
 Type <lista de tipos definidos pelo programador> 
 Var <lista de variáveis declaradas> 
 Procedure 
 Function 
Implementation 
 Uses <lista de unidades referenciadas> 
 Const <lista de constantes declaradas> 
 Type <lista de tipos definidos pelo programador> 
 Var <lista de variáveis declaradas> 
 Procedure 
 Function 
Initialization 
 <Comandos> 
Finalization 
 <Comandos> 
End. 
 
Cabeçalho de uma Unit 
 
Define o nome da Unit, sendo que este deverá ser único. O nome de uma Unit poderá ter qualquer 
tamanho, porém o Delphi considera apenas os 63 caracteres. Não é necessário que o nome da Unit seja igual ao 
nome do arquivo (PAS) que a contém, mas é uma boa técnica usar esses nomes iguais, facilitando o uso dessas 
Units. 
 
Exemplo: 
 
unit unit_ola; 
Cláusula Interface 
 
Nesta área serão especificadas todas as Units necessárias para a Unit em questão e também tudo que 
poderá ser usado por outras Units, ou seja, todas as constantes, tipos, variáveis, procedimentos e funções 
definidas nesta área serão visíveis por unidades que usarem esta Unit. 
 
Exemplo: 
 
 
 
 
interface 
Curso de Programação em Delphi – Componentes Básicos do Delphi 
 Prof. Evandro César Freiberger Página 12 
uses 
 SysUtils, WinTypes, WinProcs, Messages, Classes, Graphics, Controls, 
 Forms, Dialogs, StdCtrls; 
type 
 TForm_ola = class(TForm) 
 BotaoOla: TButton; 
 procedure BotaoOlaClick(Sender: TObject); 
 procedure FormClick(Sender: TObject);procedure FormResize(Sender: TObject); 
 private 
 { Private declarations } 
 public 
 { Public declarations } 
 end; 
 
var 
 Form_ola: TForm_ola; 
 
Cláusula Implementation 
 
Esta área da Unit é composta pelo código que implementa as ações da Unit ( funções e procedimentos ). 
A área de implementação pode conter uma cláusula Uses. É sempre melhor usar esta técnica para as Units que 
você desenvolver, sendo que dessa forma somente o código da parte de implementação que visualizara as Units 
incluídas na cláusula Uses. 
 
Exemplo: 
 
implementation 
 
{$R *.DFM} 
 
procedure TForm_ola.BotaoOlaClick(Sender: TObject); 
begin 
 ShowMessage ('Olá, pessoal'); 
 BotaoOla.Caption := 'Diga Olá Novamente'; 
end; 
 
procedure TForm_ola.FormClick(Sender: TObject); 
begin 
 ShowMessageDlg ('Você deu um clique fora do botão’); 
end; 
 
Curso de Programação em Delphi – Componentes Básicos do Delphi 
 Prof. Evandro César Freiberger Página 13 
Cláusula Initialization 
 
Serve para inicializar quaisquer variáveis ou estrutura de dados, sendo que a inicialização será feita 
apenas um única vez: quando a Unit for acessada pela primeira vez. 
 
Exemplo: 
 
Initialization 
 DataAtual := date; 
 HoraAtual := time; 
end; 
Cláusula Finalization 
 
Será a última tarefa executada antes de encerrar uma Unit. Sua aplicação normalmente será emprega 
nos casos de devem ser liberados recursos antes alocados. 
 
Exemplo: 
 
Finalization 
 MeuObejto.Free; 
end; 
 
Exemplo de uma Unit 
 
unit unit_ola; 
interface 
uses 
SysUtils, WinTypes, WinProcs, Messages, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls; 
type 
 TForm_ola = class(TForm) 
 BotaoOla: TButton; 
 procedure BotaoOlaClick(Sender: TObject); 
 procedure FormClick(Sender: TObject); 
 procedure FormResize(Sender: TObject); 
 private 
 { Private declarations } 
 public 
 { Public declarations } 
 end; 
 
var 
 Form_ola: TForm_ola; 
 
Curso de Programação em Delphi – Componentes Básicos do Delphi 
 Prof. Evandro César Freiberger Página 14 
implementation 
 
{$R *.DFM} 
 
procedure TForm_ola.BotaoOlaClick(Sender: TObject); 
begin 
 MessageDlg ('Olá, pessoal', mtInformation, [mbOK], 0); 
 BotaoOla.Caption := 'Diga Olá Novamente'; 
end; 
 
 
 
procedure TForm_ola.FormClick(Sender: TObject); 
begin 
 MessageDlg ('Você deu um clique fora do botão', 
 mtWarning, [mbOK], 0); 
end; 
end. 
 
Curso de Programação em Delphi – Componentes Básicos do Delphi 
 Prof. Evandro César Freiberger Página 15 
Object Pascal 
 
É uma linguagem Orientada a Objetos híbrida por possuir características de programação não só visual 
mas também escrita. Ela força a você executar passos lógicos o que 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 quase todos os conceitos da orientação a objetos incluindo encapsulamento, 
herança e polimorfismo. É capaz de suportar desde as facilidades do desenvolvimento visual até o 
desenvolvimento em um baixo nível de programação (acesso as APIs do Windows e programação com código 
Assembly). 
Como se pode perceber a base de toda a programação Delphi é a linguagem Object Pascal, então neste 
capítulo trataremos de alguns aspectos deste tipo de programação. 
 
 
Palavras Reservadas 
 
Palavras-chave ou palavras reservadas são aquelas usadas pela sintaxe da linguagem com significado 
específico e, portanto, não podem ser usadas com outra finalidade. O Object Pascal se utiliza das seguintes 
palavras reservadas: 
 
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 
 
Expressões 
As expressões em Object Pascal (como em qualquer linguagem) são formadas por operadores e 
operandos; os operadores são divididos em quatro categorias básicas: 
 
Unários @, Not 
Multiplicativos >, /, div, mod, and, shl, shr, as 
Adicionais +, -, or, xor 
Relacionais =, < >, <, >, < =, > =, in, is 
 
As expressões obedecem as regras básicas de lógica para a precedência da execução das operações. 
Curso de Programação em Delphi – Componentes Básicos do Delphi 
 Prof. Evandro César Freiberger Página 16 
Identificadores 
 
Identificadores são usados para definir nomes de constantes, tipos, variáveis, procedimentos, funções, 
unidades, programas e campos de registros. Algumas regras devem ser observadas para a utilização de 
identificados em Object Pascal: 
• 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 pelo carácter underscore ( _ ). O resto é 
formado por Letras, Dígitos, carácter underscore. 
• Não é permitido a utilização de espaços para a formação do nome. 
• O Object Pascal não faz distinção entre letras maiúsculas e minúsculas nos nomes de identificadores. 
 
Constantes 
 
Uma constante é um identificador com valor fixo. Um bloco de declarações constante possui a seguinte 
expressão: 
 
const <Identificador> = <valor>; 
 
Exemplos: 
 
const 
Min = 0; 
Max = 100; 
MensOla = 'Instrução inválida'; 
 
Variáveis 
 
Para que o Delphi possa usar nossas variáveis, devemos primeiro declará-las, isto é, informar o nome e 
o tipo desejado. Um bloco de declarações de variáveis possui a seguinte expressão: 
 
var <lista de Identificadores> : <tipo>; 
 
Exemplo: 
 
Idade, X : integer; 
Salário : Real; 
 
Note que a declaração do tipo de uma variável, em princípio não lhe atribui valores. Um erro comum em 
programação é tentarmos ler valores de variáveis não inicializadas, ou às quais ainda não se atribuiu valor. 
A seguir é apresentada uma lista dos tipos de variáveis mais comuns do Object Pascal com suas faixas 
de valores e o espaço ocupado em memória: 
 
 
Curso de Programação em Delphi – Componentes Básicos do Delphi 
 Prof. Evandro César Freiberger Página 17 
Tipos de dados do Object Pascal 
Tipos de Dados Numéricos Inteiros 
 
Tipo Faixa de Valores Nº Bytes 
Integer -2.147.483.648 a 2.147.483.647 4 
Cardial 0 a 4.294.967.295 4 
ShortInt -128 a 127 1 
SmallInt -32.768 a 32.767 2 
LongInt -2.147.483.648 a 2.147.483.647 4 
Int64 -263 a 263 -1 8 
Byte 0 a 255 1 
Word 0 a 65.535 2 
LongWord 0 a 4.294.967.295 4 
 
Tipos de Dados Numéricos Reais 
 
Tipo Faixa de Valores Dígitos Significativos Nº Bytes 
Real48 2.9 x 10–39 .. 1.7 x 1038 11–12 6 
Single 1.5 x 10–45 .. 3.4 x 1038 7–8 4 
Double 5.0 x 10–324 .. 1.7 x 10308 15–16 8 
Extended 3.6 x 10–4951 .. 1.1 x 10493219–20 10 
Comp –263+1 .. 263 –1 19–20 8 
Currency –922337203685477.5808.. 
922337203685477.5807 
19–20 8 
 
Tipos de Dados Lógicos 
 
Tipo Faixa de Valores Nº Bytes 
Boolean True ou False ( 1 ou 0 ) 1 
ByteBool True ou False ( 1 ou 0 ) 1 
WordBool True ou False ( 1 ou 0 ) 2 
LongBool True ou False ( 1 ou 0 ) 4 
 
Obs: o tipo padrão para representar valores lógicos é o tipo Boolean, ou outros são basicamente para 
atender compatibilidades com outras linguagens e o ambiente Windows. 
Tipos de Dados Caracter 
 
Tipo Faixa de Valores Nº Bytes 
Char 1 caracter ASCII 1 
AnsiChar 1 caracter ASCII 1 
WideChar 1 caracter Unicode 1 
ShortString 255 characters 2 a 256 
AnsiString ~231 characters 4 a 2GB 
WideString ~230 characters - Unicode 4 a 2GB 
 
Curso de Programação em Delphi – Componentes Básicos do Delphi 
 Prof. Evandro César Freiberger Página 18 
 Obs: quando usamos o tipo String estamos usando um tipo AnsiString, porém se inserirmos 
uma diretiva de compilação {$H-} estaremos usando o tipo ShortString. 
Tipos Ordinais 
Tipos ordinais são os tipos integer, Caracter, Boolean, enumeração, sub-intervalos, ou seja, são tipos de 
dados ao qual se conheça o seu valor absoluto, o seu predecessor e o seu sucessor. Existem uma série de 
operadores capazes de manipularem esses tipos de dados: 
 
 
Função Retorno 
Ord Valor da ordem do argumento 
Pred Valor predecessor do argumento 
Succ Valor sucessor do argumento 
High Maximo valor possível para a variável do tipo em questão 
Low Mínimo valor possível para a variável do tipo em questão 
 
Tipo Variant 
Esse tipo de dado pode conter qualquer tipo de informação, na realidade o tipo de dado que uma 
variável variant é definido em tempo de execução, quando atribuímos um valor para ela. Esse tipo de dado é 
bastante usado quando lidamos com OLE – Object Linking and Embbeding, que é usado como padrão de 
transferência de dados entre aplicações no Windows, já que não sabemos se receberemos um texto, uma imagem, 
um objeto multimídia, etc. 
 
Tipo Enumerado 
Esse tipo de dado pode ser usado para representar uma lista de possíveis valores que uma variável pode 
conter. Podemos usar o tipo enumerado para representar por exemplo: tipo de profissão (assalariado, autônomo, 
empresário), tipo de chamada telefônica (Local, DDD, DDI), consulta médica ( convênio, particular), operações 
aritméticas ( adição, subtração, divisão, multiplicação). O que vemos é que o tipo enumerado é na verdade uma 
forma de nomear uma seqüência de valores, visto que, internamente o Object Pascal representa a enumeração 
com números começando do zero, para o primeiro elemento, um para o segundo e assim sucessivamente. 
 
Exemplo: 
 
Type 
 TAlinhamento = (Direita, Esquerda, Centralizado, Justificado); 
Var 
 Alinhamento : TAlinhamento; 
 
No ambiente Delphi é muito comum o uso de enumerações, vamos ver alguns exemplos: 
 
 
 
 
 
 
 
 
 
 
 
Propriedade Align do componente Label e propriedade BorderStyle do fomulário. 
Curso de Programação em Delphi – Componentes Básicos do Delphi 
 Prof. Evandro César Freiberger Página 19 
 
 
 
 
 O Delphi define essas propriedades com os seguintes tipos de dados: 
 
 type 
 
 TAlign = (alNone, alTop, alBottom, alLeft, alRight, alClient); 
 
 TFormBorderStyle = (bsNone, bsSingle, bsSizeable, bsDialog, bsToolWindow, bsSizeToolWin); 
 
 
Tipo SubArange 
 
Da mesma forma que os tipos enumerados, os tipos SubArange são definidos pelo programador, sendo 
que este determina para o novo tipo um intervalo de valores tomando como base um tipo ordinal. 
 
Exemplo: 
 
Type 
 
TContador = 0..100; //um subintervalo do tipo ordinal Integer 
 
Tdigitos = ‘0’..’9’; //um subintervalo de caracteres do tipo char 
 
Var 
 
 Contador : Tcontador; 
 Dígitos : Tdigitos; 
 
Podemos definir SubArange de tipos enumerados, veja exemplo: 
 
Type 
 
 TDiaSemana = (Domingo, Segunda, Terça, Quarta, Quinta, Sexta, Sábado); 
 TDiaUteis = Segunda ..Sexta; 
 
Curso de Programação em Delphi – Componentes Básicos do Delphi 
 Prof. Evandro César Freiberger Página 20 
Tipo Conjuntos 
Através desse tipo de dados, suportado pelo Object Pascal, podemos manipular variáveis usando os 
conceitos de conjuntos da matemática. 
 
Exemplo: 
 
Type 
 
 TDiaSemana = (Domingo, Segunda, Terça, Quarta, Quinta, Sexta, Sábado); 
 TSemana = set of TDiaSemana; 
 
Var 
 
 Semana : TSemana; 
 
Com esse tipo, conforme já foi dito acima, podemos trabalhar com as operações matemáticas de 
conjuntos. Vejamos alguns exemplos: 
 
Semana := [ ] // conjunto vazio 
 
Semana := [Terça,Quinta]; //atribuição de dois elementos ao conjunto; 
 
Semana := Semana + [Quinta,Sexta]; // união de dois conjuntos 
 
Semana := Semana – [Terça]; //Diferença entre dois conjuntos 
 
Semana := Semana * [Quanta,Quinta]; //interseção de dois conjuntos 
 
If [Segunda] in Semana then // operação de pertinência de elementos 
 
If [Segunda, Terça] <= Semana then // está contido em semana 
 
If Semana >= [Quinta, Sexta] then // semana contém os dias quinta e sexta 
 
Operadores 
Operador de Atribuição 
Atribuição de valor literal 
 
A := 10; 
NomeFunc := ‘Fulano de Tal’; 
 
Atribuição de expressões 
 
Total := A * (B + 2); 
NomeFunc := Nome + ‘de Tal’; 
 
Atribuição de retorno de função 
 
Total := Soma( A,B); 
Totao := Soma(A,B) – Soma(C,D); 
Curso de Programação em Delphi – Componentes Básicos do Delphi 
 Prof. Evandro César Freiberger Página 21 
Operadores Aritméticos 
 
+ Adição 
- Subtração 
* Multiplicação 
/ Divisão – conjunto de reias 
Div Divisão inteira 
Mod Resto da divisão inteira 
 
Operadores Lógicos 
 
And Operador lógico E 
Or Operador lógico OU 
Not Operador lógico de negação 
Xor Operador lógico Ou exclusivo 
Operadores de Conjunto 
 
+ União 
- Diferença 
* Intersecção 
In Pertence 
<= Está contido em 
>= Contém 
 
 
Operadores de Classe 
 
Is Questionamento se um objeto é de uma determinada classe 
As Afirmação que um objeto é de uma determinada classe 
 
Tipos de dados Homegêneos 
Array Unidimensional 
 
Arrays são conjuntos de variáveis com o mesmo nome e diferenciadas entre si por um índice. Eles são 
úteis para manipularmos grandes quantidades de dados de um mesmo tipo, pois evitam a declaração de diversas 
variáveis. 
 
Sintaxe: 
 
<NomeVariável> : array[i1..i2] of <tipo>; 
 
onde i1 e i2 representam os valores mínimo e máximo, respectivamente, do índice. 
 
Curso de Programação em Delphi – Componentes Básicos do Delphi 
 Prof. Evandro César Freiberger Página 22 
O Object Pascal permite que i1 e i2 possuam qualquer valor desde que i1 seja menor ou igual a i2. 
Assim, poderíamos declarar um array de 100 variáveis inteira de várias formas diferentes : 
 
lista : array [1..100] of integer; 
ou 
lista : array [-100..-1] of integer; 
ou 
lista : array [0..99] of integer 
 
Array Multidimensional 
Arrays multidimensionais são conjuntos de variáveis com o mesmo nome e diferenciadas entre si por 
dois ou mais índices. Eles são úteis para manipularmos grandes quantidades de dados de um mesmo tipo, pois 
evitam a declaraçãode diversas variáveis. 
 
Sintaxe: 
 
<NomeVariável> : array[i11..i12, i21..i22, in1..in2 ] of <tipo>; 
 
onde i1 e i2 ... in1..in2 representam os valores mínimo e máximo para cada dimensão do array 
respectivamente. 
 
Tipos de dados Heterogêneos 
Record 
 
O Object Pascal permite que o usuário crie novos tipos de dados baseados em tipos pré-existentes. A 
declaração de novos tipos deve ser feita na cláusula type da unidade de código correspondente. 
O exemplo a seguir destaca a criação de um tipo estruturado, um registro (record) capaz de armazenar 
os dados de um funcionário. 
 
type 
 TFuncionario = record 
 Nome : string; 
 Sexo : char; 
 Salario : real; 
 DataNascimento : TdataTime; 
 end; 
 
 
Agora já podemos declarar variáveis do tipo Tfuncionario 
 
var 
Funcionario : TFuncionario; 
 
O acesso aos campos que compõe a variável Funcionario pode ser feito da seguinte forma: 
 
Funcionario.Nome := ‘Fulano de Tal’; 
Funcionario.Sexo := ‘M’; 
Funcionario.Salario := 542.45; 
Funcionario.DataNascimento := StrToDate(‘28/11/1972’); 
 
Curso de Programação em Delphi – Componentes Básicos do Delphi 
 Prof. Evandro César Freiberger Página 23 
Ou ainda usando o operador With, teremos 
 
With Funcionário do 
Begin 
Nome := ‘Fulano de Tal’; 
Sexo := ‘M’; 
Salario := 542.45; 
DataNascimento := StrToDate(‘28/11/1972’); 
End; 
 
Curso de Programação em Delphi – Componentes Básicos do Delphi 
 Prof. Evandro César Freiberger Página 24 
Estruturas de Controle em Object Pascal 
 
Nos limitaremos a apresentar uma breve descrição da sintaxe dessas estruturas; os próximos exemplos 
demonstrarão melhor a sua utilização. 
 
Comentários 
Para incluir um comentário em qualquer parte do programa podemos fazer uso de três tipos de 
delimitadores: {} e (* *) e //. Os dois primeiros delimitadores permitem que os comentários sejam distribuídos 
por várias linhas. Eles marcam o início e o fim do comentário. 
 
 
Exemplos 
{ Este é um comentário } 
 (* Este é um comentário 
 com duas linhas *) 
 
O terceiro tipo de comentário se inicia com // e vai até o final da linha. 
Exemplo: 
 
 A := B; // Comentário até o final da linha. 
 
Bloco De Comandos “Begin... End” 
 
Prende um conjunto de declarações em um bloco de comandos determinado. 
Sintaxe : begin {comandos} end; 
Ex: 
 
begin 
 { ... comandos iniciais ... } 
 begin 
 { ... bloco 1 ... } 
 end; 
 begin 
 { ... bloco 2 ... } 
 end; 
 { ... comandos finais ... } 
end; 
 
Estrutura Condicional Simples “If-Then” 
 
Sintaxe: 
 
if (condição) then {Bloco de comandos se condição for verdadeira}; 
 
Exemplo: 
 
If A > B then C := 10; 
 
Curso de Programação em Delphi – Componentes Básicos do Delphi 
 Prof. Evandro César Freiberger Página 25 
Obs: Caso sejam necessários {Blocos de Comandos} com mais de uma linha, estes devem ser 
delimitados pelas cláusulas begin e end. 
 
Exemplo: 
 
If A> B then 
Begin 
 C := 10; 
 D:= C* 2; 
End; 
 
Estrutura Condicional Composta “If-Then-Else” 
 
Sintaxe: 
 
if (condição) then {Bloco de comandos se condição for verdadeira} else {Bloco de comandos se 
condição for falsa}; 
 
Exemplo: 
 
if A>B then A:= 10 Else A := 20; 
 
Obs: Caso sejam necessários {Blocos de Comandos} com mais de uma linha, estes devem ser 
delimitados pelas cláusulas begin e end. 
 
If A>B then 
Begin 
 A:=10; 
 B:= 10; 
End 
Else 
Begin 
 A:=20; 
 B:=20; 
End; 
 
Estrutura Condicional “Case-Of” 
 
Sintaxe: 
 
case expressão of 
 constante_1_1,...constante_1_n : bloco_de_comando_1; 
 constante_2_1,...constante_2_n : bloco_de_comando_2; 
 ... 
 constante_n_1,...constante_n_n : bloco_de_conabdi_n: 
 else 
bloco_de_comando; 
 end; 
 
Curso de Programação em Delphi – Componentes Básicos do Delphi 
 Prof. Evandro César Freiberger Página 26 
O comando case é um substituto mais elegante e mais legível para if-then-else múltiplos. A expressão 
(ou seletor) deverá ser de tipo com o tamanho máximo de 2 bytes (Byte, Char, Word ou Integer). Segue-se um 
exemplo: 
 
case Ch of 
 'A'..'Z', 'a'..'z' : WriteLn('Letra'); 
 '0'..'9' : WriteLn('Digito’); 
 '+', '-', '*', '/' : WriteLn('Operador'); 
else 
 WriteLn(' Caracter Especial'); 
end; 
 
Estrutura de Repetição “For-To, For-Downto” 
 
Sintaxe: 
 
for contador := valor_inicial to valor_final do 
begin 
 {bloco_de_comandos} 
end; 
 
onde: 
contador é uma variável inteira; 
valor_inicial é o valor inicial do contador, que dever ser um número inteiro; 
valor_final é o valor final (para o qual o laço se encerrará) a ser assumido pelo contador, deve ser 
inteiro; 
Se desejar que o contador assuma valores decrescentes deve-se usar a seguinte sintaxe: 
 
for contador := valor_inicial downto valor_final do 
begin 
 {bloco_de_comandos} 
end; 
 
Note que as cláusulas begin e end só são necessárias para blocos com mais de uma linha. 
 
Estrutura de Repetição “While-Do” 
 
Sintaxe: 
 
while expressão_booleana do 
begin 
 {bloco_de_comando} 
end; 
 
Note que o bloco_de_comando é executado enquanto a expressão_booleana for verdadeira e que como a 
expressão_booleana é avaliada antes da execução do bloco_de_comando, se a expressão_booleana for falsa o 
bloco_de_comando não será executado nenhuma vez. 
 
As cláusulas begin e end só são necessárias para blocos com mais de uma linha. 
 
Curso de Programação em Delphi – Componentes Básicos do Delphi 
 Prof. Evandro César Freiberger Página 27 
Estrutura “Repeat-Untill” 
 
Sintaxe: 
 
repeat 
{bloco_de_comando} 
until expressão_booleana; 
 
Note que o bloco de comando é executado em sequência, enquanto a expressão_booleana for verdadeira 
e que o bloco de comando é executado pelo menos uma vez, já que a expressão_booleana é avaliada depois dele. 
 
No comando Repeat não é necessário usar a cláusula begin e end, mesmo quando contiver mais de uma 
linha. 
 
 
SubProgramas 
Funções 
 
Uma função se define em Pascal de forma semelhante a definição matemática. Ela recebe valores como 
parâmetros e retorna um outro valor como resultado. A definição de função obedece a seguinte sintaxe : 
 
function nome_da_funcao(parametro_1:tipo_1,,,parametro_n:tipo_n) : tipo de retorno; 
var 
{declaração de variáveis locais á função} 
begin 
{corpo da função} 
end; 
 
O trecho de código a seguir define a função PRODXY, que retorna como resultado o produto de dois 
números reais X e Y: 
function PRODXY(X,Y:Real) : Real; 
begin 
PRODXY := X*Y; 
end; 
 
Observe que o sinal de atribuição em Object Pascal é := e, não o sinal de igual simplesmente. 
 
 
 
 
 
 
 
 
 
 
Procedimentos 
 
Curso de Programação em Delphi – Componentes Básicos do Delphi 
 Prof. Evandro César Freiberger Página 28 
Um procedimento é semelhante a uma função, mas não retorna um valor. 
A definição de um procedimento obedece a seguinte sintaxe : 
 
procedure nome_do_procedimento(parametro_1:tipo_1,,,,parametro_n : tipo_n); 
var 
{declaração de variáveis locaisao procedimento} 
begin 
{corpo do procedimento} 
end; 
 
 
Passagem De Parâmetros 
 
Podemos passar parâmetros para uma função ou um procedimento por valor e por referência. Quando 
se passa um parâmetro por valor estamos realmente passando um valor ou a cópia de um valor armazendo numa 
variável. Quando a passagem se faz por referência, estamos passando o endereço da variável na memória e não o 
seu valor. Quando se altera, dentro da função, o valor de uma variável passada por por referência esta alteração 
surte efeito em todo o programa (fora da função). 
Para passarmos um parâmetro por referência devemos precedê-lo da palavra reservada var. 
Ex: procedure nome_do_procedimento(var parametro1 : tipo1 ; parametro2 : tipo2); 
 
 
Curso de Programação em Delphi – Componentes Básicos do Delphi 
 Prof. Evandro César Freiberger Página 29 
Programação Orientada a Objetos com Delphi 
O que é POO? 
Programação orientada a objetos é um paradigma de desenvolvimento de programas. O Delphi não é 
totalmente orientado a objetos, porém traz características suficientes para tal. Toda base para os conceitos e 
desenvolvimento orientado a objetos está fundamentado em uma nova estrutura, denominada de classe de 
objetos. 
Classes 
É uma estrutura implementada através da união de dados e código numa mesma estrutura. Fazendo uma 
analogia com o Pascal, uma classe de objeto é semelhante a um tipo registro, porém acrescenta-se, a capacidade 
de conter código embutido nessa estrutura para manipulação dos seus próprios dados. 
De modo geral, uma linguagem para ser considerada como orientada a objetos precisa atender no 
mínimo os critérios de herança, encapsulamento e polimorfismo. 
 
Exemplo de definição de classe 
 
Cláusula Interface da Unit – definição da classe 
 
Type 
 
TEmpregado = class (TObject) 
 Private 
 FCodigo : word; 
 FUltimoCodigo : word; 
 FNome : string; 
 FNascimento : TDateTime; 
 Public 
 Constructor Criar; 
 Destructor Destruir; 
 Procedure SetNome(nome:string); 
 Function GetNome:string; 
 Procedure SetNascimento(data:TDateTime); 
 Function GetNascimento: TDateTime; 
 Function GetCodigo:Word; 
 Procedure Consulta; 
 Function CalculaIdade:string; 
 end; 
 
 
 
 
 
 
 
 
 
 
Curso de Programação em Delphi – Componentes Básicos do Delphi 
 Prof. Evandro César Freiberger Página 30 
Cláusula Implementation – implementação da classe 
 
//-------------------------------------------------------------------------- 
 //implementação do método construtor Criar 
 //-------------------------------------------------------------------------- 
 Constructor TEmpregado.Criar; 
 begin 
 Fcodigo := 0; 
 FUltimoCodigo := 0; 
 end; 
 
 
 
//-------------------------------------------------------------------------- 
 //implementação do método Destrutor Destruir 
 //-------------------------------------------------------------------------- 
 Constructor TEmpregado.Destruir; 
 begin 
 Inherited Destructor; 
 end; 
 
 //-------------------------------------------------------------------------- 
 //implementação do método SetNome 
 //-------------------------------------------------------------------------- 
 Procedure TEmpregado.SetNome(nome:String); 
 begin 
 FNome := nome; 
 FCodigo := FUltimoCodigo + 1; 
 FUltimoCodigo := FCodigo; 
 end; 
 
 //-------------------------------------------------------------------------- 
 //implementação do método GetNome 
 //-------------------------------------------------------------------------- 
 Function TEmpregado.GetNome:String; 
 Begin 
 GetNome := FNome; 
 end; 
 
 //-------------------------------------------------------------------------- 
 //implementação do método SetNascimento 
 //-------------------------------------------------------------------------- 
 Procedure TEmpregado.SetNascimento(data:TDateTime); 
 begin 
 FNascimento :=data; 
 end; 
 
 
 
 
 
 
 
 
 
Curso de Programação em Delphi – Componentes Básicos do Delphi 
 Prof. Evandro César Freiberger Página 31 
 //-------------------------------------------------------------------------- 
 //implementação do método GetNacimento 
 //-------------------------------------------------------------------------- 
 Function TEmpregado.GetNascimento:TDateTime; 
 Begin 
 GetNascimento := FNascimento; 
 end; 
 
 
 //-------------------------------------------------------------------------- 
 //implementação do método GetCodigo 
 //-------------------------------------------------------------------------- 
 Function TEmpregado.GetCodigo:Word; 
 Begin 
 GetCodigo := FCodigo; 
 end; 
 
 
 //-------------------------------------------------------------------------- 
 //implementação do método Consulta 
 //-------------------------------------------------------------------------- 
 Procedure TEmpregado.Consulta; 
 begin 
 ShowMessage('Dados do Funcionário(a): '+FNome+#13+ 
 'Matricula : '+intToStr(FCodigo)+#13+ 
 'Data Nasc : '+DateToStr(FNascimento)); 
 
 end; 
 
 //-------------------------------------------------------------------------- 
 //implementação do método CalculaIdade, que através da data de nascimento 
 //calcula a idade, tendo como base a data atual do sistema e devolve uma 
 //string com o número de anos,meses e dias que a pessoa tem. 
 //-------------------------------------------------------------------------- 
 Function TEmpregado.CalculaIdade:String; 
 var 
 numAno,numMes,numDia: word; 
 Diferenca : TDateTime; 
 begin 
 Diferenca := Date - FNascimento; 
 DecodeDate(Diferenca,numAno,numMes,numDia); 
CalculaIdade := 'A idade do(a) '+Fnome+' é de '+intToStr(numAno-1900)+ 
' Anos, '+intToStr(numMes)+' Mês e '+intToStr(numDia)+' Dias, '; 
 end; 
 
 
 
 
 
 
 
 
 
 
 
Curso de Programação em Delphi – Componentes Básicos do Delphi 
 Prof. Evandro César Freiberger Página 32 
Usando a classe definida acima 
 
Var 
 Empregado : Tempregado; 
 Codigo : word; 
 Nome : String; 
Begin 
 Empregado := Tempregado.Criar; //cria uma instância da classe Tempregado 
 Empregado.SetNome(‘Fulano’); //atribui um novo nome 
 Empregado.SetNascimento(StrToDate(‘01/03/1975’)); //atribui a data de nasci. 
 ShowMessage(Empregado.CalculaIdade); //exibe a idade 
 Codigo := Empregado.GetCodigo; // busca o codigo 
 Nome := Empregado.GetNome; //busca o nome 
 Empregado.Destruir; //destrói a instância liberando memória 
End; 
 
Encapsulamento 
 
É a capacidade de ocultar a complexidade que foi necessária para sua implementação. Dessa forma o 
desenvolvedor que irá usar essa classe, não conhecerá a complexidade de sua implementação, facilitando e 
agilizando o processo de implementação da aplicação. 
 
Tipos de Encapsulamento 
 
São definidos através dos atributos de visibilidade, que devem ser colocados antes dos membros que 
possuem o respectivo atributo. Os atributos podem aparecer em qualquer ordem, porém é adotada como padrão a 
ordem alfabética ( private, protected, public, published).Exemplo: 
 
Type 
 
Tdialogo = Class 
Private 
Ffonte : Tfont; 
Fmin : Integer; 
Fmax : Integer; 
Procedure MudaFonte(Fonte:Tfont); 
Protected 
Procedure DesenhaTela; 
Property Fonte : Tfont read Ffonte write MudaFonte; 
Public 
Constructor Cria(nome : string); 
Destructor Destroi; 
Function Executa : Boolean; 
Published 
Property Min read Fmin write Fmin; 
Property Max read Fmax write Fmax; 
End; 
 
Obs : quando temos para o mesmo atribuito de visibilidade, métodos e campos, os campos devem vir 
antes que os métodos. 
Curso de Programação em Delphi – Componentes Básicos do Delphi 
 Prof. Evandro César Freiberger Página 33 
 
Atributo de Visibilidade Private 
 
Esses membros ficam invisíveis para as units que irão usar a classe em questão, bem como para todas as 
classes que herdarem esses membros, ou seja, esses membros serão visíveis somente na classe que os definiu. 
 
Atributo de Visibilidade Protected 
 
Esses membros ficam invisíveis para as units que irão usar a classe em questão, porém poderão ser 
acessados na implementação dos métodos das classes que herdarem esses membros. 
 
Atributo de Visibilidade Public 
 
Não tem restrições de acesso, tanto usuários da classe quanto classes que herdam esses membros 
poderão acessa-los. 
 
Atributo de Visibilidade Published 
 
Da mesma maneira que os atributos públicos, não possuem restrições, porém será usado para definir 
propriedades dos novos componentes para o delphi. Essa propriedades serão inseridas no Object Inspector para 
que possam ser manipuladas em tempo de projeto. 
 
 
Obs: quando omitimos os atributos de visibilidade, serão admitidos como públicos. 
 
 
 
Curso de Programação em Delphi – Componentes Básicos do Delphi 
 Prof. Evandro César Freiberger Página 34 
Herança 
 
É a capacidade que uma classe tem de herdar características (dados e código) de uma classe ancestral, 
formando assim uma hierarquia de classes. No Delphi, qualquer classe pode herdar características de uma classe 
ancestral, com exceção da classe Tobject, que é a classe ancestral de todas as outras. A herança é o mecanismo 
que implementa o reaproveitamento de código. 
 
Exemplo de herança 
 
 Type 
 
TEmpregado = class (TObject) 
 Protected 
FCodigo : word; 
FUltimoCodigo : word; 
FNome : string; 
FNascimento : TDateTime; 
Procedure SetNome(nome:string); 
 Public 
Constructor Criar; Virtual; 
Function CalculaIdade:string; 
Procedure CalculaSalario; Virtual; Abstract; 
Procedure Demitir; Virtual; Abstract; 
Procedure Consulta; Virtual; 
property Matricula : Word read FCodigo; 
property Nome : String read FNome write SetNome; 
property Nascimento : TDateTime read FNascimento write FNascimento; 
 end; 
 
 
 TEmpregadoCLT = class (TEmpregado) 
 Private 
FSaldoFGTS:Double; 
FTempoServico:word; 
FTempoSemFerias:word; 
FNumFeriasPendentes: 0..2; 
FSalario:Double; 
 Public 
Constructor Criar; override; 
Procedure CalculaSalario; override; 
Procedure Demitir; override; 
Procedure TirarFerias; 
Procedure Consulta; Override; 
property Salario : Double read Fsalario write FSalario; 
 end;