51
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: _______________

Apostila 1 Delphi

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