Baixe o app para aproveitar ainda mais
Prévia do material em texto
UNIVERSIDADE DE SÃO PAULO Instituto de Ciências Matemáticas e de Computação ISSN - 0103-2585 33UURRJJUUDDPPDDomomR�R�''HHOOSSKKLL DDSSRRLLDDQQGGR�R�D�FD�FRRQQVVWWUUXXoommR�GR�GHH DDSSOOLLFFDDWWLLYYRRV�V�GGH�H�%%DDVVHHV�V�GGH�H�''DDGRGRVV Enzo Seraphim Renata Pontin de Mattos Fortes Notas Didáticas n0 42 São Carlos, dezembro de 1999 Programação Delphi apoiando aplicativos de Bases de Dados 2 Índice 1 INTRODUÇÃO ............................................................................................................................................ 4 1.1 PRINCIPAIS CARACTERÍSTICAS DO DELPHI.................................................................................................. 4 1.2 CARACTERÍSTICAS DO DELPHI CLIENT/SERVER.......................................................................................... 5 2 O AMBIENTE DELPHI.............................................................................................................................. 5 2.1 COMO É FORMADA UMA APLICAÇÃO EM DELPHI ........................................................................................ 5 2.2 CÓDIGO FONTE DO ARQUIVO PROJECT(.DPR)............................................................................................. 7 2.3 CÓDIGO FONTE DO ARQUIVO UNIT (.PAS) .................................................................................................. 7 2.4 ARQUIVOS GERADOS PELA COMPILAÇÃO ................................................................................................... 9 2.5 AMBIENTE DE PROGRAMAÇÃO.................................................................................................................... 9 3 FUNDAMENTOS DE OBJECT PASCAL............................................................................................... 11 3.1 CONCEITOS DE PROGRAMAÇÃO ORIENTADA A OBJETOS .......................................................................... 11 3.2 VARIÁVEIS................................................................................................................................................ 11 3.3 ATRIBUTOS ............................................................................................................................................... 12 3.4 ENCAPSULAMENTO ................................................................................................................................... 12 3.5 CLASSES ................................................................................................................................................... 12 3.6 OBJETOS ................................................................................................................................................... 13 3.7 LITERAIS ................................................................................................................................................... 13 3.8 CONSTANTES ............................................................................................................................................ 13 3.9 INSTRUÇÕES.............................................................................................................................................. 13 3.10 COMENTÁRIOS...................................................................................................................................... 14 3.11 TIPOS DE DADOS PADRÃO .................................................................................................................... 14 3.12 CONVERSÕES DE TIPO .......................................................................................................................... 17 3.13 EXPRESSÕES ......................................................................................................................................... 18 3.14 OPERADORES........................................................................................................................................ 18 3.15 ESTRUTURAS DE DECISÃO .................................................................................................................... 19 3.16 ESTRUTURAS DE REPETIÇÃO ................................................................................................................ 19 3.17 TIPOS DEFINIDOS PELO USUÁRIO.......................................................................................................... 20 3.18 PROCEDIMENTOS, FUNÇÕES E MÉTODOS.............................................................................................. 22 3.19 WITH .................................................................................................................................................... 23 3.20 SELF ..................................................................................................................................................... 23 3.21 CRIANDO E DESTRUINDO OBJETOS ...................................................................................................... 23 3.22 RTTI .................................................................................................................................................... 24 3.23 EXCEÇÕES ............................................................................................................................................ 24 4 BIBLIOTECA DE CLASSES.................................................................................................................... 28 4.1 NOMENCLATURA ...................................................................................................................................... 28 4.2 PROPRIEDADES ......................................................................................................................................... 28 4.3 EVENTOS................................................................................................................................................... 29 4.4 MÉTODOS ................................................................................................................................................. 30 4.5 JANELAS ................................................................................................................................................... 30 4.6 COMPONENTES PADRÃO ........................................................................................................................... 31 4.7 CAIXAS DE DIÁLOGO ................................................................................................................................ 35 4.8 MENUS...................................................................................................................................................... 35 4.9 CLASSES NÃO VISUAIS ............................................................................................................................. 36 5 BANCOS DE DADOS................................................................................................................................ 38 5.1 CONCEITOS IMPORTANTES ........................................................................................................................ 38 5.2 BORLAND DATABASE ENGINE .................................................................................................................. 38 5.3 ARQUITETURA DE ACESSO........................................................................................................................ 38 5.4 DATA ACCESS........................................................................................................................................... 39 5.5 DATA CONTROLS ...................................................................................................................................... 50 6 RELATÓRIOS ...........................................................................................................................................54 Programação Delphi apoiando aplicativos de Bases de Dados 3 6.1 IMPRESSÃO DE TEXTO............................................................................................................................... 54 6.2 IMPRESSÃO GRÁFICA ................................................................................................................................ 54 6.3 IMPRESSÃO COM O REPORTSMITH ............................................................................................................ 55 6.4 IMPRESSÃO COM O QUICKREPORT ............................................................................................................ 55 7 CONCLUSÃO ............................................................................................................................................ 58 Programação Delphi apoiando aplicativos de Bases de Dados 4 1 INTRODUÇÃO A disciplina de Laboratório de Base de Dados ministrada aos alunos de cursos de Computação visa proporcionar o desenvolvimento de aplicações práticas utilizando sistemas de gerenciamento de bases de dados relacionais e ferramentas de apoio. Além disso, como disciplina “optativa”, ela proporciona a consolidação da teoria apresentada na disciplina de Banco de Dados que é seu pré-requisito. Para tanto, aulas expositivas seguidas de demonstração prática em laboratório têm sido adotadas como metodologia do ensino. Os exercícios são então elaborados em aulas de laboratório assistidas. Nesse contexto, este conjunto de notas didáticas se destina a viabilizar um suporte para a utilização de Delphi como ferramenta de apoio para as práticas necessárias de disciplinas que em seu conteúdo programático, contam com o desenvolvimento de aplicativos de Bases de Dados tendo por front-end a programação em Delphi. Este material foi em grande parte coletado de informações disponíveis na World-Wide Web. Desde que a primeira versão do Delphi foi lançada, em 1995, tem se mostrado muito atrativo para o desenvolvimento em ambiente operacional Windows. Numa relação com outros ambientes de programação, podemos dizer que o Delphi possui muitos dos recursos poderosos do C++ e a facilidade do Visual Basic. A principal vantagem do Delphi está na linguagem usada, Object Pascal, que é uma evolução do Pascal padrão. O Pascal surgiu no final dos anos 60 e, até hoje, é usada como uma das primeiras linguagens de programação para estudantes de computação. Em 1984, a Borland lançou o Turbo Pascal, que se firmou como um bom compilador de Pascal para o mercado e, a partir de então, passou a incluir novos recursos nesta linguagem, como Units e Objetos, até a ascensão do Windows, quando foi lançado o Turbo Pascal for Windows. Depois surgiu o Borland Pascal, cuja linguagem é considerada a primeira versão da Object Pascal. Na sua versão atual, usada pelo Delphi, a Object Pascal é uma linguagem sólida e respeitada, sem perder sua peculiar facilidade. No Delphi, a criação de aplicativos começa com a montagem de componentes em janelas, como se fosse um programa gráfico, o usuário também pode utilizar de componentes desenvolvidos por terceiros ou criar seus próprios componentes. O Delphi vem com todas as ferramentas necessárias para a criação de bancos de dados dBase e Paradox, além de uma versão do Interbase, permitindo a criação de aplicativos com banco de dados sem a necessidade de aquisição de outro programa. O Delphi também tem acesso a bases de dados como Foxpro, Access, Informix, SYBASE, Oracle, SQL Server e DB2, além de qualquer outro banco de dados para Windows compatível com ODBC. Atualmente, podem ser encontradas as seguintes versões de Delphi: Delphi Standard → para estudantes, sem classes para armazenamento de estruturas de dados. Delphi Professional → com classes para armazenamento de estruturas de dados, mas sem suporte a arquitetura cliente/servidor. Delphi Client/Server Suite → versão completa com fontes dos componentes. 1.1 Principais Características do Delphi • Construtor Visual de Interface com o Usuário - o IDE (Interface Development Environment) permite criar visualmente aplicações Client/Server de forma rápida através da seleção de componentes na paleta. • Arquitetura Baseada em Componentes - os componentes asseguram que as aplicações Delphi sejam robustas, reutilizáveis e de fácil manutenção. Com facilidade de criação de componentes nativos, além de controles ActiveX, inclusive com disponibilidade do código fonte dos componentes padrão • Compilador de Código Nativo de Alta Performance - compilador/otimizador de código mais rápido do mercado, gerando executáveis rápidos e puros, sem run-time Programação Delphi apoiando aplicativos de Bases de Dados 5 • Tow-Way Tools - a capacidade de alternar entre um form e seu código permite aos desenvolvedores trabalhar tanto na edição de texto como no modo de design visual através de total sincronização do código fonte com a representação visual. • Biblioteca de Componentes Visuais - a biblioteca de componentes visuais (VCL-Visual Component Library) consiste de objetos reutilizáveis incluindo objetos padrão de interface com o usuário, gerenciamento de dados, gráficos e multimidia, gerenciamento de arquivos e quadros de dialogo padrão. A Client/Server edition inclui o código fonte do Visual Component Library. • Arquitetura Aberta - a arquitetura do IDE permite adicionar componentes e ferramentas personalizadas e de terceiros. • Linguagem Orientada a Objetos - o Delphi utiliza o Object Pascal, que oferece a facilidade de programação em 4GL de alto nível com a performance e poderio de um 3GL. Fluxo de programação baseado em eventos. Suporte a manipulação de exceções, que permite criar aplicações mais robustas e com maior segurança. • Suporte à Tecnologia do Windows - o Delphi é compatível com a tendência da tecnologia Windows, incluindo suporte a OLE 2.0,DDE, DCOM, VBXs e ODBC. • Depurador Gráfico - o Debugger permite encontrar e eliminar "bugs" em seu código. • Edição Estilo Brief - o Editor permite a utilização de um conjunto de símbolos para expressões. Consulte Brief Regular Expressions no Help on-line. • Ambiente Personalizável - a opção de menu Environment Options permite personalizar seu ambiente para o máximo de produtividade. • Object Browser - o Object Browser permite a visualização da hierarquia dos objetos na visual component library. • Gerenciador de Projetos - o Project Manager oferece uma visualização de todos os forms e units de um determinado projeto e oferece um mecanismo conveniente para gerenciar projetos. • Experts - Uma variedade de Experts o guia através do desenvolvimento de tipos padrões de forms. Por exemplo, o Database form expert auxilia-o na construção de forms que exibam dados em bancos de dados locais ou remotos. • Gerador de Relatórios - o ReportSmith oferece a mais avançada ferramenta de geração de relatórios para desenvolvedores que precisem criar relatórios que acessem grandes volumes de dados, com utilização de componentes nativos. 1.2 Características do Delphi Client/Server O Delphi Client/Server Edition inclui todas as características do Delphi Professional e as seguintes características específicas ao ambiente Client/ Server: • Conectividade de Alta Performance - os SQL Links oferecem acesso de alta performance aos drives nativos, conectando com bancos de dados populares, incluindo Oracle, Sybase,Informix, e InterBase. • Suporte a Team Development - Intersolv PVCS permite que grupos de desenvolvedores trabalhem juntos com códigos fonte integrados, check-in, check-out e gerenciamento de controle de versão. • Construtor Visual de Query - o Visual Query Builder oferece uma ferramenta visual para criar facilmente queries sofisticadas e gerar automaticamente o código SQL correspondente. • Objetos Distribuídos - capacidade de criação de aplicações multi-tier, com objetos distribuídos comCorba. 2 O AMBIENTE Delphi 2.1 Como é formada uma Aplicação em Delphi Programação Delphi apoiando aplicativos de Bases de Dados 6 Quando o desenvolvedor abre um projeto no Delphi, já lhe é mostrada uma UNIT com várias linhas de código. Este texto tem como objetivo explicar um pouco da estrutura que ele usa. Um projeto Delphi tem, inicialmente, duas divisões: uma UNIT, que é associada a um Form, e outra Project, que engloba todos os FORM e UNITs da aplicação. Em Delphi temos: o Project, os Forms e as Units. Para todo Form temos pelo menos uma UNIT (Código do Form), mas temos UNITs sem Form (códigos de procedures, funções, etc). A figura a seguir ilustra a formação de uma aplicação Delphi e o Quadro 1 lista as extensões dos arquivos gerados no desenvolvimento de aplicativos em Delphi. Quadro 1. Arquivos Gerados no desenvolvimento em Delphi Extensão Arquivo Definição Função .DPR 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. .OPT Arquivo de opções do projeto Arquivo texto que contém a situação corrente das opções do projeto. Gerado com o primeiro salvamento e atualizado em subseqüentes alterações feitas para as opções 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. .DPR TESTE .EXE UNIT 1 .PAS FORM 1 .DFM FORM 1 .DCU UNIT 2 .PAS FORM 2 .DFM FORM 2 .DCU UNIT N .PAS FORM N .DFM FORM N .DCU ROTINAS .PAS Programação Delphi apoiando aplicativos de Bases de Dados 7 .~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). Obs.: .~DF, .~PA , .~DP são arquivos de backup( Menu Options, Enviroment, Guia Editor Display, Caixa de Grupo Display and file options, opção Create Backup Files, desativa o seu salvamento). Devido a grande quantidade de arquivos de uma aplicação, cada projeto deve ser montado em um diretório específico. 2.2 Código fonte do arquivo Project(.DPR) Neste arquivo está descrito o código de criação da aplicação e de seus formulários. O arquivo Project tem apenas uma seção. Esta seção é formada pelo seguinte código: PROGRAM - Define o Projeto; USES - Cláusula que inicia uma lista de outras unidades. Forms = É a unidade do Delphi que define a forma e os componentes do aplicativo In = A clausula indica ao compilador onde encontrar o arquivo Unit. Unit1 = A unidade que você criou {$R *.RES} - Diretiva compiladora que inclui o arquivo de recursos. Quando se abre um projeto novo, o Project possuirá o seguinte conteúdo: program Project1; uses Forms, Unit1 in 'UNIT1.PAS' {Form1}; {$R *.RES} begin Application.CreateForm(TForm1, Form1); Application.Run; end. 2.3 Código fonte do arquivo Unit (.PAS) Nesta divisão são escritos os códigos dos seus respectivos forms (Unit1 = Form1). Assim, são definidos os códigos de cada procedimento dos componentes que você colocar no Form. • Seção Unit - declara o nome da UNIT. • Seção Uses - contém as UNITS acessadas por este arquivo. • Seção Interface - nesta seção estão as declarações de constantes, tipos de variáveis, funções e procedures gerais da Unit/Form. As declarações desta seção são visíveis por qualquer Unit. Esta seção é formada pelo seguinte código: INTERFACE - palavra que inicia a seção; USES - cláusula que inicia uma lista de outras unidades compiladas (units) em que se basea: SysUtils = utilitários do sistema (strings, data/hora, gerar arquivos) Programação Delphi apoiando aplicativos de Bases de Dados 8 WinProcs = acesso a GDI, USER e KERNEL do Windows Wintypes= tipos de dados e valores constantes Messages=constantes com os números das mensagens do Windows e tipos de dados das Mensagens Classes=elementos de baixo nível do sistema de componentes Graphics=elementos gráficos Controls=elementos de nível médio do sistema de componentes Forms=componentes de forma e componentes invisíveis de aplicativos Dialogs=componentes de diálogo comuns • Seção Type - declara os tipos definidos pelo usuário. Subseções: Private, declarações privativas da Unit. Public declarações publicas da Unit. • Seção Var - declara as variáveis privadas utilizadas. • Seção Implementation - contém os corpos (códigos que implementam) das funções e procedures declaradas nas seções Interface e Type. Nesta seção também estão definidos todos os procedimentos dos componentes que estão incluídos no Form. As declarações desta seção são visíveis apenas por ela mesma. Esta seção é formada pelo seguinte código: {$R*.DFM} - Diretiva compiladora que inclui toda a interface, propriedades da forma e componentes do arquivo *.DFM {$S+} - Diretiva compiladora que ativa verificação de pilha. • Seção uses adicional - serve para declarar Units que ativam esta. • Inicialization - nesta seção, que é opcional, pode ser definido um código para proceder as tarefas de inicialização da Unit quando o programa começa. Ela consiste na palavra reservada inicialization seguida por uma ou mais declarações para serem executadas em ordem. Quando se abre um projeto novo, a Unit possuirá o seguinte conteúdo: unit Unit1; interface uses SysUtils, WinTypes, WinProcs, Messages, Classes, Graphics, Controls, Forms, Dialogs; type TForm1 = class(TForm) private { Private declarations } public { Public declarations } end; var Form1: TForm1; implementation {$R *.DFM} {Uses Adicional} {Initialization} end. Programação Delphi apoiando aplicativos de Bases de Dados 9 2.4 Arquivos Gerados pela Compilação Extensão Arquivo Definição Função .EXE Arquivo compilado executável Este é um arquivo executável distribuivel 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. Obs.: Estes arquivos podem ser apagados para economizar espaço em disco. 2.5 Ambiente de Programação • Janela Principal - a janela principal do Delphi é composta pela barra de menus, barra de ferramentas e paleta de componentes. Para personalizar a barra de ferramentas, basta clicar em Properties no menu de contexto. Na paleta de componentes estão os controles usados nas aplicações, agrupados em guias por categorias. • Object Inspector - no Object Inspector podemos manipular, em tempo de projeto, as propriedades e eventos dos componentes. Você também pode selecionar um componente usando o Seletor de Objetos, no topo do Object Inspector. • Propriedades - são as características de um componente. Para mudar uma propriedade, selecioneo componente no Form Designer ou no Object Selector, localize a propriedade, na guia Properties e mude o valor na coluna à direita. A edição de propriedades pode ser simples, por lista suspensa, caixa de dialogo ou com propriedades aninhadas. • Eventos - numa definição inicial, eventos podem ser vistos como chamadas a métodos em resposta a determinadas mensagens do Windows. Para criar um método para um evento, selecione o componente e clique duas vezes na coluna à direita do evento na guia Events do Object Inspector, o Delphi faz todas as declarações necessárias e mostra o método pronto para ser programado no Editor de Código. Para que um evento chame um método já definido, em vez de clicar duas vezes na coluna à direita do evento, você deve usar a lista suspensa. • Form Designer - o Form Designer é onde são desenhados os Forms das aplicações, com a inserção de componentes. No menu de contexto do Form, você pode clicar em View as Text para editar a descrição textual do Form e de seus componentes no Editor de Código, essas informações são gravadas em um arquivo binário com a extensão DFM, para voltar ao modo de exibição normal, escolha View as Form no menu de contexto do Editor de Código. • Manipulando Componentes Incluir: Selecionar o componente na paleta e clicar no Form Designer. Redimensionar: Clicar no componente e arrastar as alças de borda. Podemos usar SHIFT+SETAS para redimensionar o componente fora da grade de alinhamento do Form. Mover: Arrastar o componente. Podem ser usadas também operações de recortar, copiar e colar, além de CTRL+SETAS para mover o componente para fora da grade de alinhamento do Form. Selecionar: Segurar SHIFT para selecionar vários componentes individuais e CTRL para escolher uma área retangular do Form e selecionar todos os componentes nesta área. Alinhamento: Para alinhar componentes selecione-os e escolha View / Alignment Palette. Menu de Contexto: Bring To Front / Send To Back, para trazer o componente para frente ou enviar para trás, Tab Order para mudar a ordem de tabulação, além de Align To Grid, para alinhar os componentes selecionados à Grade do Form Designer. • Editor de Código - para escrever o código, usamos o Editor de Código do Delphi. Para cada Form é criado um código, que é gravado em arquivos chamados Units. Nesses arquivos é definida a classe do Form e seus métodos de eventos. Para alternar entre o Form e sua Unit podemos clicar Programação Delphi apoiando aplicativos de Bases de Dados 10 em Toggle Form/Unit no menu View, ou no botão corresponde da Barra de Ferrramentas. Para cada Form aberto é criado um Form Designer e uma nova guia no Editor de Código. • Configuração do Ambiente - grande parte das opções de configuração do ambiente podem ser acessadas através do item Environment Options do menu Tools. A maioria das opções desse diálogo são bastante claras e através delas podemos definir, desde as opções do Form Designer, até o Editor de Código e o caminho das Livrarias. No menu Tools, podemos escolher também Configure Tools, para permitir abrir aplicações externas a partir do ambiente do Delphi, como o Image Editor e o Database Desktop. • Project Manager - para ajudar no gerenciamento de projetos, podemos usar o Project Manager pelo menu View. O Project Manager lista as Units, os Forms existentes nessas Units e o path, se a Unit não estiver na pasta do projeto. Através dos botões do Project Manager você pode adicionar, excluir e visualizar Units e Forms que compõem o projeto. • Project Options - através do item Options, do menu Project, podemos escolher diversos aspectos de um projeto. • Forms - nessa página, podemos definir o Form principal da aplicação e a os Forms que serão criados automaticamente. Se um Form não for criado automaticamente, você terá que instanciar esse Form explicitamente. • Application - nessa página podemos definir o título, o arquivo help e o ícone da aplicação. • Compiler - usamos essa página para definir as opções de compilação, para o projeto atual. Essas opções irão interferir diretamente no executável gerado. • Linker - essa página é muito pouco usada, mas somente através dela podem modificar a memória exigida por uma aplicação. • Directories/Conditionals - pode-se especificar pastas de saída para os arquivos gerados na compilação do projeto e opções de compilação condicional. • Version Information - informações da versão do executável. • Packages - Nesta página você pode especificar parte do código para ser incluído em Packages, fora do executável, permitindo compartilhamento de componentes entre várias aplicações Delphi. • Gerenciamento de Projetos - segue uma descrição das mais importantes opções de menu para o gerenciamento de projetos, algumas dessas opções tem um botão correspondente na barra de ferramentas. File New Abre um diálogo com novos itens que podem ser adicionados ao projeto Open Abrir projetos, pode abrir também Units, Forms e texto no editor de código Save Salva o arquivo aberto no editor de código Save Project As Salva o projeto com outro nome ou local Use Unit Faz com que a Unit atual possa usar outra Unit do projeto Add to Project Adiciona uma Unit em disco ao projeto Remove from Project Remove uma Unit do projeto View Project Manager Mostra o gerenciador de projeto Project Source Mostra o código do projeto Object Inspector Mostra o Object Inspector Toggle Form/Unit Alterna entre o Form e a Unit Units Mostra o código fonte de uma Unit ou do Projeto a partir de uma lista Forms Seleciona um Form a partir de uma lista Project Compile Compila o projeto Options Opções do projeto, como ícone do executável, nome da aplicação e opções de compilação Run Run Compila e executa o projeto Programação Delphi apoiando aplicativos de Bases de Dados 11 • Ajuda - o sistema de ajuda do Delphi é a referência mais completa, seguida pelos manuais do usuário cedidos com o sistema. Se quiser ajuda sobre um componente, selecione-o e aperte F1, o mesmo pode ser feito com propriedades e eventos, no Object Inpector e comandos, no editor de código. 3 FUNDAMENTOS DE Object Pascal 3.1 Conceitos de Programação Orientada a Objetos Antes de partir para a linguagem propriamente dita, devemos considerar, de forma prática, alguns conceitos básicos de Programação Orientada a Objetos. Classe: definição de tipo dos objetos, modelo de objeto. Objeto: instância de classe, variável cujo tipo é uma classe. Atributos: variáveis de instância que são os dados de um objeto. Métodos: funções e procedimentos de um objeto. Propriedades: apelido usado para evitar o acesso direto aos atributos de um objeto, onde podemos especificar métodos que serão usados para ler e atribuir seus valores a esses atributos. Mensagens: chamada de métodos, leitura e atribuição de propriedades. Encapsulamento: conjunto de técnicas usadas para limitar o acesso aos atributos e métodos internos de um objeto. Herança: possibilidade de criar uma classe descendente de outra, aproveitando seus métodos, atributos e propriedades. Ancestral: super classe ou classe de base, a partir da qual outras classes podem ser criadas. Descendente: subclasse. Hierarquia de Classes: conjunto de classes ancestrais e descendentes, geralmente representadas em uma árvore hierárquica. Polimorfismo: capacidade de redefinir métodos e propriedades de uma classe em seus descendentes. 3.2 Variáveis No Delphi, toda variável tem que ser declarada antes de ser utilizada. As declarações podem ser feitas após a palavra reservada var, onde são indicados o nome e o tipo da variável. Os nomes de variáveis não podem ter acentos, espaços ou caracteres especiais como &, $ ou % e o primeiro caractere de um nome de variável tem que ser uma letra ou um sublinhado. O Delphi ignora o caso das letras. Variáveis Globais As variáveis abaixo são globais, declaradas da Interface da Unit. Podem ser acessadas por qualquer Unitusuária. var I: Integer; Usuario: string; A, B, Soma: Double; Ok: Boolean; Variáveis Locais As variáveis abaixo são locais ao método, ou seja, elas só existem dentro do método, não podem ser acessadas de fora, mesmo que seja na mesma Unit. Na verdade essas variáveis são criadas quando o método é chamado e destruído quando ele é encerrado, seu valor não é persistente. Programação Delphi apoiando aplicativos de Bases de Dados 12 procedure TFrmExemplo.BtnTrocarClick(Sender: TObject); var Aux: string; begin Aux := EdtA.Text; EdtA.Text := EdtB.Text; EdtB.Text := Aux; end; 3.3 Atributos Os atributos são variáveis de instância. Para declarar um atributo em uma classe basta definir o identificador e o tipo do atributo na declaração da classe, feita na seção type da Interface da Unit, como abaixo. type TFrmSomar = class(TForm) private { Private declarations } A, B: Double; public { Public declarations } Soma: Double; end; 3.4 Encapsulamento Os principais níveis de visibilidade dos atributos e métodos de uma classe são mostrados abaixo. Nível Visibilidade Private Os itens declarados nesse nível só podem ser acessados na mesma unit. Public Nesse nível, qualquer unit usuária poderá acessar o item. Protected Os itens só poderão ser acessados em outra unit se for em uma classe descendente Published É o nível default, igual ao Public, mas define propriedades e eventos usados em tempo de projeto. 3.5 Classes Classes são tipos de objetos, uma classe é declarada na cláusula type da seção interface e os métodos são definidos na seção implementation. Examine o código de um Form para identificar os elementos de sua classe. interface type TFrmSomar = class(TForm) EdtA: TEdit; EdtB: TEdit; BtnSoma: TButton; procedure BtnSomaClick(Sender: TObject); private { Private declarations } public { Public declarations } end; implementation procedure TFrmSoma.BtnSomaClick(Sender: TObject); begin ShowMessage(EdtA.Text + EditB.Text); end; Programação Delphi apoiando aplicativos de Bases de Dados 13 3.6 Objetos Um Objeto é tratado como uma variável cujo tipo é uma classe. A declaração de objetos é igual à declaração de uma variável simples, tendo no lugar do tipo a classe do objeto. var FrmSomar: TFrmSomar; 3.7 Literais Valores literais são valores usados em atribuições e expressões. Cada tipo tem uma sintaxe diferente. Tipo Definição Inteiro Seqüência de dígitos decimais (0 a 9), sinalizados ou não Inteiro Hexadecimal Seqüência de dígitos hexadecimais (0 a F), precedidos por um sifrão ($) Real Igual ao tipo Inteiro, mas pode usar separador decimal e notação científica Caractere Letra entre apóstrofos ou o caracter # seguido de um número inteiro entre 0 e 255 (ASCII) String Seqüência de caracteres delimitados por apóstrofos 3.8 Constantes São declaradas na seção const, podem ser usadas como variáveis, mas não podem ser alteradas. Geralmente o nome das constantes é escrito em letras maiúsculas e na declaração dessas constantes não é indicado o tipo. const G = 3.94851265E-19; NUM_CHARS = '0123456789'; CR = #13; SPACE = ' '; MAX_VALUE = $FFFFFFFF; Constantes Tipadas Na verdade, constantes tipadas são variáveis inicializadas com valor persistente, que podem ser alteradas normalmente, como qualquer variável. A única diferença de sintaxe entre constantes tipadas e simples é que o tipo da constante é indicado explicitamente na declaração. Se uma constante tipada for declarada localmente, ela não será destruída quando o método for encerrado. Para diferenciar das constantes normais, costuma-se declarar estas com letras de caso variável, como abaixo. const Cont: Integer = 1; Peso: Double = 50.5; Empresa: string = 'SENAC'; 3.9 Instruções Os programas são compostos por instruções, que são linhas de código executável. Exemplos de instruções simples são atribuições, mensagens entre objetos, chamadas de procedimentos, funções e métodos, como mostradas abaixo. As instruções podem ser divididas em várias linhas, o que indica o fim de uma instrução é o ponto e vírgula no final. Quando uma instrução é quebrada, costuma-se dar dois espaços antes das próximas linhas, para melhorar a leitura do código. Caption := 'Gabba Gabba Hey!'; Form2.ShowModal; Application.MessageBox('Você executou uma operação ilegal, o programa será finalizado.', 'Falha geral', MB_ICONERROR); Programação Delphi apoiando aplicativos de Bases de Dados 14 É possível se usar várias instruções agrupadas em uma instrução composta, como se fosse uma só instrução. Uma instrução composta delimitada pelas palavras reservadas begin e end. Toda instrução, simples ou composta, é terminada com um ponto-e-vírgula. if CheckBox1.Checked then begin ShowMessage('O CheckBox será desmarcado.'); CheckBox1.Checked := False; end; Estilo de Codificação As instruções e todo o código de uma Unit devem ser distribuídos para facilitar o máximo a leitura. Para isso, podemos usar a indentação, geralmente de dois espaços para indicar os níveis de código. Procure criar um estilo próprio, que melhor se molde à sua realidade. Se for desenvolver em grupo, é melhor que todos usem o mesmo estilo para evitar confusões. 3.10 Comentários Existem três estilos de comentário no Delphi, como mostrado abaixo. (* Comentário do Pascal Padrão *) { Comentário do Turbo Pascal } // Comentário de linha do C++ Cuidado com as diretivas de compilação, pois elas são delimitadas por chaves e podem ser confundidas com comentários. A diretiva de compilação mostrada abaixo é incluída em todas as Units de Forms. {$R*.DFM} 3.11 Tipos de Dados Padrão O Delphi trata vários tipos de dados padrão, segue uma descrição sucinta desses tipos. Tipos Inteiros São tipos numéricos exatos, sem casas decimais. O tipo Integer é o tipo inteiro padrão. Tipo Tamanho em Bytes Valor Mínimo Valor Máximo ShortInt 1 -128 127 SmallInt 2 -32768 32767 Longint 4 -2147483648 2147483647 Byte 1 0 255 Word 2 0 65535 Integer 4 -2147483648 2147483647 Cardinal 4 0 2147483647 Tipos Reais São tipos numéricos com casas decimais. O tipo Double é o tipo real padrão. Tipo Tamanho em Bytes Valor Mínimo Valor Máximo Dígitos Significativos Real 6 10-39 1038 11-12 Single 4 10-45 1038 7-8 Double 8 10-324 10308 15-16 Extended 10 10-4932 104932 19-20 Comp 8 -1018 1018 19-20 Currency 8 -1012 1012 19-20 Tipos Texto Os tipos texto podem operar com caracteres simples ou grupos de caracteres. O tipo texto padrão é o tipo string. Programação Delphi apoiando aplicativos de Bases de Dados 15 Tipo Descrição Char Um único caractere ASCII String Texto alocado dinamicamente, pode ser limitado a 255 caracteres conforme configuração PChar String terminada em nulo (#0), usada geralmente nas funções da API do Windows O operador + pode ser usado para concatenar strings e você pode usar uma variável do tipo string como uma lista de caracteres. ShowMessage('5ª letra do título da janela: ' + Caption[5]); Label1.Text := '2ª letra do Edit: ' + Edit1.Text[2]; Existem várias funções de manipulação de strings, veja algumas das mais importantes mostradas abaixo. Função Descrição AnsiCompareText Compara 2 strings sem sensitividade de maiúsculas/minúsculas AnsiLowerCase Converte todas as letras de uma string para minúsculas AnsiUpperCase Converte todas as letras de uma string para maiúsculas Copy Retorna parte de uma string Delete Apaga parte de uma string Insert Insere uma string em outra Length Número de caracteres de uma string Pos Posição de uma string em outra Trim Remove todos os espaços de uma string TrimLeft Remove os espaços à esquerda de uma string TrimRight Remove os espaços à direita de uma string Format Formatauma string com uma série de argumentos de vários tipos Por exemplo, para comparar o texto de dois Edits, poderíamos usar a função AnsiCompareText. if AnsiCompareText(EdtA.Text, EdtB.Text) = 0 then ShowMessage('O texto dos dois Edits são iguais.'); A função Format é especialmente útil na formatação de strings, veja alguns exemplos. ShowMessage(Format('O número %d é a parte inteira do número %f.', [10, 10.5])); ShowMessage(Format('Este texto%sfoi formatado%susando o caractere #%d.', [#13, #13, 13])); ShowMessage(Format('O preço do livro %s é %m.', ['Como Programar em Delphi', 50.7])); Um detalhe que deve ser observado é que as propriedades dos objetos não podem ser usadas como variáveis em funções. Veja a declaração do procedimento Delete no help. procedure Delete(var S: string; Index, Count:Integer); Digamos que você deseje apagar as 5 primeiras letras de um Edit, como a string do Delete é variável, não poderia usar o código abaixo. Delete(Edit1.Text, 1, 5); Para você poder fazer a operação desejada, teria que usar uma variável como variável auxiliar. var S: string; begin S := Edit1.Text; Delete(S, 1, 5); Edit1.Text := S; end; Tipos Ordinais Tipos ordinais são tipos que tem uma seqüência incremental, ou seja, você sempre pode dizer qual o próximo valor ou qual o valor anterior a um determinado valor desses tipos. São tipos ordinais o Char, Programação Delphi apoiando aplicativos de Bases de Dados 16 os tipos inteiros, o Boolean e os tipos enumerados. Algumas rotinas para ordinais são mostradas abaixo. Função Descrição Dec Decrementa variável ordinal Inc Incrementa variável ordinal Odd Testa se um ordinal é ímpar Pred Predecessor do ordinal Succ Sucessor do ordinal Ord Ordem de um valor na faixa de valores de um tipo ordinal Low Valor mais baixo na faixa de valores High Valor mais alto na faixa de valores Por exemplo, use o código abaixo no evento OnKeyPress de um Edit e veja o resultado. Inc(Key); Boolean Variáveis do tipo Boolean podem receber os valores lógicos True ou False, verdadeiro ou falso. Uma variável Boolean ocupa 1 byte de memória. TDateTime O tipo TDateTime guarda data e hora em uma estrutura interna igual ao tipo Double, onde a parte inteira é o número de dias desde 31/12/1899 e a parte decimal guarda a hora, minuto, segundo e milissegundo. As datas podem ser somadas ou subtraídas normalmente. Existem várias rotinas de manipulação de datas e horas, usadas com o tipo TDateTime, veja algumas a seguir. Rotina Descrição Date Retorna a data do sistema Now Retorna a data e hora do sistema Time Retorna a hora do sistema DayOfWeek Retorna o dia da semana de uma data especificada DecodeDate Decodifica um valor TDateTime em Words de dia, mês e ano DecodeTime Decodifica um valor TDateTime em Words de hora, minuto, segundo e milissegundos EncodeDate Retorna um TDateTime a partir de Words de dia, mês e ano EncodeTime Retorna um TDateTime a partir de Words de hora, minuto, segundo e milissegundos No help de cada uma das funções acima você vai encontrar alguns exemplos, veja os colocados abaixo. if DayOfWeek(Date) = 1 then ShowMessage('Hoje é Domingo, pé de cachimbo!') else ShowMessage('Hoje não é Domingo, pé de cachimbo!'); var A, M, D: Word; begin DecodeDate(Date, A, M, D); ShowMessage(Format('Dia %.2d do mês %.2d de %d.', [D, M, A])); end; Programação Delphi apoiando aplicativos de Bases de Dados 17 Variant Tipo genérico, que pode atribuir e receber valores de qualquer outro tipo. Evite usar variáveis do tipo Variant, pois o uso dessas variáveis pode prejudicar o desempenho do programa, além de diminuir a legibilidade do código fonte e a integridade do executável, veja o trecho de código abaixo e note como esse tipo de variável tem um comportamento estranho. var V1, V2, V3: Variant; begin V1 := True; V2 := 1234.5678; V3 := Date; ShowMessage(V1 + V2 + V3); end; 3.12 Conversões de Tipo Freqüentemente você vai precisar converter um tipo de dado em outro, como um número em uma string. Para essas conversões você pode usar duas técnicas, o TypeCasting e as rotinas de conversão de tipos. TypeCasting - é uma conversão direta de tipo, usando o identificador do tipo destino como se fosse uma função. Como o Delphi não faz nenhuma verificação se a conversão é válida, você deve tomar um certo cuidado ao usar um TypeCast para não criar programas instáveis. var I: Integer; C: Char; B: Boolean; begin I := Integer('A'); C := Char(48); B := Boolean(0); Application.MessageBox(PChar('Linguagem de Programação' + #13 + 'Delphi 3'), 'SENAC', MB_ICONEXCLAMATION); end; Rotinas de Conversão As principais rotinas de conversão estão listadas na tabela abaixo. Caso você tente usar uma dessas rotinas em uma conversão inválida, pode ser gerada uma exceção. Rotina Descrição Chr Byte em Char StrToInt String em Integer IntToStr Integer em String StrToIntDef String em Integer, com um valor default caso haja erro IntToHex Número em String Hexadecimal Round Arredonda um número real em um Integer Trunc Trunca um número real em um Integer StrToFloat String em Real FloatToStr Real em string FormatFloat Número real em string usando uma string de formato DateToStr TDateTime em string de data, de acordo com as opções do Painel de Controle StrToDate String de data em TDateTime TimeToStr TDateTime em Strind de Hora StrToTime String de hora em TDateTime DateTimeToStr TDateTime em string de data e hora StrToDateTime String de data e hora em TDateTime FormatDateTime TDateTime em string usando uma string de formato Programação Delphi apoiando aplicativos de Bases de Dados 18 VarCast Qualquer tipo em outro usando argumentos do tipo Variant VarAsType Variante em qualquer tipo Val String em número, real ou inteiro Str Número, real ou inteiro, em String Veja alguns exemplos de como usar essas rotinas. Conversão de dados é uma operação muito comum na programação em Object Pascal, seeria interessante dar uma olhada no help de cada uma das funções acima. var I: Integer; D: Double; S1, S2: string; begin D := 10.5; I := Trunc(D); S1 := FloatToStr(D); S2 := IntToStr(I); ShowMessage(S1 + #13 + S2); end; var A, B, Soma: Bouble; begin A := StrToFloat(EdtA.Text); B := StrToFloat(EdtB.Text); Soma := A + B; ShowMessage(Format('%f + %f = %f', [A, B, Soma]); end; 3.13 Expressões Uma expressão é qualquer combinação de operadores, variáveis, constantes, valores literais e chamadas de funções que resultem em um valor de determinado tipo. Uma expressão é usada sempre que precisamos de um valor que possa ser obtido por uma expressão. Alguns exemplos são apresentados a seguir. A + 12 * C Date - 4 StrToInt(Edit1.Text + Edit2.Text) StrToDate(Edit2.Text) - StrToDate(Edit1.Text) 12 * A / 100 A < B 3.14 Operadores Os operadores são usados em expressões e a ordem em que as expressões são executadas depende da precedência desses operadores. Veja abaixo a lista de operadores em ordem descendente de precedência. Operadores Unários @ Endereço not Não booleano ou bit voltado para não Operadores Multiplicativos e de direção de Bit * Multiplicação ou interseção de conjuntos / Divisão de Real div Divisão de Inteiro mod Resto de divisão de Inteiros as TypeCast seguro quanto ao tipo (RTTI) Programação Delphi apoiando aplicativos de Bases de Dados 19 and E booleano ou bit voltado para e shl Deslocamento de bits à esquerda shr Deslocamento de bits à direita Operadores Aditivos + Adição ou união de conjuntos - Subtração ou diferença de conjuntos or Ou booleano ou bit voltado para ou xor Ou exclusivo booleano ou bit voltado para ou exclusivo Operadores Relacionais = Igual <> Diferente < Menor > Maoir<= Menor ou igual >= Maior ou igual in Pertinência a conjuntos is Compatibilidade de tipos (RTTI) Para forçar uma expressão de menor precedência a ser executada antes, você pode usar os parênteses, como mostrado abaixo. (5 - 2) * 3; (A > B) and (A < C) Para fazer potenciação, use a função Power, abaixo temos que A é igual a A elevado a 4. A := Power(A, 4); 3.15 Estruturas de Decisão If - uma estrutura de decisão usada para realizar instruções em determinadas condições. O if é considerado uma só instrução, por isso, só encontramos o ponto-e-vírgula no final. O else é opcional. if Opn.Execute then Img.Picture.LoadFromFile(Opn.FileName); if Nota < 5 then ShowMessage('Reprovado') else ShowMessage('Aprovado'); Case - permite que o fluxo da execução seja desviado em função de várias condições de acordo com o valor do argumento, que tem que ser ordinal, caso o valor do argumento não corresponda a nenhum dos valores listados, podemos incluir um else. case Ch of ' ': ShowMessage('Espaço'); '0'..'9': ShowMessage('Dígito'); '+', '-', '*', '/': ShowMessage('Operador'); else ShowMessage('Caractere especial'); end; case CbbBorda.ItemIndex of 0: BorderStyle := bsDialog; 1: BorderStyle := bsSingle; 2: BorderStyle := bsSizeable; end; 3.16 Estruturas de Repetição While - executa uma instrução até que uma condição deixe de ser verdadeira. Programação Delphi apoiando aplicativos de Bases de Dados 20 I := 10; while I >= 0 do begin ShowMessage(IntToStr(I)); Dec(I); end; For - executa uma instrução um número determinado de vezes, incrementando uma variável de controle automaticamente a cada iteração. Caso seja preciso que a contagem seja decremental, pode-se usar downto em vez de to. for I := 1 to ComponentCount do ShowMessage('O ' + IntToStr(I) + 'º Componente é ' + Components[I - 1].Name); for I := Length(Edit1.Text) downto 1 do ShowMessage(Edit1.Text[I]); Repeat - executa instruções até que uma condição seja verdadeira. I := 1; repeat S := InputBox('Acesso', 'Digite a senha', ''); Inc(I); if I > 3 then Halt; until S = 'fluminense'; Quebras de Laço - em qualquer um dos laços mostrados podemos usar o procedimento Break para cancelar a repetição e sair do laço, podemos também forçar a próxima iteração com o procedimento Continue. I := 1; while true do begin Inc(I); if I < 10000000 then Continue; ShowMessage('Chegamos a dez milhões'); Break; end; 3.17 Tipos Definidos pelo Usuário O usuário também pode declarar tipos não definidos pelo Delphi. Essas declarações são feitas na seção type, da interface ou implementation, sendo que na implementation esses tipos não poderão ser usados em outras Units. Mas, de fato, dificilmente você terá que definir tipos, a não ser classes, pois os tipos padrão do Delphi são o bastante para a maioria das aplicações. Strings Limitadas - caso se deseje limitar o número de caracteres que uma string pode receber, podemos criar um tipo de string limitada. TNome = string[40]; TEstado = string[2]; Tipo Sub-Faixa - É um subconjunto de um tipo ordinal e possui as mesmas propriedades do tipo original. TMaiusculas = 'A'..'Z'; TMes = 1..12; Programação Delphi apoiando aplicativos de Bases de Dados 21 Enumerações - define uma seqüência de identificadores como valores válidos para o tipo. A cada elemento da lista de identificadores é associado internamente um número inteiro, iniciando pelo número 0, por isso são chamados de tipos enumerados. TBorderIcon = (biSystemMenu, biMinimize, biMaximize, biHelp); TDiaSemana = (Seg, Ter, Qua, Qui, Sex, Sab, Dom); Ponteiros - armazenam endereços de memória, todas as classes em Object Pascal são implementadas como ponteiros: TIntPtr: ^Integer; Quanto desejo o ponteiro de um outro objeto: TIntPtr := @Tvarnum; Quanto desejo manipular o objeto e não o ponteiro: showmessage ( IntToStr ( TIntPtr^ ) ); Records - o tipo record é uma forma de criar uma única estrutura com valores de diferentes tipos de dados. Cada um dos dados de um record é chamado de campo. TData = record Ano: Integer; Mes: TMes; Dia: Byte; end; var Festa: TData; begin Festa.Ano := 1997; Festa.Mes := Mai; Festa.Dia := 8; end; Arrays - Fornecem uma forma de criar variáveis que contenham múltiplos valores, como em uma lista ou tabela, cujos elementos são do mesmo tipo. A seguir, alguns exemplos de arrays de dimensões variadas. TTempDia = array [1..24] of Integer; TTempMes = array [1..31, 1..24] of Integer; TTempAno = array [1..12, 1..31, 1..24] of Integer; var TD: TTempDia; I: Integer; begin for I := 1 to 24 do TD[I] := StrToIntDef(InputBox('Temperaturas', 'Digite a temperatura na hora ' + IntToStr(I), ''), 30); end; Um array pode ser definido como constante tipada, onde todos os seus elementos devem ser inicializados. FAT: array[1..7] of Integer = (1, 2, 6, 24, 120, 720, 5040); O tipo dos elementos de um array pode ser qualquer um, você pode ter uma array de objetos, de conjuntos, de qualquer tipo que quiser, até mesmo um array de arrays. TTempMes = array [1..31] of TTempDia; TBtnList = array [1..10] of TButton; Sets - São conjuntos de dados de um mesmo tipo, sem ordem, como os conjuntos matemáticos. Conjuntos podem conter apenas valores ordinais, o menor que um elemento pode assumir é zero e o maior, 255. TBorderIcons = set of BorderIcon; Programação Delphi apoiando aplicativos de Bases de Dados 22 BorderIcons := [biSystemMenu, biMinimize]; if MesAtual in [Jul, Jan, Fev] then ShowMessage('Férias'); Os conjuntos podem ser definidos como constantes ou constantes tipadas, como abaixo. DIG_HEXA = ['0'..'9', 'A'..'Z', 'a'..'z']; DIG_HEXA: set of Char = ['0'..'9', 'A'..'Z', 'a'..'z']; 3.18 Procedimentos, Funções e Métodos As ações de um objeto devem ser definidas como métodos. Quando a ação não pertence a um objeto, como uma transformação de tipo, essa ação deve ser implementada em forma de procedimentos e/ou funções. Procedimentos São sub-rotinas, que realizam uma tarefa e não retornam um valor. A declaração de um procedimento é feita na seção interface e a definição, na seção implementation. Ao chamar o identificador do procedimento, com os parâmetros necessários, esse procedimento será executado. Veja abaixo o exemplo de uma unit com a implementação um procedimento. unit Tools; interface procedure ErrorMsg(const Msg: string); implementation uses Forms, Windows; procedure ErrorMsg(const Msg: string); begin Application.MessageBox(PChar(Msg), 'Operação inválida', MB_ICONERROR); end; end. Funções São muito semelhantes com procedimentos; a única diferença é que as funções retornam um valor. O tipo do valor de retorno deve ser informado no cabeçalho da função. Na implementação da função deve-se atribuir o valor de retorno à palavra reservada Result ou ao identificador da função. Pode-se então usar a função em expressões, atribuições, como parâmetros para outras funções, em qualquer lugar onde o seu valor possa ser usado. function Average(A, B: Double): Double; begin Result := (A + B) / 2; end; Métodos São funções ou procedimentos que pertencem a alguma classe, passando a fazer parte de qualquer objeto dessa classe. Na implementação de um método precisamos indicar qual a classe à qual ele pertence. Para chamar um método em algum lugar não pertencente à sua classe, como procedimentos, funções ou métodos de outras classes, deve ser indicado o objeto que deve executar o método. Os métodos usam os mesmos níveis de encapsulamento dos atributos. type TFrmMsg = class(TForm) LblMsg: TLabel; BtnOk: TButton; BtnCancelar: TButton; ImgMsg: TImage; publicProgramação Delphi apoiando aplicativos de Bases de Dados 23 procedure ShowMsg(const Msg: string); end; procedure TFormMsg.ShowMsg(const Msg: string); begin LblMsg.Caption := Msg; ShowModal; end; Parâmetros Existem três tipos de passagem de parâmetros, que devem ser indicados na declaração da função ou procedimento. Parâmetros de tipos diferentes de vem ser separados por ponto e vírgula. function MultiStr(const S: string; N: Double; var Erro: Integer): string; • Quando não é indicado o tipo de passagem, é passado o valor do parâmetro, como constante. • Ao usar a palavra-chave var não é enviado o valor do parâmetro, mas a referência a ele, tornando possível mudar o valor do parâmetro no código do procedimento. • Como alternativa você pode passar um parâmetro por referência constante, para isso use a palavra const antes da declaração do parâmetro. 3.19 With Usado para facilitar o acesso às propriedades e métodos de um objeto. with Edt do begin CharCase := ecUpperCase; MaxLenght := 10; PasswordChar := '*'; Text := 'Brasil'; end; 3.20 Self Self é usado quando se quer referenciar a instância atual da classe. Se você precisar referenciar a instância atual de uma classe, é preferível usar Self em vez de usar o identificador de um Objeto, isso faz com que o código continue funcionando para as demais instâncias da classe e em seus descendentes. 3.21 Criando e Destruindo Objetos Antes de tudo, você deve declarar o objeto, se quiser referenciá-lo. Para criá-lo, use o método Create, que é um método de classe. Para você usar um método de classe, referencie a classe, não o Objeto, como mostrado a seguir. var Btn: TBitBtn; begin Btn := TBitBtn.Create(Self); With Btn do begin Parent := Self; Kind := bkClose; Caption := '&Sair'; Left := Self.ClientWidth - Width - 8; Top := Self.ClientHeight - Height - 8; end; end; Programação Delphi apoiando aplicativos de Bases de Dados 24 Porém, se você não precisar referenciar o Objeto, poderia criar uma instância sem referência. with TBitBtn.Create(Self) do begin Parent := Self; Kind := bkClose; Caption := '&Sair'; Left := Self.ClientWidth - Width - 8; Top := Self.ClientHeight - Height - 8; end; Para destruir um objeto, use o método Free. Para Forms, é recomendado usar o Release, para que todos os eventos sejam chamados. O parâmetro do método Create é usado apenas em Componentes, para identificar o componente dono. Ao criar Forms, poderíamos usar o Objeto Application. FrmSobre := TFrmSobre.Create(Application); FrmSobre.ShowModal; FrmSobre.Release; Para criar objetos não componentes, você não precisa de nenhum parâmetro no método Create. var Lst: TStringList; begin Lst := TStringList.Create; Lst.Add('Alô, Teresinha!'); Lst.Add('Uhh uhh...'); Lst.SaveToFile('Teresinha.txt'); Lst.Free; end; 3.22 RTTI Run Time Type Information é a informação de tipo dos objetos em tempo de execução. O operador is é usado para fazer comparações e o operador as é usado para fazer um TypeCast seguro com objetos. for I := 0 to ComponentCount - 1 do if Components[I] is TEdit then TEdit(Components[I]).Clear; (Sender as TEdit).Color := clYellow; 3.23 Exceções O tratamento de exceção é um mecanismo capaz de dar robustez a uma aplicação, permitindo que os erros sejam manipulados de uma maneira consistente e fazendo com que a aplicação possa se recuperar de erros, se possível, ou finalizar a execução quando necessário, sem perda de dados ou recursos. Para que uma aplicação seja segura, seu código necessita reconhecer uma exceção quando esta ocorrer e responder adequadamente a essa exceção. Se não houver tratamento para uma exceção, será exibida uma mensagem padrão descrevendo o erro e todos os processamentos pendentes não serão executados. Uma exceção deve ser respondida sempre que houver perigo de perda de dados ou de recursos do sistema. Exceções são classes definidas pelo Delphi para o tratamento de erros. Quando uma exceção é criada, todos os procedimentos pendentes são cancelados e, geralmente é mostrada uma mensagem de erro para o usuário. As mensagens padrão nem sempre são claras, por isso é indicado criar seus próprios blocos protegidos. Programação Delphi apoiando aplicativos de Bases de Dados 25 Blocos Protegidos Um bloco protegido é um grupo de comandos com uma seção de tratamento de exceções. try A := StrToFloat(EdtA.Text); B := StrToFloat(EdtB.Text); ShowMessage(Format('%f / %f = %f', [A, B, A + B])); except ShowMessage('Números inválidos.'); end; Algumas vezes você pode precisar especificar quais exceções quer tratar, como mostrado abaixo. try Soma := StrToFloat(EdtSoma.Text); NumAlunos := StrToInt(EdtNum.Text); ShowMessage(Format('Média igual a %f.', [Soma / NumAlunos])); except on EConvertError do ShowMessage('Valor inválido para soma ou número de alunos.'); on EZeroDivide do ShowMessage('O número de alunos tem que ser maior que zero.'); else ShowMessage('Erro na operação, verifique os valores digitados.'); end; Principais Exceções O Delphi define muitas exceções, para cada erro existe uma exceção correspondente. Classe Descrição Exception Exceção genérica, usada apenas como ancestral de todas as outras exceções. EAbort Exceção silenciosa pode ser gerada pelo procedimento Abort e não mostra nenhuma mensagem. EAccessViolation Acesso inválido à memória, geralmente ocorre com objetos não inicializados. EConvertError Erro de conversão de tipos. EDivByZero Divisão de inteiro por zero. EInOutError Erro de Entrada ou de Saída reportado pelo sistema operacional. EIntOverFlow Resultado de um cálculo inteiro excedeu o limite. EInvalidCast TypeCast inválido com o operador as. EInvalidOp Operação inválida com número de ponto flutuante. EOutOfMemory Memória insuficiente. EOverflow O resultado de um cálculo, com número real, excedeu o limite. ERangeError Valor excede o limite do tipo inteiro ao qual foi atribuída. EUnderflow O resultado de um cálculo, com número real, é menor que a faixa válida. EVariantError Erro em operação com variant. EZeroDivide Divisão de real por zero. EDatabaseError Erro genérico de banco de dados, geralmente não é usado diretamente. EDBEngineError Erro da BDE, descende de EDatabaseError e traz dados que podem identificar o erro. Blocos de Finalização Blocos de finalização são executados sempre, haja ou não uma exceção. Geralmente os blocos de finalização são usados para liberar recursos. FrmSobre := TFrmSobre.Create(Application); try FrmSobre.Img.LoadFromFile('Delphi.bmp'); FrmSobre.ShowModal; finally FrmSobre.Release; end; Programação Delphi apoiando aplicativos de Bases de Dados 26 Você pode usar blocos de proteção e finalização aninhados FrmOptions := TFrmOptions.Create(Application); try FrmOptions.ShowModal; try Tbl.Edit; TblValor.AsString := EdtValor.Text; except on EDBEngineError do ShowMessage('Alteração não permitida.'); on EConvertError do ShowMessage('Valor inválido.'); end; finally FrmOptions.Release; end; Geração de Exceções Você pode provocar uma exceção usando a cláusula raise. raise EDatabaseError.Create('Erro ao alterar registro.'); Também é possível criar seus próprios tipos de exceções. type EInvalidUser = class (Exception); raise EInvalidUser.Create('Você não tem acesso a essa operação.'); Se você quiser que uma exceção continue ativa, mesmo depois de tratada, use a cláusula raise dentro do bloco de tratamento da exceção. Geralmente isso é feito com exceções aninhadas. try Tbl.Edit; TblContador.Value := TblContador.Value + 1; Tbl.Post; except ShowMessage('Erro ao alterar contador.'); raise; end;Erros de Bancos de Dados A exceção EDBEngineError permite a identificação de erros de bancos de dados gerados pela BDE (Borland Database Engine). try TblCli.Post; except on E: EDBEngineError do if E.Errors[0].ErrorCode = DBIERR_KEYVIOL then ShowMessage('Cliente já cadastrado.'); end; Note que a variável E, que vai identificar o erro, só precisa ser declarada no bloco de tratamento da exceção. No help você pode consultar outras propriedades de EDBEngineError que podem ser importantes. Você também pode usar os eventos de erro do componente Table, sem precisar de blocos de tratamento. procedure TFrmCadCli.TblCliPostError(DataSet: TDataSet; E: EDatabaseError; var Action: TDataAction); begin if(E is EDBEngineError) then with EDBEngineError(E) do Programação Delphi apoiando aplicativos de Bases de Dados 27 case Errors[0].ErrorCode of DBIERR_KEYVIOL: ShowMessage('Cliente já cadastrado.'); DBIERR_REQDERR: ShowMessage('Campo obrigatório não preenchido.'); end else ShowMessage('Erro no banco de dados:' + #13#13 + E.Message); Action := daAbort; end; Alguns códigos de erro da BDE estão listados abaixo. Todas as constantes e funções relacionadas à API da BDE no Delphi 3 estão na Unit BDE, que deve ser adicionada à cláusula uses. No BDE API Help você pode encontrar referência sobre as funções nativas da BDE, como também alguns exemplos em Delphi. Constante Descrição DBIERR_KEYVIOL Violação de chave primária DBIERR_MAXVALERR Valor máximo excedido DBIERR_FORIEGNKEYERR Erro de chave externa, como em integridade referencial DBIERR_LOCKED Registro travado DBIERR_FILELOCKED Arquivo travado DBIERR_NETMULTIPLE Mais de um diretório usado como NetFileDir DBIERR_MINVALERR Campo com valor mais baixo que valor mínimo DBIERR_REQDERR Campo obrigatório faltando DBIERR_LOOKUPTABLEERR Erro em tabela Lookup Se você quiser mais informações a respeito do erro pode usar o procedimento DBIGetErrorContext, como na função mostrada abaixo que retorna determinadas informações sobre o erro. function GetErrorInfo(Context: SmallInt): string; begin SetLength(Result, DBIMAXMSGLEN + 1); try DbiGetErrorContext(Context, PChar(Result)); SetLength(Result, StrLen(PChar(Result))); except Result := ''; end; end; No evento OnEditError, usado no exemplo abaixo, se ocorrer um erro ao tentar alterar um registro, podemos identificar o usuário da rede que está alterando esse registro usando a função criada anteriormente. if Pos('locked', E.Message) > 0 then ShowMessage('Usuário ''' + GetErrorInfo(ecUSERNAME) + ''' está alterando o registro.'); Note que foi usada uma outra técnica de identificação do erro, usando a própria mensagem de erro e não o código, como mostrado anteriormente. Você pode usar a função criada acima mandando como parâmetro os valores mostrados abaixo, que podem ser encontrados no help da BDE. Constante Descrição ecTABLENAME Nome da Tabela EcFIELDNAME Nome do campo EcUSERNAME Nome do usuário, muito usado para identificar qual usuário travou o registro EcFILENAME Nome do arquivo EcINDEXNAME Nome do índice EcDIRNAME Pasta EcKEYNAME Chave primária EcALIAS Alias EcDRIVENAME Drive Programação Delphi apoiando aplicativos de Bases de Dados 28 EcNATIVECODE Código de erro nativo EcNATIVEMSG Mensagem de erro nativa EcLINENUMBER Número da linha, usado em instruções SQL Para desenvolver um sistema genérico de tratamento de erros, considere a opção de criar esse tratamento em um DataModule genérico para ser usado como ancestral por todos os DataModules do sistema, utilizando a herança visual. Se o único problema for traduzir as mensagens, localize os arquivos CONSTS.INT e DBCONSTS.INT e crie uma nova Unit de definição de strings com uma estrutura semelhante a mostrada abaixo e juntando todas as definições das constantes das duas Units devidamente traduzidas. Depois, basta usar essa Unit em seus projetos que as novas mensagens irão sobrepor às anteriores. unit NewConsts; interface resourcestring SAssignError = 'Não é possível atribuir %s a %s'; SFCreateError = 'Não é possível criar arquivo %s'; SFOpenError = 'Não é possível abrir arquivo %s'; SInvalidFieldSize = 'Tamanho de campo inválido'; SInvalidFieldRegistration = 'Registro de campo inválido'; SUnknownFieldType = 'Campo ''%s'' tem um tipo desconhecido'; implementation end. Uma outra opção seria criar um método para o evento OnException do objeto Application, esse método seria chamado sempre que houvesse uma exceção em qualquer parte do sistema. 4 BIBLIOTECA DE CLASSES 4.1 Nomenclatura Para nomear os componentes podemos usar uma convenção muito usada, onde as primeiras letras, minúsculas, identificam o tipo do componente e o restante identifica a função deste, assim, btnSair, seria o botão de sair. Se a função do componente for um nome composto esse nome deve ser escrito com os primeiros nomes abreviados e com letras de caso variável, como em btnRelVendas, que seria o botão do relatório de vendas ou btnRelVenProduto, que seria o botão do relatório de vendas por produto. 4.2 Propriedades As propriedades são características dos componentes, como foi mostrado anteriormente. Para alterar propriedades em código use a sintaxe de ponto, como mostrado a seguir. Tipos de Propriedade • Tipo String Button1.Caption := 'Fechar'; Label1.Caption := Edit1.Text + '/' + Edit2.Text; • Tipo Numérico Button2.Height := Button2.Height * 2; Width := Button1.Width + Button2.Width + 12; • Tipo Enumerado BorderStyle := bsDialog; Programação Delphi apoiando aplicativos de Bases de Dados 29 Panel1.Color := clWindow; • Propriedades Aninhadas de Classe Memo1.Lines.Text := 'E agora, José?'; Label1.Font.Color := clBlue; • Propriedades Aninhadas de Conjunto BorderIcons := [biSystemMenu, biMaximize]; Label1.Font.Style := [fsBold, fsItalic]; Propriedades Comuns Propriedade Descrição Align Determina o alinhamento do componente Canvas Superfície de desenho, do tipo TCanvas, onde pode se desenhar a imagem do componente Caption Legenda do componente (& indica tecla de atalho para alguns componentes) Color Cor do componente ComponentCount O número de componentes possuídos Components Matriz de componentes possuídos Ctl3D Define a aparência 3D do componente Enabled Define se o componente está ativo, se pode ser usado Font Fonte utilizada no componente Height Altura HelpContext Número utilizado para chamar o Help on-line Hint String utilizada em dicas instantâneas Left Posição esquerda Name Nome do componente PopupMenu Menu de contexto do componente ShowHint Define se o Hint será mostrado TabOrder A ordem de tabulação do componente, usada quando o usuário tecla TAB TabStop Indica se o componente será selecionado quando o usuário teclar TAB Tag Propriedade não utilizada pelo Delphi, que pode ser usada como propriedade personalizada. Top Posição superior Visible Define se o componente está visível Width Largura 4.3 Eventos Os Eventos acontecem em resposta a uma ação do usuário ou do próprio sistema, ao programar um método de evento, devemos levar em consideração que este só será executados quando o evento acontecer. Uma das tarefas mais importantes na programação baseada em eventos é determinar quais eventos serão usados e qual a ordem desses eventos, por exemplo, quando o usuário clicar em um botão, qual evento acontecerá primeiro, OnEnter, OnMouseDown ou OnClick? Os eventos podem ser compartilhados entre componentes, dessa Forma, você pode ter um botão na barra de ferramentas que faz a mesma coisa que uma opção de menu. Para isso, basta escolher o evento na lista em vez de clicar duas vezes no Object Inspector. Podemos também mudar os métodos de evento em código, pois os eventos tambémsão propriedades e podem ser usados como tal. Você pode atribuir um evento de outro componente ou diretamente o nome do método, como mostrado abaixo. Button1.OnClick := Edit1.OnExit; Button2.OnClick := Edit2Click; Eventos Comuns Evento Descrição OnChange O conteúdo do componente é alterado OnClick O componente é acionado OnDblClick Duplo-clique no componente Programação Delphi apoiando aplicativos de Bases de Dados 30 OnEnter O componente recebe o foco OnExit O componente perde o foco OnKeyDown Tecla pressionada OnKeyPress Uma tecla é pressionada e solta OnKeyUp Tecla é solta 4.4 Métodos Os métodos realizam ações definidas pelo componente, veja os exemplos abaixo e atente para os parâmetros passados. Note que podemos chamar os métodos de evento como qualquer outro método e que os métodos de evento pertencem ao Form, não aos componentes. Edit1.Clear; Form2.Show; Close; ScaleBy(110, 100); Button1.ScrollBy(10, 10); Button1.OnClick(Sender); Button1Click(Self); Form2.Button1Click(Sender); Métodos Comuns Método Descrição Create Cria um novo Objeto de uma Classe Free Destrói um Objeto e libera a memória ocupada por ele Show Torna o componente visível Hide Torna o componente invisível SetFocus Coloca o foco no componente Focused Determina se o componente tem o foco BringToFront Coloca o componente na frente dos outros SendToBack Coloca o componente atrás dos outros ScrollBy Move o componente ScaleBy Gradua o componente em determina escala SetBounds Muda a posição e o tamanho do componente 4.5 Janelas Todo aplicativo Windows é composto por janelas, que são o elemento básico no desenvolvimento Delphi, sobre o qual um aplicativo é construído. O tipo TForm é usado no Delphi como classe base para todas as janelas, veja abaixo algumas propriedades, eventos e métodos dessa classe. Propriedade Descrição Active Indica se o Form está ativo ActiveControl Determina o controle que receberá o foco por default AutoScroll Adiciona barras de rolagem automaticamente, quando necessário BorderIcons Define quais ícones de controle serão visíveis, quais botões vão aparecer na barra de título BorderStyle Estilo da borda do Form FormStyle Tipo de Form, normal, MDI pai, MDI filho ou sempre visível Icon Ícone do Form Menu Indica qual o menu do Form Position Permite controlar a posição e tamanho do Form na exibição WindowMenu Automatiza o item de menu Window (MDI) WindowState Estado do Form, maximizada, minimizada ou normal Evento Descrição OnCreate Quando o Form é instanciado OnDestroy Quando o Form é liberado da memória OnShow Exatamente antes de mostrar o Form OnCloseQuery É chamada para validar se o Form pode ser fechado Programação Delphi apoiando aplicativos de Bases de Dados 31 OnClose Quando o Form é fechado OnActivate Quando o Form recebe o foco OnDeactivate Quando o Form perde o foco OnResize Quando o Form muda de tamanho Método Descrição Cascade Organiza as Forms filhos em cascata (MDI) Tile Organiza as Forms filhos lado a lado (MDI) ArrangeIcons Organiza os ícones dos Forms Filhos minimizados (MDI) ShowModal Ativa o Form modal, que o usuário tem que fechar para poder continuar a usar a aplicação Show Mostra o Form Close Fecha o Form Previous Ativa o Form anterior (MDI) Next Ativa a próximo Form (MDI) 4.6 Componentes Padrão Tbutton - Componente botão padrão do Windows, utilizado para executar ações. Propriedade Descrição Cancel Dispara o evento OnClick do botão quando a tecla ESC é pressionada em qualquer controle Default Dispara o evento OnClick do botão quando a tecla ENTER é pressionada em qualquer controle ModalResult Associa o botão a opção de fechamento de um Form modal Método Descrição Click Ativa o evento OnClick do botão TbitBtn - Botão especializado, com Bitmap. Propriedade Descrição Glyph Bitmap exibido pelo botão LayOut Posição do Bitmap no Botão Margin Indica o espaço entre a borda do botão e o Bitmap Spacing Indica o espaço entre o Bitmap e o texto do botão Kind Seleciona um tipo padrão para o botão, mudando várias propriedades, como Glyph e ModalResult TspeedButton - Botão com Bitmap, normalmente utilizado em barras de ferramentas. Propriedade Descrição Down Estado do botão (Pressionado ou não) GroupIndex Indica quais botões pertencerão ao mesmo grupo AllowAllUp Permite que todos os botões de um grupo possam ficar não pressionados Flat Define se a borda do botão deve aparecer apenas quando ele for apontado Tlabel - Utilizado para exibir rótulos Propriedade Descrição Alignment Alinhamento do texto no componente AutoSize Define se o tamanho do componente será automaticamente ajustado ao tamanho do Caption WordWrap Retorno automático de linha Transparent Define se o componente será transparente FocusControl Componente que receberá o foco quando a tecla de atalho do Caption (&) for pressionada ShowAccelChar Indica se o caractere & será usado para definir tecla de atalho Programação Delphi apoiando aplicativos de Bases de Dados 32 Tedit - Utilizado para entrada de texto em uma única linha. Propriedade Descrição Text Texto do componente AutoSelect Indica se o texto será ou não selecionado quando o componente receber o foco MaxLength Número máximo de caracteres permitidos CharCase Define se as letras aparecerão em maiúsculo, minúsculo ou normal PasswordChar Caractere utilizado para esconder o texto digitado (Senhas) ReadOnly Define se será permitido alterar o texto Método Descrição Clear Limpa o conteúdo do componente ClearSelection Limpa o texto selecionado no componente TmaskEdit - Permite entrada de dados texto em uma linha, utilizando uma máscara de edição. Possui todas as propriedades do componente TEdit. Propriedade Descrição EditMask Máscara de edição Máscaras - uma máscara é composta por três partes, a primeira parte é a máscara propriamente dita, a segunda parte indica se os caracteres literais serão salvos e a terceira parte indica qual o caractere utilizado para representar os espaços a serem digitados no texto. Estes são os caracteres especiais que podem compor a máscara de edição: Caractere Descrição ! Espaços em branco não serão considerados no texto > Todos os caracteres seguintes serão maiúsculos até que apareça o caractere < < Todos os caracteres seguintes serão minúsculos até que apareça o caractere > \ Indica um caractere literal l Somente caractere alfabético L Obrigatoriamente um caractere alfabético a Somente caractere alfanumérico A Obrigatoriamente caractere alfanumérico 9 Somente caractere numérico 0 Obrigatoriamente caractere numérico c Permite um caractere C Obrigatoriamente um caractere # Permite um caractere numérico ou sinal de mais ou de menos, mas não os requer. : Separador de horas, minutos e segundos / Separador de dias, meses e anos Tmemo - Permite entrada de dados texto em múltiplas linhas. Contém propriedades e métodos do TEdit. Propriedade Descrição Lines Propriedade do tipo TStrings que armazena as linhas de texto do componente WantReturns Define se a tecla ENTER será tratada como quebra de linha WantTabs Define se a tecla TAB será tratada como espaço de tabulação ScrollBar Define as barras de rolagem Tstrings - Muitos componentes, como o TMemo, possuem propriedades do Tipo TStrings, essa classe permite armazenar e manipular uma lista de Strings. Toda propriedade do tipo TStrings permite acesso indexado aos itens da lista. Propriedade Descrição Count Número de strings Text Conteúdo do memo na Forma de uma única string Método Descrição Programação Delphi apoiando aplicativos de Bases de Dados 33 Add Adiciona uma nova string no final da lista Insert Insere uma nova string
Compartilhar