Upload
djalmacp
View
169
Download
29
Embed Size (px)
DESCRIPTION
Apostila Lazarus/Delhi
Citation preview
2013
CTI UNESP
Profª Ariane Scarelli Profª Kátia Zambon
[LAZARUS/DELPHI – AP01] Apostila 01 - Linguagem de Programação II - Curso Informática. Turmas: 72A, 72B e 72C.
Identifique sua apostila Seu nome: ______________________________ Sua turma: _______________
SUMÁRIO
1 INTRODUÇÃO ....................................................................................................................... 1
2 AMBIENTES DO DELPHI E DO LAZARUS.......................................................................... 4
2.1 Elementos do Delphi/Lazarus .......................................................................................... 4
2.2 Arquivos gerados no desenvolvimento em Delphi ........................................................ 5
2.3 Arquivos gerados na execução em Delphi ..................................................................... 5
2.4 Arquivos gerados no desenvolvimento em Lazarus ...................................................... 6
2.5 Arquivos gerados na execução em Lazarus ................................................................... 6
3 TIPOS DE DADOS ................................................................................................................. 7
3.1 Números inteiros .............................................................................................................. 7
3.2 Números reais ................................................................................................................... 7
3.3 Caracteres ......................................................................................................................... 7
3.4 Lógicos .............................................................................................................................. 8
4 UTILIZAÇÃO DE COMPONENTES BÁSICOS (exemplos comentados) ............................. 8 EXEMPLO 1: Criação de uma aplicação básica ................................................................................. 8 EXEMPLO 2: Criação de uma aplicação para converter moeda de reais para dólares. .................. 10
5 EXERCÍCIOS ....................................................................................................................... 17
APÊNDICES ............................................................................................................................... 44 APÊNDICE A – Programação Orientada a Objetos (POO)............................................................... 44
6 REFERÊNCIAS BIBLIOGRÁFICAS .................................................................................... 48
7 SITES ÚTEIS ....................................................................................................................... 49
Apostila 1 – Delphi Profª Ariane e Profª Kátia 1
Nota: esta apostila está baseada no Delphi 7 e Delphi 2010. No entanto, será utilizada com o software
open source Lazarus1, que contem diversas características das duas versões do Delphi.
1 INTRODUÇÃO
O Delphi é uma linguagem de programação muito utilizada mundialmente para aplicações desktop. A
última2 versão da linguagem Delphi é a XE3, produzida pela Embarcadero3. Com ela é possível
desenvolver aplicações para Mac OS e criar soluções para iOS móveis para iPhone, iPod e iPad. Como
é uma linguagem proprietária, não temos acesso a esta última versão, e sim, a uma mais antiga para fins
não comerciais, unicamente educacionais.
Alguns aplicativos desenvolvidos em Delphi4:
MySQL Administrator (visual database administration console)
WinSCP (open source FTP client)
Skype (32 bits)
BVS Solitaire Collection (game)
Famos Robotic (offline programming and simulation for industrial robots)
Programação Estruturada
Programação estruturada é uma maneira disciplinada de se efetuar a programação. Baseia-se no
seguinte princípio: os programas podem ser escritos na forma de blocos de código que se interligam
através dos mecanismos de seqüência, iteração e seleção. As linguagens são linguagens procedurais,
particionadas em um conjunto de procedimentos e funções. A seqüência de rotinas descreve como os
dados são manipulados. O que é importante observar é que o programador controla a interação entre o
código e os dados. Na linguagem de programação Pascal pode-se utilizar este tipo de código. Exemplo:
unit unid1;
interface
var
iA, iB:integer;
procedure Verificacao(iNum:integer);
procedure Valores;
implementation
procedure Verificacao(iNum:integer);
begin
1 Consulte site do Lazarus em <http://www.lazarus.freepascal.org/>
2 Em feveveiro de 2013.
3 Consulte site da Embarcadero Brasil em http://www.embarcadero.com/br/.
4 Disponível em <http://www.embarcadero.com/rad-in-action/application-showcase>. Acesso em dez/2011.
Apostila 1 – Delphi Profª Ariane e Profª Kátia 2
if (iNum mod 2) = 0 then
begin
writeln('Par');
iA:=2 * iNum+iA;
iB:=sqr(iNum)+iB;
end
else
begin
writeln('Impar');
iA:= iNum+5+iA;
iB:=iNum*4+7+iB;
end;
end;
procedure Valores;
begin
writeln('Valor de iA= ',iA);
writeln('Valor de iB= ',iB);
end;
end. {fim da unit}
program Exemplo_Introducao;
uses wincrt,unid1;
var iX:integer;
begin
writeln('Digite um valor inteiro para verificaçao:');
readln(iX);
writeln('Digite o valor de A:');
readln(iA);
writeln('Digite o valor de B:');
readln(iB);
Verificacao(iX);
Valores;
end.
Imagens das execuções em Pascal nas Figura 1 e Figura 2.
Apostila 1 – Delphi Profª Ariane e Profª Kátia 3
Programação Orientada a Objetos5
O surgimento desta metodologia de engenharia de software deu-se em fins dos anos 70 e início
dos anos 80, quando pesquisadores do Centro de Pesquisas da Xerox, em Palo Alto, Califórnia,
desenvolveram uma linguagem de programação chamada SmalTalk, que utilizava pela primeira vez o
conceito de classes e objetos, além de possuir uma interface gráfica baseada em janelas e ícones, tal
como vemos hoje no Macintosh, no Windows, entre outros.
A ideia básica por trás dessa técnica de programação é a reutilização de códigos já prontos,
denominados classes, para criarmos as partes vitais do programa, chamados de objetos. Com isso,
economizamos um bom tempo e não se “reinventa a roda”.
Na programação orientada a objetos o usuário pode controlar a entrada de dados e cabe ao
programador a manipulação destes dados independente da ordem que entraram. Observe o mesmo
exemplo anterior na Figura 3.
5 Retirado de Alves (1999, p. 43-44).
Figura 1 – Primeira execução do programa
Figura 2 – Segunda execução do programa
Apostila 1 – Delphi Profª Ariane e Profª Kátia 4
No caso da mesma aplicação ser executada utilizando-se os objetos do Delphi (Labels, Edits,
BitButtons) e a programação realizada através dos eventos OnClick dos botões, pode-se analisar que a
entrada de dados já não depende mais da ordem de programação e sim do usuário que está manipulando
o programa.
Delphi é uma linguagem de programação orientada a objetos que teve origem no Object Pascal.
Em nossa disciplina utilizaremos as classes já prontas do Delphi, instanciando (criando) os objetos nas
aplicações que desenvolveremos. Novas classes não serão criadas aqui, pois não é o propósito de nossa
disciplina. Criaremos aplicações com inúmeros objetos instanciados e faremos a programação Orientada
a Eventos, isto é, conforme os movimentos ou ações solicitados pelo usuário. Leia o APÊNDICE A –
Programação Orientada a Objetos (POO) para mais detalhes.
2 AMBIENTES DO DELPHI E DO LAZARUS
2.1 Elementos do Delphi/Lazarus
Elementos Descrição
Formulário (Form) É uma janela, elemento básico onde se agrupa os componentes para formar a interface com o usuário
Unidade (Unit) Arquivo que contém o código fonte em Object Pascal. Para cada formulário existe uma unidade associada
Componentes Objetos utilizados para a construção das aplicações (dos projetos)
Propriedades Representam os atributos dos componentes
Métodos Procedimentos ou funções próprias do objeto
Eventos Representam a resposta dos componentes ao serem acionados
Projeto (Project) Conjunto de formulários, componentes e unidades que compõem a aplicação
Figura 3 – Execução em Delphi
Apostila 1 – Delphi Profª Ariane e Profª Kátia 5
2.2 Arquivos gerados no desenvolvimento em Delphi
Os arquivos gerados pelo Delphi são apresentados a seguir. Devido ao grande número de
arquivos gerados, recomenda-se que cada aplicação tenha uma pasta específica.
Extensão Definição Função
.DPROJ Arquivo do
Projeto
Código fonte em Pascal do arquivo principal do projeto. Lista todos os formulários e units no projeto, e contém código de inicialização da aplicação. Criado quando o projeto é salvo.
.PAS Código fonte da Unit( Object Pascal)
Um arquivo .PAS é gerado por cada formulário que o projeto contém. Seu projeto pode conter um ou mais arquivos .PAS associados com algum formulário. Contem todas as declarações e procedimentos incluindo eventos de um formulário.
.DFM Arquivo gráfico do formulário
Arquivo binário que contém as propriedades do desenho de um formulário contido em um projeto. Um .DFM é gerado em companhia de um arquivo .PAS para cada formulário do projeto.
.RES Arquivo de Recursos do Compilador
Arquivo binário que contém o ícone, mensagens da aplicação e outros recursos usados pelo projeto.
.~DP Arquivo de Backup do Projeto
Gerado quando o projeto é salvo pela segunda vez.
.~PA Arquivo de Backup da Unit
Se um .PAS é alterado, este arquivo é gerado.
.~DF Backup do Arquivo gráfico do formulário
Se você abrir um .DFM no editor de código e fizer alguma alteração, este arquivo é gerando quando você salva o arquivo.
.DSK Situação da Área de Trabalho
Este arquivo armazena informações sobre a situação da área de trabalho especifica para o projeto em opções de ambiente( Options Environment).
2.3 Arquivos gerados na execução em Delphi
Extensão Definição Função
.EXE Arquivo compilado executável
Este é um arquivo executável distribuível de sua aplicação. Este arquivo incorpora todos os arquivos .DCU gerados quando sua aplicação é compilada. O Arquivo .DCU não é necessário distribuir em sua aplicação.
.DCU Código objeto da Unit
A compilação cria um arquivo .DCU para cada .PAS no projeto.
Apostila 1 – Delphi Profª Ariane e Profª Kátia 6
2.4 Arquivos gerados no desenvolvimento em Lazarus
Os arquivos gerados pelo Lazarus são apresentados a seguir. Devido ao grande número de
arquivos gerados, recomenda-se que cada aplicação tenha uma pasta específica.
Extensão Definição Função
.LPI Arquivo do
Projeto
Arquivo principal do projeto (LPI – Lazarus Project Information). Equivalente ao .DPR do Delphi. Formato XML.
.LPR Arquivo fonte do programa principal
Código fonte em Pascal do arquivo principal do projeto (Lazarus Project Main Source). Lista todos os formulários e units no projeto, e contém código de inicialização da aplicação. Criado quando o projeto é salvo.
.PAS Código fonte da Unit (Object Pascal)
Um arquivo .PAS é gerado por cada formulário que o projeto contém. Seu projeto pode conter um ou mais arquivos .PAS associados com algum formulário. Contem todas as declarações e procedimentos incluindo eventos de um formulário.
.LFM Arquivo gráfico do formulário
Arquivo binário que contém as propriedades do desenho de um formulário contido em um projeto. Um .LFM é gerado em companhia de um arquivo .PAS para cada formulário do projeto. Equivalente ao .DFM do Delphi.
2.5 Arquivos gerados na execução em Lazarus
Extensão Definição Função
.EXE Arquivo compilado executável
Este é um arquivo executável distribuível de sua aplicação.
Apostila 1 – Delphi Profª Ariane e Profª Kátia 7
3 TIPOS DE DADOS
3.1 Números inteiros
Toda e qualquer informação numérica que pertença ao conjunto dos números inteiros relativos
(negativa, nula ou positiva). Números sem casas decimais.
Tipo Faixa Utilização Memória (bytes)
Shortint -128 .. +127 1
Smallint -32.768 .. +32.767 2
Longint -2.147.483.648 ..
+2.147.483.647
4
Byte 0 .. +255 1
Word 0 .. +65.535 2
Integer -2.147.483.648 ..
+2.147.483.647
4
Cardinal 0 .. +2.147.483.647 4
3.2 Números reais
Valores que podem ter parte inteira e parte decimal (ponto flutuante ou float).
Tipo Faixa Dígitos significativos
Utilização Memória (bytes)
Real 5x10^-324 .. 1.7x10^308 15 – 16 8
Real48 2.9x10^-39 .. 1.7x10^38 11 – 12 6
Single 1.5x10^-45 .. 3.4x10^38 7 - 8 4
Double 5.0x10^-324 .. 1.7x10^308 15 – 16 8
Extended 3.6x10^-4951 .. 1.1x10^4932 19 – 20 10
Comp -2^63+1 .. 2^63-1 19 – 20 8
Currency -922,337,203,685,477.5808 .. 922,337,203,685,477.5807
19 - 20 8
3.3 Caracteres
Toda e qualquer informação composta por um conjunto de caracteres alfanuméricos: numéricos
(0.. .9), alfabéticos (A.. .Z, a.. .z) e especiais (por exemplo, #, ?, !, @).
Apostila 1 – Delphi Profª Ariane e Profª Kátia 8
Tipo Tamanho máximo
Char 1 byte
String Até 2 Gigabytes
3.4 Lógicos
Toda e qualquer informação que pode assumir apenas duas situações.
Tipo Utilização Memória (bytes)
Boolean 1
Bytebool 1
Wordbool 2
Longbool 4
4 UTILIZAÇÃO DE COMPONENTES BÁSICOS (exemplos comentados)
EXEMPLO 1: Criação de uma aplicação básica
Criando uma Aplicação para o Exemplo1
Linguagens de Programação Lazarus
Criar um novo projeto (Figura 5): Menu Arquivo Novo Projeto/Aplicação
A partir deste ponto, alguns conceitos de programação devem ser inseridos:
Figura 4 – Exemplo 1: Aplicação Básica
Apostila 1 – Delphi Profª Ariane e Profª Kátia 9
Projeto composto por vários formulários (vários *.LFM os quais têm sua respectiva unit
associada, os arquivos *.PAS)
Formulário composto dos componentes que serão utilizados para a programação do projeto
Componentes estão nas suas respectivas guias: Standard, Additional, System, Data Access,
Data Controls etc.
Projeto (aplicação) – prjExemplo1.LPI
Alterando as propriedades do Formulário
Propriedade Valor Descrição
BorderStyle Single Estilo da borda da janela: modo simples, não permite que o tamanho da janela seja alterado com o mouse
Caption Exemplo 1 – Aplicação Básica
Label escrito no título superior da janela
Color ClMenu Cor da janela: clMenu é uma constante que guarda a cor padrão da janela definido pelo usuário no Windows
Name frmExemplo1 Nome do objeto interno
WindowsState WsNormal Modo de abertura da janela, modo Normal. Outros
untExemplo1.LFM
untExemplo1.PAS
Figura 5 – Criando um novo projeto
Apostila 1 – Delphi Profª Ariane e Profª Kátia 10
modos podem ser selecionados, como o maximizado ou minimizado.
Salvando o projeto e o formulário
Menu Arquivo Salvar Tudo, o Lazarus questionará o nome e a pasta (utilize uma pasta específica
para cada projeto):
Pasta: C:\trabalho\exemplo1
Projeto: prjExemplo1
(neste processo o Lazarus salva: prjExemplo1.LPI – Lazarus Project Information)
Formulário: untExemplo1
(neste processo o Lazarus salva: untExemplo1.PAS – Source File
untExemplo1.LFM – Lazarus Form)
Inserindo os componentes e alterando suas propriedades
Guia Objeto Propriedade Valor Descrição
Standard Label Caption Hello World!!! É o que será apresentado na tela
Fonte Size 20 Tamanho da letra
Name lblHello Nome da variável
EXEMPLO 2: Criação de uma aplicação para converter moeda de reais para dólares.
Figura 6 – Exemplo 2: Conversor de Moedas
Apostila 1 – Delphi Profª Ariane e Profª Kátia 11
Criando uma Aplicação para o Exemplo2
Linguagens de Programação Lazarus
Criar um novo projeto: Menu Arquivo Novo Projeto/Aplicação
Alterando as propriedades do Formulário
Propriedade Valor Descrição
BorderStyle Single Estilo da borda da janela: modo simples, não permite que o tamanho da janela seja alterado com o mouse
Caption Exemplo 1 – Conversor de Moeda
Label escrito no título superior da janela
Color ClMenu Cor da janela: clMenu é uma constante que guarda a cor padrão da janela definido pelo usuário no Windows
Name frmMoeda Nome do objeto interno (variável)
WindowsState WsMaximized Modo de abertura da janela, modo Maximizado
Salvando o formulário e o projeto
Menu Arquivo Salvar Tudo, o Lazarus questionará o nome e a pasta (utilize uma pasta específica
para cada projeto):
Pasta: C:\trabalho\exemplo2
Projeto: prjExemplo2
(neste processo o Lazarus salva: prjExemplo2.LPI – Lazarus Project Information)
Formulário: untExemplo2
(neste processo o Lazarus salva: untExemplo2.PAS – Source File
untExemplo2.LFM – Lazarus Form)
Inserindo os componentes e alterando suas propriedades
Guia Objeto Propriedade Valor Descrição
(você deve completar)
Standard Panel Align AlTop
Caption Conversor de Moeda
Fonte Size 18
Name pnlMoeda
Standard Label Caption Digite o valor do dólar hoje (US$):
Apostila 1 – Delphi Profª Ariane e Profª Kátia 12
Fonte Size 10
Name lblDolar
Standard Label Caption Digite o valor a ser convertido (R$):
Fonte Size 10
Name lblReal
Standard Edit Name edtDolar
<espaço em branco>
Text
Standard Edit Name edtReal
Text <espaço em branco>
Additional BitBtn Name bbtnConverter
Fonte Size 10
Caption &Converter
Hint Converte reais em dólares
ShowHint True
Additional BitBtn Name bbtnSair
Fonte Size 10
Caption &Sair
Hint Encerra a aplicação
ShowHint True
Standard Label Caption Valor convertido em dólares: US$
Fonte Size 12
Name lblResposta
Standard Label Caption <espaço em branc >
Fonte Size 12
Name lblRetorno
Entendendo o código fonte principal do Projeto (prjExemplo2.LPR):
program prjExemplo2;
{$mode objfpc}{$H+}
uses
{$IFDEF UNIX}{$IFDEF UseCThreads}
cthreads,
{$ENDIF}{$ENDIF}
Interfaces, // this includes the LCL widgetset
Apostila 1 – Delphi Profª Ariane e Profª Kátia 13
Forms, untExemplo2;
{ you can add units after this }
{$R *.res}
begin
RequireDerivedFormResource := True;
Application.Initialize;
Application.CreateForm(TfrmMoeda, frmMoeda);
Application.Run;
end.
Entendendo o código fonte do Formulário (untExemplo2.PAS):
unit untExemplo2;
{$mode objfpc}{$H+}
interface
uses
Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, ExtCtrls,
StdCtrls, Buttons;
Type
{ TfrmMoeda }
TfrmMoeda = class(TForm)
bbtnConverter: TBitBtn;
bbtnSair: TBitBtn;
edtDolar: TEdit;
edtReal: TEdit;
lblResposta: TLabel;
lblRetorno: TLabel;
lblDolar: TLabel;
lblReal: TLabel;
pnlMoeda: TPanel;
private
{ private declarations }
public
{ public declarations }
end;
Apostila 1 – Delphi Profª Ariane e Profª Kátia 14
var
frmMoeda: TfrmMoeda;
implementation
{$R *.lfm} { Diretiva compiladora que inclui toda a interface, propriedades da forma
e componentes do arquivo *LDFM }
end.
Eventos utilizados no exemplo:
Os programas feitos em Delphi/Lazarus são orientados a eventos. Eventos são ações
normalmente geradas pelo usuário, mas podem ser também geradas pelo Windows. Existem eventos
associados ao formulário e a cada componente. Ex.: Clicar o mouse, pressionar uma tecla, mover o
mouse, pressionar <ENTER> etc.
Exemplos:
Ao formulário está ligado o evento on create, que ocorre quando o formulário é exibido na tela
pela primeira vez durante a execução;
Ao objeto botão está ligado o evento on click, que ocorre quando um click com o mouse sobre
o botão é executado.
Eventos comuns aos componentes
Evento Descrição
OnClick Ocorre quando o usuário clica o mouse posicionado no objeto
OndblClick Ocorre quando o usuário dá um duplo clique
OnKeyDown Ocorre quando o usuário pressiona uma tecla enquanto o objeto
tem foco
OnKeyUp Ocorre quando o usuário solta uma tecla enquanto o objeto tem o
foco
OnKeyPress Ocorre quando usuário pressiona uma tecla
OnMouseDown Ocorre quando o usuário pressiona o botão do mouse
OnMouseUp Ocorre quando o usuário solta o botão do mouse
OnMouseMove Ocorre quando o usuário move o ponteiro do mouse
Métodos
Um método é um tipo especial de função ou procedimento que está relacionado à classe a que
pertence o componente.
Apostila 1 – Delphi Profª Ariane e Profª Kátia 15
Método Descrição
Show Mostra um formulário
Hide Esconde um formulário mais não o descarrega
Print Imprime um formulário na impressora
SetFocus Estabelece o foco para um formulário ou
componente
BringtoFront Envia para frente
Botão Sair Evento OnClick (no evento On Click ocorrerá o método Close)
procedure TfrmMoeda.btnSairClick(Sender: TObject);
begin
frmMoeda.Close;
end;
Nota: o parâmetro Sender enviado nas procedures de eventos dos componentes de um form é do tipo
TObject e é um tipo específico do Delphi que proporciona maior flexibilidade de programação
(generalização). Ele indica que componente (ou objeto) recebeu o evento e então ativa o processo
correspondente. Um exemplo típico seria apontar para a mesma procedure o evento de dois objetos
diferentes. Por exemplo, o trecho de código abaixo mostra o título da aplicação no Caption de um Dialog
Box somente se o evento OnClick foi recebido por Button1.
procedure TMainForm.Button1Click(Sender: TObject);
begin
if Sender = Button1 then
AboutBox.Caption := ‘Sobre’ + Application.Title
else
AboutBox.Caption := '';
AboutBox.ShowModal;
end;
Botão Converter Evento OnClick (no evento On Click ocorrerá a execução dos procedimentos
abaixo)
procedure TfrmMoeda.bbtnConverterClick(Sender: TObject);
begin
Apostila 1 – Delphi Profª Ariane e Profª Kátia 16
val(edtDolar.Text,rValorDolar,iErro);
val(edtReal.Text,rValorReal,iErro);
rValorConvertido := rValorReal / rValorDolar;
str(rValorConvertido:8:1,sRetorno);
lblRetorno.Caption:=sRetorno;
end;
Criando as variáveis utilizadas neste exemplo
As variáveis podem ser criadas na seção Implementation:
var
rValorDolar, rValorReal, rValorConvertido:real;
iErro:integer;
sRetorno:string[20];
Ou podem ser criadas localmente, na seção var da própria sub-rotina, porque, neste caso, são
utilizadas somente no escopo desta procedure.
procedure TfrmMoeda.bbtnConverterClick(Sender: TObject);
var
rValorDolar, rValorReal, rValorConvertido:real;
iErro:integer;
sRetorno:string[20];
begin
val(edtDolar.Text,rValorDolar,iErro);
val(edtReal.Text,rValorReal,iErro);
rValorConvertido := rValorReal / rValorDolar;
str(rValorConvertido:8:1,sRetorno);
lblRetorno.Caption:=sRetorno;
end;
Verifique seu aprendizado:
a) No componente LABEL, qual a diferença entre as propriedades NAME e CAPTION?
Apostila 1 – Delphi Profª Ariane e Profª Kátia 17
b) No componente EDIT, qual a diferença entre as propriedades NAME e TEXT?
c) Qual a finalidade do “&” no componente BITBTN? Em qual propriedade deve ser inserido?
d) Qual o componente possui a propriedade HINT? Qual a finalidade desta propriedade?
e) Qual deve ser o status da propriedade SHOWHINT para que o HINT funcione?
f) O que significam os arquivos salvos? .LPI, .PAS e .LFM?
5 EXERCÍCIOS
1) Elabore uma aplicação em Lazarus que receba uma temperatura em graus Celsius e a converta em
Farenheit:
F = 9C/5+32
Pasta: C:\Trabalho\Exercicio1 (para cada exercício uma nova pasta)
Formulário: untExerc1.PAS
Projeto: prjExerc1.LPI
2) Elabore uma aplicação que receba o valor do raio (admita que o raio esteja no intervalo de 0 – 100) de
uma esfera e calcule o seu volume e sua área, baseando-se nas fórmulas dadas. Mostre os valores
calculados. Utilize para o valor de 3.14159265.
3
2
3
4
4
RVOLUME
RAREA
Apostila 1 – Delphi Profª Ariane e Profª Kátia 18
Inserindo novos objetos e alterando suas propriedades
Guia Objeto Propriedade Valor Descrição (você
deve completar)
Additional LabeledEdit EditLabel Caption Qual é o valor do RAIO?
Additional BitBtn Name bbtnCalcular
Caption &Calcular
Glyph ... Load... escolher
imagem da calculadora
Additional BitBtn Name bbtnLimpar
Caption &Limpar
Glyph ... Load... escolher
imagem da vassoura
Additional BitBtn Name bbtnFechar
Caption &Fechar
Glyph ... Load... escolher
imagem de fechar janela
Additional Bevel Name bevBaixoRelevo
Validação da entrada (raio no intervalo de 0-100) no evento OnExit do próprio LabelEdit:
Na seção Implementation, declare as variáveis que serão utilizadas nas procedures:
var
rRaio:real; // variável utilizada na transformação de text para real
rArea, rVolume:real; // variáveis utilizadas no cálculo
iErro:integer; // variável utilizada na procedure VAL
No evento OnExit do LabelEdit do Raio:
procedure TfrmCalculos.lbledtRaioExit(Sender: TObject);
begin
// Verifica se o valor está no intervalo de 0 - 100
val(lbledtRaio.Text, rRaio, iErro);
if (rRaio < 0) or (rRaio > 100) then
begin
ShowMessage('Valor do Raio fora do intervalo válido (0-100)');
Apostila 1 – Delphi Profª Ariane e Profª Kátia 19
lbledtRaio.Clear; // Limpa o valor anteriormente digitado
lbledtRaio.SetFocus // Volta o foco para LabelEdit
end;
end;
3) Desenvolva uma aplicação para entrar com dois valores e executar as funções de uma calculadora
(adição, subtração, multiplicação e divisão). Para a divisão, verifique se o divisor não é zero e dê uma
mensagem para alertar o usuário e volte o foco para acessar outro valor:
ShowMessage('Divisor não pode ser zero!');
edtValor2.SetFocus; // edtValor2: name do edit que acessa o 2º. Valor
Inserindo objetos e alterando suas propriedades
Guia Objeto Propriedade Valor Descrição (você deve completar)
Additional Bevel Name bevTopo
Shape bsFrame
Style bsRaised
Additional Bevel Name bevCalculos
Apostila 1 – Delphi Profª Ariane e Profª Kátia 20
Shape bsFrame
Style bsRaised
Additional Bevel Name bevTotalLimpa
Shape bsFrame
Style bsRaised
Additional Bevel Name bevRodape
Shape bsFrame
Style bsRaised
Standard Edit Name edtMostra
ReadOnly true
Dica: deixe o objeto edtMostra somente para leitura, não permitindo alteração. Para isso, altere a
propriedade ReadOnly de false para true.
Nota: para transformar strings em valores reais e vice-versa:
rValor1 := StrToFloat (frmCalc.edtValor1.Text);
edtMostra.Text := FloatToStr(rCalc);
Criando uma procedure para efetuar as conversões
Ao clicar em cada botão de cálculo (soma, subtração, multiplicação e divisão) a aplicação terá que
converter as duas entradas string (Text) dos Edits para valores reais. Para não repetir as mesmas
instruções de conversão em todos os botões, criaremos uma procedure de conversão que será
chamada a partir de cada botão no evento click.
unit untCalc;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, ExtCtrls, StdCtrls;
type
TfrmCalc = class(TForm)
//definições de objetos e procedures gerados automaticamente pelo Delphi
Apostila 1 – Delphi Profª Ariane e Profª Kátia 21
procedure Conversao; //deve ser incluído manualmente pelo programador
private
{ Private declarations }
public
{ Public declarations }
end;
var
frmCalc: TfrmCalc;
implementation
var
rCalc,rValor1,rValor2:real;
iErro:integer;
sCald:string;
{$R *.dfm}
procedure TfrmCalc.Conversao;
begin
rValor1:=strtofloat( edtValor1.text);
rValor2:=strtofloat( edtValor2.Text);
end;
procedure TfrmCalc.btnSomaClick(Sender: TObject);
begin
Conversao;
rCalc:=rValor1+rValor2;
end;
//outras procedures da aplicação
end.
Definição de ordem para as entradas solicitadas:
Neste exercício há duas entradas (Primeiro valor e Segundo valor) e diversos botões que devem
possuir uma ordem de foco para o uso da tecla TAB. Pense na situação em que o usuário utilizará
somente o teclado para ter acesso aos componentes de entrada. A sequência ou ordem dos objetos
deve seguir uma lógica, geralmente, de cima para baixo e da esquerda para a direita. Para que isto
Apostila 1 – Delphi Profª Ariane e Profª Kátia 22
ocorra, programe a propriedade TabOrder para os Edits e também para os botões. Esta ordem inicia-
se no valor 0.
4) Elabore uma aplicação para inserir um ComboBox (guia Standard) para a seleção de um estado do
Brasil, com a imagem do mapa do respectivo estado:
Altere as propriedades do objeto ComboBox para:
Propriedade Valor Descrição (você deve completar)
Name cmbEstado
Text Selecione o Estado
DropDownCount 5
Font Size 10
Hint Selecione um estado
ShowHint True
AutoComplete True
Items <digitar todos os estados que deverão aparecer no combo>
Para que o estado selecionado apareça no Edit:
<nome_edit>.text := <nome_combo>.text;
Dica: deixe o Edit somente para leitura, não permita alteração. Qual é a propriedade?
Uma das formas de apresentar o nome da capital do estado no Edit correspondente é utilizar o
ItemIndex do próprio Combo. Exemplo:
Apostila 1 – Delphi Profª Ariane e Profª Kátia 23
procedure TfrmCombo.cmbEstadosClick(Sender: TObject);
begin
edtEstado.Text:=cmbEstados.Text;
case cmbEstados.ItemIndex of
0:edt_capital.Text:='Vitória';
1:edt_capital.Text:='Cuiabá';
2:edt_capital.Text:='Belo Horizonte'; //colocar para os outros estados
end;
end;
5) Faça uma aplicação para apresentar o signo do zodíaco correspondente a uma data. Receba como
dados de entrada (ComboBox) o mês e o dia de nascimento de uma pessoa (habilite a seleção do dia
somente após selecionado o mês). A tabela abaixo mostra o último dia de cada mês e o signo
correspondente. Apresente, através do componente Image (Guia Additional), uma figura
correspondente a cada signo após sua identificação.
Para o componente Image:
o Name: imgSigno
o AutoSize: True
o Center: True
Apostila 1 – Delphi Profª Ariane e Profª Kátia 24
Para habilitar a seleção do dia depois de selecionado o mês, no evento OnChange do
ComboBox de seleção do mês, faça:
procedure TfrmZodiaco.cmbMesChange(Sender: TObject);
begin
lblDia.Enabled:=True;
cmbDia.Enabled:=True;
end;
Nota: as imagens devem ser tipo BMP e, para facilitar, deverão estar na mesma pasta que a aplicação.
Mês Último dia Signo
Jan 20 CAPRICÓRNIO
Fev 19 AQUÁRIO
Mar 20 PEIXES
Abr 20 ÁRIES
Mai 20 TOURO
Jun 20 GÊMEOS
Jul 21 CÂNCER
Ago 22 LEÃO
Set 22 VIRGEM
Out 22 LIBRA
Nov 21 ESCORPIÃO
Dez 21 SAGITÁRIO
Evento OnClick do Botão “Descobrir Signo?”
procedure TfrmZodiaco.btnSignoClick(Sender: TObject);
begin
imgSigno.Picture.LoadFromFile('capricornio.bmp');
lblSigno.Caption:='Capricórnio';
end;
Apostila 1 – Delphi Profª Ariane e Profª Kátia 25
6) Faça uma aplicação de uma agência de carros que utilize o componente ListBox (guia Standard). Apresente também a imagem do carro selecionado na lista. Modifique o design do form conforme
necessário.
Altere as propriedades do objeto ListBox para:
Propriedade Valor Descrição (você deve completar)
Fonte Size 10
Sorted True
Items <digitar todos os carros que deverão aparecer na lista>
Para os edits: Primeiro / Selecionado / Último propriedade ReadOnly deve ser true.
Evento Duplo Clique no ListBox procedure TfrmListBox.ltbCarrosDblClick(Sender: TObject);
var
QtdeItens:byte;
begin
with ltbCarros do
begin
edtPrimeiro.Text:=Items[0]; // preencherá o texto do edit: Primeiro da lista
edtSelecionado.Text:=Items[ItemIndex]; // preencherá o texto do edit: Selecionado
QtdeItens:=ltbCarros.Items.Count;
edtUltimo.Text:=Items[QtdeItens-1]; // preencherá o texto do edit: Último da lista
end;
end;
Apostila 1 – Delphi Profª Ariane e Profª Kátia 26
Evento KeyPress no Edit do Adicionar à lista procedure TfrmListBox.edtAdicionarKeyPress(Sender: TObject; var Key: Char);
begin
if key = #13 then // testa se a tecla foi um <enter>
begin
if edtAdicionar.Text <> '' then // para não adicionar item em branco
begin
// adiciona em tempo de execução, mas não armazena em Items
ltbCarros.Items.Add(edtAdicionar.Text);
// Limpar valores dos Edits
edtAdicionar.Clear;
edtPrimeiro.Clear;
edtSelecionado.Clear;
edtUltimo.Clear;
ltbCarros.SetFocus; // volta o foco para o ListBox
end;
end;
end;
7) Faça uma aplicação para efetuar a tabuada de um número qualquer.
a) Faça a previsão de que o usuário pode digitar qualquer caracter e não só valores numéricos
b) Pode-se utilizar um ListBox para apresentar os valores (veja o exercício anterior) para o método:
<Name_ListBox>.Items.Add (<string que será apresentada>);
c) O operador + faz a concatenação de strings e pode ser utilizado no método acima. Exemplo: ‘72’ +
‘ABCD’ é igual a 72ABCD
d) Qualquer um dos comandos de repetição podem ser utilizados: While, Repeat ou For.
Apostila 1 – Delphi Profª Ariane e Profª Kátia 27
8) Faça uma aplicação na qual você selecione o tipo de animal de estimação que possui (se não possui,
escolha assim mesmo!), a sua raça e busque a foto dele.
Utilize um componente OpenPictureDialog (da Guia Dialogs) para procurar o caminho que se
encontra a imagem.
Coloque um botão que deverá indicar a seleção da Imagem, como “Buscar Foto”. Dê o nome
BTN_BuscarFoto.
Evento OnClick do Botão “Buscar Foto”
procedure Tfrm_PET.btn_BuscarFotoClick(Sender: TObject);
begin
OpenPictureDialog1.Execute;
if OpenPictureDialog1.FileName <> '' then // aqui se usa dois apóstrofos, não são aspas
Image1.Picture.LoadFromFile(OpenPictureDialog1.FileName);
end;
Implemente: para cada tipo de animal, trazer apenas as raças que correspondam a este tipo. Exemplo:
“Cão”, trazer apenas as raças de cães. Isto pode ser implementado no Evento OnClick do ComboBox
referente ao tipo de animal.
Apostila 1 – Delphi Profª Ariane e Profª Kátia 28
9) Faça uma aplicação para a verificação de tipos de triângulos.
Primeiro: verifique se os lados formam um triângulo: Cada lado tem que ser menor que a
soma dos dois outros lados. Caso não formem um triângulo, dê uma mensagem ao
usuário, limpe os valores dos componentes do tipo Edit e solicite redigitação dos dados.
Quando o usuário digitar valores que formem um triângulo, apresentar um Radiogroup (que
vai existir no formulário, mas estará invisível até o momento) com as opções de tipo de
triângulo para que ele selecione o tipo. O programa fará as verificações e apresentará uma
mensagem de acerto ou de erro para o usuário. No caso de erro, identifique o tipo correto:
2 lados iguais ▲ isósceles
3 lados iguais ▲ eqüilátero
3 lados diferentes ▲ escaleno
Apostila 1 – Delphi Profª Ariane e Profª Kátia 29
Implemente as seguintes características:
a) no botão Checar apresentar a mensagem “Identifica o tipo de triângulo” quando passar o
cursor em cima do botão (Hint). Anote as propriedades que foram setadas para que esta ação
ocorra;
b) b) nos botões utilizados no formulário é possível acioná-los utilizando a tecla <ALT> e a letra
que está sublinhada. Como isto foi feito?
10) A aplicação descrita abaixo utiliza o componente RadioButton (Guia Standard). Insira 4 objetos do
tipo RadioButton e altere suas propriedades para:
Caption Name
Somar rdbSomar
Subtrair rdbSubtrair
Multiplicar rdbMultiplicar
Dividir rdbDividir
a) Para a apresentação do resultado utilize um objeto Panel (ou um Edit com a propriedade
ReadOnly true);
Objeto Propriedade Valor Descrição (você deve completar)
Panel Name pnlMostrar
Caption <deixe vazio>
b) Para a verificação de qual opção foi setada basta utilizar o método checked do componente
RadioButton:
If rdbAdicao.Checked then
< calcular a adição dos valores>;
If rdbSubtracao.Checked then
< calcular a subtração dos valores>;
...
Apostila 1 – Delphi Profª Ariane e Profª Kátia 30
c) Para os botões calcular, limpar e sair utilize o objeto SpeedButton (guia Additional):
Objeto Propriedade Valor Descrição (você deve completar)
SpeedButton Name sbtnCalcular
Glyph ... Load... escolher imagem de
calculadora
SpeedButton Name sbtnLimpar
Glyph ... Load... escolher imagem de
vassoura
SpeedButton Name sbtnSair
Glyph ... Load... escolher imagem de
porta aberta
Para melhorar a qualidade do programa faça testes de consistência ao clicar o botão Calcular:
o não deixar valores em branco;
o na divisão testar se o divisor é diferente de zero.
Apostila 1 – Delphi Profª Ariane e Profª Kátia 31
11) A aplicação descrita abaixo utiliza o componente RadioGroup e CheckGroup (Guia Standard). No
entanto, você pode criar a aplicação com os componentes que achar conveniente para uma boa
interface.
Pesquise sobre os possíveis doadores para cada tipo sanguíneo e implemente no botão “Checar
Respostas” a verificação para a “Doação bem sucedida” ou “Doação Mal Sucedida”.
A forma de checagem do CheckGroup é:
if CheckGroup1.Checked[num_item]then
Apostila 1 – Delphi Profª Ariane e Profª Kátia 32
12) Faça uma aplicação para executar o jogo Joken-Po. Neste jogo você poderá utilizar o componente
Radiogroup ou adicionar um Groupbox e vários RadioButtons. A interface deverá prever a sua
escolha (ou jogada) e a escolha do computador entre as opções de PEDRA-TESOURA-PAPEL.
Utilize a função Random que retorna um valor aleatório para a jogada do computador.
iComputador := Random(3); //para sortear de 0 a 2
O usuário deverá necessariamente marcar sua opção de jogo, caso contrário dê uma mensagem.
Após o usuário marcar sua opção (evento click do componente), mostre a opção do computador
(gerada aleatoriamente entre 0 e 2). Não permita que o usuário (jogador) marque as opções do
computador (desabilite-as). Feito isto, apresente o número de jogos (vamos estipular em 5 jogadas) e
o placar (quantas vezes o usuário ganhou, quantas vezes o computador ganhou e quantos empates
ocorreram).
A tela abaixo é apenas uma sugestão, modifique o design conforme sua criatividade.
13) Faça uma aplicação para calcular o IMC (índice de massa corporal) de uma pessoa, utilizando a
fórmula: AlturaAltura
PesoIMC
*
Entre com peso, altura e sexo da pessoa. Faça os testes de consistência necessários para as
entradas peso e altura. Para sexo utilize o objeto ComboBox (guia Standard) e preencha a
propriedade Items com as opções Feminino e Masculino.
Calcule e mostre o IMC e classifique-o de acordo com a tabela abaixo:
Apostila 1 – Delphi Profª Ariane e Profª Kátia 33
IMC Resultado
Inferior a 20 Muito magro
20 a 25 Normal
26 a 30 Sobrepeso
31 a 40 Obeso
Acima de 40 Obesidade Grave
14) Faça um programa na forma de jogo em que o usuário possa identificar características dos animais
até descobri-lo ou o usuário escolhe o animal e tenta acertar suas características. A seguir, UMA
SUGESTÃO de como pode ser feito este jogo, mas use a sua criatividade, inclusive utilizando outros
tipos de componentes.
Exemplo: É mamífero? Sim. É quadrúpede? Sim. É carnívoro? Não. É herbívoro? Sim. Então o
animal escolhido é o cavalo.
cobrapatassem
crocodilocarnívoros
tartarugacascocom
réptil
patonadadora
pingüimpolar
avestruztropicalvoadoranão
aves
baleiaaquático
morcegovoador
macacofrutífero
emonívorobípede
cavaloherbívoro
leãocarnívoroquadrúpede
mamífero
_____________________
____________________
____________________
______________________
____________
__________
_________________
__________________
__________
hom___________
_____
_____
Apostila 1 – Delphi Profª Ariane e Profª Kátia 34
Sugestão montada:
15) Faça uma aplicação que contemple duas abas inseridas no componente PageControl – Guia Win32.
Uma para o Cadastro de Alunos e outra, para o Cadastro de Professores. Abaixo, SUGESTÕES para
o exercício, mas podem inserir outros dados e utilizar outros componentes.
Implementação: insira a data de nascimento do aluno e utilize o componente Calendário (guia
Dialogs).
Apostila 1 – Delphi Profª Ariane e Profª Kátia 35
16) Faça uma aplicação para anotar um prato do cardápio de uma trattoria de acordo com as escolhas do
cliente. Calcule e apresente o preço. Faça como descrito no formulário, porém, o design é apenas
uma sugestão.
Apostila 1 – Delphi Profª Ariane e Profª Kátia 36
Inserindo objetos e alterando suas propriedades
Guia Objeto Propriedade Valor Descrição (você deve
completar)
Standard RadioGroup Name rdgMassa
Caption Massa
ItemIndex -1
Items <digitar todas as opções de massa>
Standard RadioGroup Name rdgMolho
Caption Molho
ItemIndex -1
Items <digitar todas as opções de massa>
Standard GroupBox Name grbIngredientes
Caption Ingredientes
Standard CheckBox Name chkAzeitona
Caption Azeitona
Checked False
Standard CheckBox <repetir para os demais ingredientes como acima>
Standard Memo Name memPedido
Lines <deixar vazio>
Standard Edit Name edtTotal
ReadOnly True
Para adicionar ao Memo do Pedido, veja o exemplo:
memPedido.Lines.Add(variavel + ‘texto’ + variavel + ‘texto’);
O botão Fechar Pedido deve ser desabilitado após ser clicado e será habilitado novamente ao
clicar em Limpar. Para desabilitar, faça:
btnFecharPedido.Enabled := False;
Tabela de preços:
Item Preço (R$)
Spaghetti 18,00
Farfalle 22,00
Gnocchi 25,00
Apostila 1 – Delphi Profª Ariane e Profª Kátia 37
Sugo 8,00
Branco 11,00
Alho 0,50
Azeitona 1,00
Queijo 2,50
Manjericão 0,50
Alcaparra 0,90
Funghi 3,50
Observações:
Caso nenhuma opção de massa, molho e ingredientes seja selecionada, dê uma
mensagem;
Nos botões deve aparecer uma mensagem quando o mouse estiver posicionado sobre eles
(Hint):
Botão Sair mensagem: encerra a aplicação
Botão Limpar mensagem: novo prato
Botão Fechar Pedido mensagem: calcula pedido
Fazer no Botão Limpar: limpar o Edit, limpar as seleções dos RadioGroup e CheckBox.
17) A aplicação a seguir é o início dos estudos sobre criptografia. Esta técnica ou método criado poderá
ser utilizado no trabalho do Jogo e Quiz a ser realizado nos próximos bimestres. É importante que
seja aplicado um método eficiente para que possa ser implementado com o banco de dados do
trabalho para proteger logins e senhas de usuários.
Leitura e estudo do material “Criptografia e Chaves Digitais.PDF” (baixar do Blog da Profª Ariane)
Fazer o exercício com a sugestão dada ou criar uma interface nova para sua aplicação:
Apostila 1 – Delphi Profª Ariane e Profª Kátia 38
18) O aplicativo solicitado a seguir tem o objetivo de preparar um menu com opções que englobem todos
os exercícios desenvolvidos até aqui. Determine, segundo sua opinião, os níveis de dificuldade dos
exercícios e os inclua nas opções de níveis correspondentes (Fácil, Médio, Difícil). Siga os passos
abaixo para evitar erros. Nesta aplicação há um único projeto com vários forms.
a) Criar uma nova aplicação e salvar:
prjMenu.LPI
untMenu.PAS (que salvará a untMenu.LFM)
b) Inserir o componente MainMenu (Guia Standard) e as opções do Menu (segundo sua opinião)
Para colocar as teclas de atalho setar a propriedade ShortCut
Apostila 1 – Delphi Profª Ariane e Profª Kátia 39
c) Testar a aplicação e, se tudo estiver correto, comece a inserir os formulários um a um e
execute o projeto para cada formulário inserido.
Coloque na mesma pasta do projeto do menu os arquivos .PAS e .LFM
correspondentes ao exercício (vamos utilizar o exercício da temperatura:
untExerc1.PAS e untExerc1.LFM)
Para inserir o formulário correspondente, siga os passos:
1) Abra no Lazarus o arquivo da unit (untExerc1.PAS) a ser inserido;
2) Clique em menu Projeto → Adicionar arquivo do editor ao projeto;
3) Abra o código fonte do projeto (menu Projeto → Exibir fonte do projeto);
4) Acrescente a linha a seguir:
Application.CreateForm(TfrmTemperatura, frmTemperatura);
5) Repita o passo 4 para cada unit que for inserida ao projeto.
Cuidado: se os formulários estiverem com o mesmo nome (form1 e form1, por
exemplo, então não será possível adicionar o novo formulário)
Em cada opção correspondente do objeto MainMenu, no evento click, inserir o
nome do formulário que deseja que seja aberto:
procedure TfrmMenu.TemperaturaClick(Sender: TObject);
begin
frmTemperatura.ShowModal;
end;
Na unit do Menu inserir os nomes das units correspondentes às opções do menu:
unit untMenu;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls,
Forms, Dialogs, Menus, untExerc1; //Nome atribuído à unit criada
Acrescente os outros formulários da mesma forma
Observação: verifique a diferença entre a ativação de um formulário pelo método Show e pelo
método ShowModal. Anote aqui.
Apostila 1 – Delphi Profª Ariane e Profª Kátia 40
Exercícios extras:
19) O dia da Páscoa é o primeiro domingo depois da lua cheia que ocorre a partir do vigésimo primeiro dia
do mês de março. Se a lua cheia ocorre num domingo, então a Páscoa é no domingo seguinte. Ao
cálculo do dia da Páscoa deu-se o nome de Computus. Em 1800, Carl Friedrich Gauss, um dos
maiores matemáticos de todos os tempos, resumiu o cálculo do dia da Páscoa numa fórmula bastante
simples. O processo de Gauss para determinar em que dia se comemora a Páscoa no ano X é o
seguinte:
a) Determine duas constantes M e N, pela tabela:
ANO M N
1582 a 1699 22 2
1700 a 1799 23 3
1800 a 1899 23 4
1900 a 2099 24 5
2100 a 2199 24 6
2200 a 2299 25 0
2300 a 2399 26 1
2400 a 2499 25 1
b) Determine A = resto da divisão de Ano por 4
c) Determine B = resto da divisão de ano por 7
d) Determine C = resto da divisão de Ano por 19
e) Determine D = resto da divisão de (19 x C + M) por 30
f) Determine E = resto da divisão de (2 x A + 4 x B + 6 x D + N) por 7
g) Calcula-se o valor de P dado por P= 22 + D + E
h) Se P for inferior ou igual a 31, a Páscoa será no dia P de Março. Mas se P for maior que 31,
então:
i) Calcula-se P'= D + E - 9 e a Páscoa será no dia P' de Abril. Mas, se P' for superior a 25, então:
j) Calcula-se P'' = P' - 7 e a Páscoa será a P'' de Abril, já que não pode ser celebrada em data
posterior a 25 de Abril
Faça um programa que receba o ano, determine e mostre em que dia se comemora a Páscoa num
ano qualquer, de 1582 até 2499.
Apostila 1 – Delphi Profª Ariane e Profª Kátia 41
20) Elabore uma aplicação que receba o nome do aluno, as médias dos 4 bimestres, calcule e mostre a
média resultante. No botão calcular testar os 4 edits nos quais foram digitadas as médias e, se estiver
fora do intervalo 0-10 voltar o foco para acessar novamente (teste de consistência de dados).
Neste exercício, utilizar o componente MaskEdit (da guia Additional).
Alterar as propriedades: Name, Text (deixar em branco) e EditMask para 99,9. Este formato de
máscara permitirá que sejam digitados somente valores numéricos com este formato: dois inteiros
e uma casa decimal. A validação de dados (valores no intervalo de 0 – 10) não é feita aqui.
A máscara tem basicamente 3 campos separados por ; (ponto-e-vírgula):
Primeiro campo: é a máscara propriamente dita (quantidade de caracteres, tipo etc.);
Segundo campo: o valor 0 (zero) não salva os caracteres fixos da máscara e o valor 1 salva;
Terceiro campo: representa o caractere em branco, podendo ser substituído pelo underline, @ etc.
Alguns caracteres do MasEdit mais utilizados:
Caractere Definição Exemplo
0 Caracteres numéricos (0-9) de preenchimento obrigatório 000;1;_
9 Caracteres numéricos (0-9) de preenchimento opcional 999;1;_
# Caracteres numéricos (0-9) e os sinais de - ou + de preenchimento
opcional
###;1;_
L Caracteres alfabéticos (A-Z, a-z.) de preenchimento obrigatório LLL;1;_
l Caracteres alfabéticos (A-Z, a-z.) de preenchimento opcional Lll;1;_
A Caracteres alfanuméricos (A-Z, a-z, 0-9) de preenchimento obrigatório AAA;1;_
a Caracteres alfanuméricos (A-Z, a-z, 0-9) de preenchimento opcional Aaa;1;_
> Todos os caracteres alfabéticos digitados após este símbolo serão
convertidos para maiúsculos
>aaa;0;_
< Todos os caracteres alfabéticos digitados após este símbolo serão
convertidos para minúsculos
<aaa;0;_
\ Utilizado para marcar determinado caractere não especial como fixo,
não podendo sobrescrevê-lo
\(999\)000-
0000;0;_
: Utilizado como separador de horas, minutos e segundos 00:00:00;1;_
/ Utilizado como separador de dia, mês e ano 99/99/9999;1;_
Apostila 1 – Delphi Profª Ariane e Profª Kátia 42
Para o botão Limpar:
procedure TForm1.Button1Click(Sender: TObject);
begin
medit_nota1.Clear; //Limpa o texto no MaskEdit
medt_nota2.clear;
medt_nota3.clear;
medt_nota4.clear;
medit_nota1.SetFocus; // Volta o foco para o MaskEdit da 1ª média
end;
Validação das entradas (médias no intervalo de 0-10) no evento OnExit do próprio MaskEdit:
Na seção IMPLEMENTATION, declarar as variáveis que serão utilizadas nas procedures:
var rMed1,rMed2,rMed3,rMed4:real; // variávies utilizadas na transformação de text para real
iErro:integer; // variável utilizada na procedure VAL
Apostila 1 – Delphi Profª Ariane e Profª Kátia 43
No evento OnExit do MaskEdit da Primeira Média:
procedure TForm1.medit_nota1Exit(Sender: TObject);
begin
// Verifica se o valor está no intervalo de 0 - 10
val(medit_nota1.Text,rMed1,iErro);
if (rMed1 < 0) or (rMed1 > 10) then
begin
ShowMessage('Valor da Média do 1º Bimestre fora do intervalo 0-10');
medit_nota1.Clear; // Limpa o valor anteriormente digitado
medit_nota1.SetFocus; // Volta o foco para o primeiro MaskEdit
end;
end;
Não permitir a edição do MaskEdit da Média Anual:
Após o botão Calcular ser acionado, a média anual será calculada e o seu valor apresentado no
MaskEdit correspondente:
Este e qualquer outro componente que permita edição, mas que está sendo utilizado somente para
apresentar valores DEVEM ter a propriedade ReadOnly alterada para TRUE. Neste caso, o componente
não permite edição, somente leitura.
Verifique seu aprendizado:
a) Nos componentes EDITs, para que serve a propriedade TABORDER?
b) Para impedir a alteração de um componente EDIT, o que deve ser feito?
Apostila 1 – Delphi Profª Ariane e Profª Kátia 44
APÊNDICES
APÊNDICE A – Programação Orientada a Objetos (POO)
Programação Orientada A Objetos (POO)
Até alguns anos atrás, o desenvolvimento de software foi baseado no chamado modelo
procedural, que consiste na execução sequencial de rotinas ou funções, ordenadas de acordo com a
maneira como se deseja que a aplicação resultante funcione. Mas uma técnica mais simples, natural e
interessante para o processo de análise de problemas e construção de aplicações foi criada: a Orientação
a Objetos (OO). De uns anos para cá, embora o modelo procedural ainda seja utilizado, uma migração
em grande escala deste para o modelo OO vem ocorrendo.
Como principais vantagens, a POO traz a capacidade de reutilização de código e a modularidade
de escrita.
Orientação a Objetos (OO) O modelo orientado a objetos tem como base a execução de métodos (pequenas funções que
atuam diretamente sobre os dados de um objeto), levando em consideração a maneira como o usuário
enxerga o sistema e suas funções. A OO é uma forma de programação em que os dados são agrupados
ao seu processamento. Ou seja, em vez de existirem dados declarados e funções que os alteram
arbitrariamente, cada pequeno conjunto de dados estará acompanhado por um conjunto de funções que
operam sobre eles fazendo todas as operações desejáveis. Nenhum outro trecho de código do programa
acessará esses dados diretamente, mas sempre chamando as funções corretas. Dessa forma, é mais
fácil manter consistência dos dados, encontrar e corrigir erros, fazer manutenção, implementar novas
funcionalidades ou trocar representações de dados. O principal benefício da OO é a reutilização de
código, pois a cada objeto criado não é necessário criar novamente sua estrutura.
Características da OO A OO tem como principais características: classificação, identidade, abstração, encapsulamento,
herança e polimorfismo.
Classificação consiste em categorizar aquilo que nos rodeia. Criamos classes de objetos para
facilitar nossa compreensão do mundo, ou seja, grupos de objetos que compartilham características
comuns, embora distintas, em cada objeto. Por exemplo, os seres humanos têm características comuns:
estrutura e funcionamento do corpo, embora possam ser distintos por sua altura, idade, peso, cor e
aparência da pele, olhos etc.
Apostila 1 – Delphi Profª Ariane e Profª Kátia 45
Identidade consiste em denominarmos todos os objetos, não apenas classificá-los, de forma que
cada objeto se torne único, ou seja, assuma uma identidade. As pessoas têm nomes e sobrenomes, os
animais de estimação recebem nomes, os automóveis têm chapa etc.
Abstração é um processo que consiste em compreender um sistema, concreto (como um jogo de
futebol) ou não (um sistema de conta corrente, por exemplo), e criar um modelo documentado e
padronizado que reflita o seu comportamento. Em outras palavras, abstração é um processo de
modelagem de sistemas concretos ou não, extraindo do seu contexto os principais objetos e
descrevendo-os por meio da discriminação de suas propriedades (atributos) e funcionalidades (métodos).
Encapsulamento indica que podemos utilizar um objeto conhecendo apenas sua interface, isto é,
sua aparência exterior, tal como fazemos, muitas vezes, com computadores, automóveis e outras
máquinas de nosso tempo. Nele, os dados não estão acessíveis diretamente, mas apenas através dos
métodos permitidos O encapsulamento permite preservar informações consideradas importantes ou
sigilosas dentro do objeto, divulgando apenas aquilo que se julgue conveniente.
Herança é o mecanismo de criação de novas classes de objetos a partir de outras já existentes. A
herança toma como prontas e disponíveis certas características do objeto de origem, sendo portanto uma
forma muito especial de compartilhamento de código. Isso permite que criemos várias classes,
hierarquicamente relacionadas, partindo de uma mais geral para diversas outras mais especializadas,
obtendo como resultado uma árvores de classes, tal como a classificação proposta pela biologia para a
divisão dos seres vivos.
Polimorfismo refere-se à nossa capacidade de reconhecer em um objeto particular um outro mais
geral, por exemplo: podemos falar de uma bola de futebol em termos de uma bola genérica, podemos
tratar um liquidificador como um eletrodoméstico genérico, podemos classificar morcegos, cachorros e
orcas como animais mamíferos.
Classes Na OO, o programa é formado por um conjunto de classes que são modelos para a criação
de objetos. Pense nas classes como sendo um gabarito, um protótipo, a planta de uma casa ao
realizarmos uma construção, a receita de um bolo.
Classes são estruturas que definem as características e comportamentos dos seres ou coisas do
mundo real; quando implementados as classes, as características passam a se chamar atributos, e os
comportamentos se transformam nos nossos métodos de acesso (ou funções).
Objetos são as instâncias das classes, os seres que existem no mundo real quando são inseridos
no mundo computacional.
Atributos são as características inerentes ao ser ou coisa do mundo real quando são definidas no
mundo computacional.
Métodos são os comportamentos ou funções de um objeto do mundo real na forma como ele é
tratado no mundo computacional.
Apostila 1 – Delphi Profª Ariane e Profª Kátia 46
Por exemplo, um objeto carro no mundo real tem as propriedades cor, ano, número de portas e
tipo de combustível, entre outras. Além disso, tem os comportamentos acelerar, frear, virar à esquerda e
outros. Assim, quando modelamos esse carro computacionalmente para um jogo de corridas, por
exemplo, definimos uma classe carro cujas propriedades são transformadas nos atributos cor, ano,
número de portas, tipo de combustível e seus comportamentos são transformados no código do programa
nos métodos acelerar, frear, virar à esquerda e outros (Figura 7).
Figura 7 – Exemplo de classe e objetos
Assim, durante a execução do sistema, a cada carro que cadastramos uma cópia nova da classe
carro é criada, e damos a ela características que irão diferenciá-la dos demais carros, ou seja, criamos a
cada vez um novo objeto do tipo de carro.
Quando um trecho de código quer fazer uma operação sobre um objeto ele emite
uma mensagem para esse objeto requisitando a operação. Na prática, pode-se implementar isso como
uma simples chamada de função (chamada de método), que é o que ocorre em C++.
Instanciação É a criação de um objeto. Instanciar significa criar uma instância da classe, isto é, um novo objeto
que pode ser descrito por meio dessa classe. Enquanto uma classe é um modelo abstrato de um objeto,
uma instância representa um objeto concreto dessa classe. Podemos criar uma classe Bola que
representa um modelo abstrato de bola, enquanto cada bola que existe fisicamente é uma instância
dessa classe, ou seja, um objeto concreto deste tipo.
Isso significa que utilizamos as mesmas características para descrever objetos diferentes, ou seja,
uma bola de 4 cm de raio, maciça, de madeira e amarela é uma bola diferente de outra com 1 m de raio,
oca, de plástico, azul, embora descritas através das mesmas características (raio, oca ou maciça,
material e cor). Assim, os atributos de uma classe são variáveis-membro dessa classe, que contém a
informação representativa sobre um certo objeto deste tipo.
Apostila 1 – Delphi Profª Ariane e Profª Kátia 47
Do ponto de vista da computação, a instanciação corresponde à alocação de memória para
armazenar informações sobre um certo objeto, ou seja, a reserva de uma porção de memória organizada
internamente para guardar os valores associados aos atributos que descrevem um objeto de uma certa
classe.
Exemplo em C++:
/*
Instanciação de objeto
*/
#include <iostream>
#include <conio.h>
using namespace std;
class ponto
{
private: //nao precisaria por private, em class eh default.
float x, y;
public: //daqui em diante tudo e acessivel.
void inicializa(float a,float b){ x=a; y=b; }
/* As funcoes de uma classe podem acessar os atributos
private dela mesma.*/
void mostra(void){cout << "X:" << x << " , Y:" << y <<
endl;}
};
int main()
{
ponto ap; //instanciacao
ap.inicializa(0.0,0.0); //metodo public
ap.mostra(); //metodo public
getche();
}
Apostila 1 – Delphi Profª Ariane e Profª Kátia 48
6 REFERÊNCIAS BIBLIOGRÁFICAS
ALVES, William Pereira. Delphi 5.0, Aplicação para Banco de Dados – Controle de Estoque. Editora
Érica, São Paulo, 1999.
CANTÙ, Marco. Delphi 7 – “A Bíblia”. Editora Pearson, São Paulo, 2003.
RUBENKING, Neil J. Programação em Delphi para leigos. Editora Berkeley, São Paulo, 1995.
SANTOS, Jean Patrick Figueiredo dos. Desenvolvendo Aplicativos com Lazarus – Linux e Windows. 1ª
ed. 2011 (Ebook), AGBook. Disponível para compra em <https://www.agbook.com.br/books>
SCARELLI, Ariane. Apostila 03 do Curso de Linguagem C/C++, Programação Orientada a Objetos (POO).
CTI, Unesp. 2011.
Apostila 1 – Delphi Profª Ariane e Profª Kátia 49
7 SITES ÚTEIS
http://www.ajudadelphi.com.br/index.php http://www.delphidicas.com.br/ http://www.activedelphi.com.br/ http://www.delphibrasil.net/index.php http://www.embarcadero.com/br/ http://www.marcocantu.com/ http://blog.marcocantu.com/ http://wiki.lazarus.freepascal.org/ http://wiki.lazarus.freepascal.org/Lazarus_IDE_Tools