programação em delph, Notas de estudo de Informática

Baixe programação em delph e outras Notas de estudo em PDF para Informática, somente na Docsity!

Delphi

Enviado por:

Aryanne da Costa

BORLAND DELPHI

®

ESCLARECIMENTOS

Parte desta apostila foi criada utilizando-se partes de apostilas encontradas na Internet. Qualquer problema, por favor, contatar o professor para correção.

Esta apostila foi elaborada com o propósito de servir de apoio ao curso e não pretende ser uma referência completa sobre o assunto. Para aprofundar conhecimentos, sugerimos consultar as seguintes obras:

1. Cantu, Marco, "Dominando o Delphi 7 – A Bíblia", São Paulo, Makron Books, 2003
2. Cortes, Pedro Luiz, “Trabalhando com Banco de Dados Utilizando o Delphi”, Érica, 2005

O curso parte do pressuposto que a pessoa é iniciante em Delphi, mas que conhece Lógica de Programação e possui conceitos básicos de POO.

EEdduuaarrddoo^ RRoossaalléémm^ MMaarrcceelliinnoo^ – –^ eerrmmaarrcc@@iitteelleeffoonniiccaa..ccoomm..bbrr

Ì ÌNNDDIICCEE

• ÌNDICE
• UM POUCO SOBRE DELPHI E PROGRAMAÇÃO PARA WINDOWS
• PRINCÍPIOS DA PROGRAMAÇÃO PARA WINDOWS.......................................................................................................
• COMPONENT PALETTE (PALETA DE COMPONENTES)...................................................................................................
• CONCEITO DE PROGRAMAÇÃO ORIENTADA A OBJETO..............................................................................................
  • ORIENTAÇÃO A OBJETO
  • EVOLUÇÃO DAS LINGUAGENS PARA OO
  • BENEFÍCIOS DA OOP
  • LINGUAGENS PROCEDURAIS X ORIENTADA A OBJETOS :......................................................................................
  • ALGUNS EXEMPLOS DE LINGUAGENS PROCEDURAIS COM EXTENSÕES OO:...........................................................
  • LINGUAGENS COMPILADAS X INTERPRETADAS :
• EVENTOS, MÉTODOS E PROPRIEDADES
  • EVENTOS
  • PROPRIEDADES...................................................................................................................................................
  • MÉTODOS
• OBJECT PASCAL
  • PALAVRAS RESERVADAS
  • VARIÁVEIS
  • ARRAYS (VETORES).............................................................................................................................................
  • RECORDS (REGISTROS).......................................................................................................................................
• PRINCIPAIS TECLAS DE ATALHO DA IDE DO DELPHI
• COMO É FORMADA UMA APLICAÇÃO EM DELPHI
  • ARQUIVOS QUE COMPÕE UMA APLICAÇÃO DELPHI...............................................................................................
  • ARQUIVOS GERADOS NO DESENVOLVIMENTO......................................................................................................
  • ARQUIVOS GERADOS PELA COMPILAÇÃO
  • CÓDIGO FONTE DO ARQUIVO PROJECT(.DPR)......................................................................................................
  • ESTRUTURA DA UNIT DE UM FORM (.PAS)
• O PARÂMETRO “SENDER” E OS OPERADORES “IS” E “AS”
  • O OPERADOR “IS”
  • O OPERADOR “AS"...............................................................................................................................................
  • O PARÂMETRO SENDER
  • UM EXEMPLO COMPLETO COM OS OPERADORES “AS” E “IS”................................................................................
• EVENTOS MAIS UTILIZADOS NO DELPHI:
  • ONCREATE
  • ONKEYPRESS
  • ONKEYDOWN
  • ONCLICK
  • ONDESTROY
  • ONDBLCLICK
  • ONMOUSEMOVE
  • ONENTER............................................................................................................................................................
  • ONEXIT...............................................................................................................................................................
  • ASSOCIANDO UM PROCEDIMENTO À UM EVENTO EM TEMPO DE EXECUÇÃO
• A CLASSE TWINCONTROL
  • PRINCIPAIS PROPRIEDADES
  • PRINCIPAIS MÉTODOS
• ALGUNS COMPONENTES VISUAIS DO DELPHI
  • PRINCIPAIS EVENTOS DO FORMULÁRIO...............................................................................................................
  • PALHETA STANDARD
• MANIPULANDO DATA E HORA NO DELPHI
• APLICAÇÕES ROBUSTAS - TRATAMENTO DE EXCEÇÕES
  • EXCEÇÕES...........................................................................................................................................................
  • BLOCOS PROTEGIDOS
  • PRINCIPAIS EXCEÇÕES
  • BLOCOS DE FINALIZAÇÃO....................................................................................................................................
  • GERAÇÃO DE EXCEÇÕES......................................................................................................................................
  • EXIBINDO O ERRO GERADO PELA EXCEÇÃO
  • EXCEÇÕES SILENCIOSAS
  • MANIPULANDO EXCEÇÕES GLOBAIS.....................................................................................................................
  • ENTENDENDO UM POUCO SOBRE O QUE É UM GPF
  • CONFIGURANDO O DELPHI PARA NÃO “PARAR” EM EXCEÇÕES
  • CONCLUSÃO:
• ARQUIVOS INI.........................................................................................................................................................
• CRIANDO UMA BIBLIOTECA DE PROCEDURES, FUNÇÕES, ETC.
• TRABALHANDO COM FORMULÁRIOS
• PRINCIPAIS TECNOLOGIAS DE ACESSO A DADOS
  • BDE (BORLAND DATABASE ENGINE):
  • DBEXPRESS (DBX):
  • ADO (ACTIVEX DATA OBJECTS):
  • "INTERBASE EXPRESS">INTERBASE EXPRESS (IBX):.............................................................................................
• CONFIGURANDO UMA CONEXÃO COM BD USANDO ADO NO BORLAND DELPHI
• CRIANDO UM CADASTRO SIMPLES (APENAS 1 TABELA)
• VALIDANDO OS DADOS DO CADASTRO
• CRIANDO UM CADASTRO COM MAIS DE UMA TABELA (FK)
• SUGERINDO UM CÓDIGO AUTOMATICAMENTE
• SOLICITANDO UM DADO AO USUÁRIO (INPUTBOX)..................................................................................................
• CADASTROS SEM O TDBNAVIGATOR
• UMA TELA CRIADA SEM O TDBNAVIGATOR
• CONSTRUINDO UMA TELA DE CONSULTA
  • PASSANDO PARÂMETROS PARA O OBJETO ADOQUERY
• DATAMODULE
• CONTINUANDO COM A CONSTRUÇÃO DA TELA DE CONSULTA
  • O MÉTODO LOCATE DA CLASSE TDATASET
• VERIFICANDO SE UM REGISTRO EXISTE EM UMA TABELA.........................................................................................
• EXIBINDO OS ERROS EM UMA TELA SEPARADA
• TRABALHANDO COM VETORES DINÂMICOS..............................................................................................................
• TRANSAÇÕES
• FILTRANDO DADOS DE UMA TABELA........................................................................................................................
• FRAMES
• OBJETO TFIELD.......................................................................................................................................................
  • ACESSANDO OS DADOS DE UM TFIELD:
• FIELDS EDITOR
• VALIDANDO ATRAVÉS DO EVENTO ONVALIDADE DOS OBJETOS TFIELD....................................................................
• CAMPOS CALCULADOS.............................................................................................................................................
• CAMPOS LOOKUP
• O EVENTO ONGETTEXT
• O EVENTO ONSETTEXT............................................................................................................................................
• TABELAS TEMPORÁRIAS COM O TCLIENTDATASET
• FORMULÁRIOS PADRÕES
• CRIANDO UM CADASTRO MASTER - DETAIL
• APÊNDICE - FUNÇÕES PARA TRABALHAR COM STRINGS (RETIRADAS DO HELP DO DELPHI 7) ..................................
• APÊNDICE - OBJECT PASCAL: ESTRUTURAS BÁSICAS...............................................................................................
• APÊNDICE - RELAÇÕES ENTRE CLASSES ..................................................................................................................
• APÊNDICE - DESCRIÇÃO DOS PRINCIPAIS PROCEDIMENTOS E FUNÇÕES PRÉ DEFINIDAS.........................................
• APÊNDICE - TECNOLOGIAS APLICÁVEIS AO DELPHI 7..............................................................................................

Possui um compilador extremamente rápido, que gera executáveis nativos (em código de máquina, não interpretado), obtendo assim melhor performance e total proteção do código fonte.

O Delphi é extensível, sua IDE ( Integrated Development Environment – Ambiente de Desenvolvimento Integrado ) pode ser ampliada e personalizada com a adição de componentes e ferramentas criadas utilizando-se o Object Pascal, a linguagem de programação do Delphi. Neste ambiente constroem-se as janelas das aplicações de maneira visual, ou seja, arrastando e soltando componentes que irão compor a interface com o usuário.

O Object Pascal é uma poderosa linguagem Orientada a Objeto, que além de possuir as características tradicionais das mesmas como classes e objetos, também possui interfaces (semelhantes às encontradas em COM e Java), tratamento de exceção, programação multithreaded e algumas características não encontradas nem mesmo em C++, como RTTI (Runtime Type Information). Assim como o C++, o Object Pascal é uma linguagem híbrida, pois além da orientação a objeto possui também uma parte da antiga linguagem estruturada (Pascal)

Devido ao projeto inicial da arquitetura interna do Delphi e da orientação a objeto, suas características básicas mantêm-se as mesmas desde o seu lançamento em 1995 (ainda para o Windows 3.1, pois o Windows 95 ainda não havia sido lançado), o que demonstra um profundo respeito com o desenvolvedor. Isto permite que uma aplicação seja facilmente portada de uma versão anterior para uma nova, simplesmente recompilando-se o código fonte.

Obs: Embora as características, teorias e exemplos abordados aqui sejam sobre o Delphi 2005 (última versão disponível), tudo pode ser aplicado em versões anteriores do Delphi, excetuando-se o caso da utilização de componentes e ferramentas introduzidos apenas nesta versão.

P PRRIINNCCÍÍPPIIOOSS DDAA PPRROOGGRRAAMMAAÇÇÃÃOO PPAARRAA WWIINNDDOOWWSS

Antes de começar a trabalhar com o Delphi, é importante ter algumas noções do que está envolvido na programação Windows e no Delphi em particular. Algumas coisas tornam a tarefa de programação no Windows (e ambientes baseados em eventos e interface gráfica) bem diferente de outros ambientes e das técnicas de programação estruturada normalmente ensinadas nos cursos de lógica de programação:

Independência do Hardware : No Windows, o acesso aos dispositivos de hardware é feito com intermédio de drivers fornecidos pelo fabricante do hardware, o que evita que o programador tenha que se preocupar com detalhes específicos do hardware. Como acontecia com a programação em DOS.

Configuração Padrão : O Windows armazena centralmente as configurações de formato de números, moeda, datas e horas, além da configuração de cores, livrando o programador de se preocupar com esses detalhes específicos.

Multitarefa : Antigamente, no DOS (não estamos falando do Prompt do MS-DOS), um programa geralmente tomava o controle da máquina só para si, e outros programas não rodavam até que o mesmo fosse fechado. Já no Windows vários programas são executados de maneira simultânea e não há como evitar isso.

Controle da Tela : No DOS geralmente um programa ocupa todo o espaço da tela, e o usuário via e interagia apenas com aquele programa. Já no Windows, todas as informações mostradas e todas as entradas recebidas do usuário são feitas por meio de uma janela , uma área separada da tela que pode ser sobreposta por outras janelas do mesmo ou de outros programas.

Padrões de Interface : No Windows, todos os elementos de interface aparecem para o usuário e interagem da mesma forma. Além disso, existem padrões definidos pela Microsoft que são recomendados para conseguir a consistência entre aplicativos. Falaremos de alguns deles no curso, mas a melhor forma de aprendê-los é analisar os aplicativos Windows mais usados do mercado.

Eventos e a Cooperação com o Sistema : Num programa criado para DOS (como os programas escritos em Clipper) ele é responsável pelo fluxo de processamento, temos que definir claramente não só que instruções, mas também em que ordem devem ser executadas, ou seja a execução segue uma ordem preestabelecida pelo programador, e o programa só chama o sistema operacional quando precisa de alguma coisa dele. Em Windows não é bem assim. Nosso programa não controla o fluxo de processamento, ele responde e trata eventos que ocorrem no sistema.

Existem muitos eventos que podem ocorrer, sendo que os principais são aqueles gerados pelo usuário através do mouse e do teclado. A coisa acontece mais ou menos assim: O usuário clica o mouse e o Windows verifica que aplicação estava debaixo do mouse no momento em que foi clicado. Em seguida ele manda uma mensagem para a aplicação informando que ocorreu um clique e as coordenadas do cursor do mouse na tela no momento do clique. A aplicação então responde à mensagem executando uma função de acordo com a posição do mouse na tela.

É claro que o Delphi toma conta do serviço mais pesado e facilita muito as coisas para o programador. Detalhes como as coordenadas da tela em que ocorreu o clique, embora estejam disponíveis, dificilmente são necessários nos programas.

Isso, como veremos, afeta radicalmente o estilo de programação e a forma de pensar no programa. A seqüência de execução do programa depende da seqüência de eventos.

C COOMMPPOONNEENNTT PPAALLEETTTTEE ((PPAALLEETTAA DDEE CCOOMMPPOONNEENNTTEESS))

Cada ícone na paleta refere-se a um componente que, quando colocado em um Form, executa determinada tarefa: por exemplo, um TLabel mostra um texto estático, e um TEdit é uma caixa de edição que permite mostrar e alterar dados, o TComboBox é uma caixa que permite selecionar um dentre os itens de uma lista, etc.

A paleta de componentes tem diversas guias, nas quais os componentes são agrupados por funcionalidade. Outras guias podem ser criadas com a instalação de componentes de terceiros.

Segue abaixo algumas das principais paletas do Delphi. As imagens foram tiradas do Delphi 6, onde a paleta era na horizontal.

assim, não permite acesso a dBase, Paradox ou Access para estes você deverá continuar a utilizar o BDE.

BDE : componentes de acesso a dados utilizando a BDE (até o Delphi 5 faziam parte da guia Data Access). A BDE é a engine que acompanha o Delphi desde sua primeira versão. Muito completa, permite acessar desde bases de dados desktop, como Paradox, dBase ou Access, até bases de dados SGDB, como Interbase, DB/2, Oracle, Informix, SyBase ou MS-SQL Server, todos em modo nativo. Permite ainda o acesso a outros bancos de dados através de ODBC.

DBGO : componentes de acesso a dados da interface dbGo (introduzida no Delphi 5 como o nome de ADO Express) através da tecnologia ADO (ActiveX Data Objects), da Microsoft. Tanto a ADO como o OLE DB (drivers de acesso) estão incluídos no MDAC (Microsoft Data Access Components) e permitem acesso a uma série de bancos de dados e à ODBC. Sua principal vantagem é estar incorporada as versões mais recentes do Windows (2000/XP e ME) não sendo necessário nenhuma instalação de engine de acesso. Também é escalável, permitindo acesso desde bases de dados desktop até aplicações multicamadas. A desvantagem é que não é portável para outras plataformas, caso queira portar seu sistema para Linux, terá que trocar todos os componentes de acesso a dados.

Interbase : componentes para acesso nativo ao Interbase, através de sua API, constituindo o método de acesso mais rápido e eficiente para este banco de dados. Por não ser uma interface genérica permite utilizar todos os recursos que o Interbase disponibiliza. A desvantagem, no entanto é que ao utiliza-los perde-se a possibilidade de alterar o banco de dados sem mudar o programa, visto que os mesmos se destinam apenas ao Interbase.

WebServices : componentes que formam a BizSnap, uma plataforma RAD para desenvolvimento de Web services, que simplifica a integração B2B criando conexões e Web services baseados em XML/SOAP

InternetExpress : componentes para manipulação de XML e produção de páginas para internet.

Internet : componentes para manipulação de Sockets, páginas e web browser.

DataSnap : componentes que permitem a criação de middleware de alto desempenho capazes de trabalhar com Web services, possibilitando fácil conexão de qualquer serviço ou aplicação de cliente com os principais bancos de dados, como Oracle, MS-SQL Server, Informix, IBM, DB2, Sybase e InterBase, através de Serviços Web padrão da indústria e XML, DCOM ou CORBA. (No Delphi 5 esta guia era chamada de Midas).

WebSnap : componentes para o desenvolvimento de aplicações Web que suporta os principais Servidores de Aplicações Web, inclusive Apache, Netscape e Microsoft Internet Information Services (IIS);.

FastNet : componentes para manipulação de protocolos e serviços da internet como http, nntp, ftp, pop3 e smtp entre outros. (São mantidos por compatibilidade com o Delphi 5, nesta versão foram inseridos os componentes Indy com maior funcionalidade).

Decision Cube : componentes para tomada de decisão através da análise multidimensional de dados, com capacidades de tabulação cruzada, criação de tabelas e gráficos. Estes componentes permitem a obtenção de resultados como os obtidos por ferramentas OLAP (On-Line Analytical Processing – Processamento Analítico On-Line) utilizados para análise de Data Warehouses.

Qreport : QuickReport é um gerador de relatórios que acompanha o Delphi e se integra totalmente ao mesmo, sem a necessidade de run-time ou ferramentas externas como o Cristal Report, etc. Estes componentes permitem a criação de diversos tipos de relatórios de forma visual e também a criação de preview personalizado.

Dialogs : O Windows tem caixas de diálogo comuns, como veremos, que facilitam mostrar uma interface padrão dentro do seu programa para as tarefas comuns, como abrir e salvar arquivos, impressão, configuração de cores e fontes etc. Esta guia tem componentes que permitem utilizar essas caixas de diálogo comuns.

Servers : componentes para automatização do Microsoft Office, permitindo o controle, impressão e criação de documentos destes aplicativos dentro do seu programa.

CCOONNCCEEIITTOO DDEE PPRROOGGRRAAMMAAÇÇÃÃOO OORRIIEENNTTAADDAA AA OOBBJJEETTOO

Para compreendermos melhor a novo ambiente de desenvolvimento do Borland o Delphi é necessário que você aprenda e tenha em mente os conceitos de POO ( Programação Orientada a Objetos ) e não confunda os conceitos com POE ( Programação Orientada a Eventos ) muito difundido com o Access 2.0 ©^ (um ambiente baseado em Objetos). A longo deste capítulo você vai notar as sensíveis diferenças que existem entre esses dois conceitos.

A POO e a POE são facilmente confundidas, mas lembre-se a POO contém a POE mas a POE não contém a POO. Um objeto pode existir mesmo que não exista nenhum evento associado a ele, mas um evento não pode existir se não houver um objeto a ele associado. Outra característica que pode causar confusão são os ambientes Orientados a Objetos e ambientes Baseados em Objetos. Em ambiente Orientado a Objetos consegue-se criar e manipular objetos enquanto que o Baseado em Objetos não é possivel a criação de objetos apenas a sua manipulação.

A POO é um conceito desenvolvido para facilitar o uso de códigos de desenvolvimento em interfaces gráficas. Sendo a Borland , uma das primeiras a entrar neste novo conceito, possui suas principais linguagens de programação (tais como Object Pascal e C++ ), totalmente voltadas para este tipo de programação. A POO atraiu muitos adeptos principalmente pelo pouco uso de código que o projeto (diferente de sistema) carrega no programa fonte, ao contrário das linguagens mais antigas como o Clipper’87 ©^ muito utilizado no final da década de 80 e início da década de 90. O resultado desta “limpeza” no código resulta que a manutenção do projeto torna-se muito mais simples.

Por ser baseado no Pascal Object, o Delphi permite que se construa aplicações orientadas a objetos. Em linhas gerais, aplicações orientadas a objetos se baseiam no conceito de classe. A classe é um tipo de dado, contendo atributos e serviços. O objeto é uma variável de determinada classe. Por exemplo, um formulário nada mais é do que um objeto da classe Formulário (Tform).

OORRIIEENNTTAAÇÇÃÃOO AA OOBBJJEETTOO

Antes de começarmos a falar realmente de linguagem orientada a objetos e necessário que você possua os conceitos básicos da orientação a objetos, são eles:

Classe - A modelagem de um conceito do mundo real. As propriedades associadas ao conceito são representadas por atributos (variáveis) e operações (i.e. funções). Uma classe descreve os atributos que seus objetos vão ter e as funções que podem executar. (i.e. a classe das Janelas descreve o tamanho, formato, funcionalidades, etc. de uma Janela)

Por exemplo, no domínio universitário os conceitos de professores, aulas, alunos, poderiam ser representados por classes.

Objeto - é qualquer estrutura modular que faz parte de um produto. Uma janela por exemplo, é um objeto de uma casa, de um carro ou de um software com interface gráfica para o usuário.

Cada objeto pertence a uma classe. A estrutura do objeto como as operações que ele pode executar são descritas pela classe.

Objetos são entidades independentes uns dos outros. Dois objetos com exatamente os mesmos atributos são dois objetos diferentes. Na informática, se pode pensar na memória de um computador: dois objetos com os mesmos atributos, estão em diferentes partes da memória, na verdade eles tem um atributo implícito (o endereço na memória onde eles ficam) que é diferente.

Instância - Um objeto. Por exemplo, uma casa pode possuir várias instâncias da classe janela.

Propriedades - São as características do objeto, como cor e tamanho, a janela, por exemplo, tem atributos como o modelo, tamanho, abertura simples ou dupla, entre outros.

Encapsulação - é um mecanismo interno do objeto “escondido” do usuário. Uma pessoa pode abrir uma janela girando a tranca sem precisar saber o que há dentro dela.

Herança - um objeto novo nem sempre é criado do zero. Ele pode “herdar” atributos e ações de outros já existentes. Uma janela basculante herda atributos das janelas e das persianas.

Mais formalmente, Herança é a modelagem da noção de especialização/generalização. No mundo real, conceitos são especializações uns dos outros: um professor visitante é um caso especial de professor; um professor, um aluno são seres humanos; um ser humano é um animal, ...Os conceitos mais especiais têm todas as propriedades dos conceitos mais gerais, mais algumas propriedades em si próprio.

Na POO, uma sub-classe possui todos os atributos e todas as operações da super-classe. A sub- classe pode acrescentar alguns atributos e métodos. Ela pode também redefinir, dentro de alguns limites, alguns métodos da super-classe. Ela não pode tirar nenhuma propriedade da super-classe.

Polimorfismo - O poliformismo é um recurso das linguagens orientadas a objetos, que literalmente indica a capacidade de um objeto assumir várias formas. Em outras palavras, o poliformismo permite que você referencie propriedades e métodos de classes diferentes por meio de um mesmo objeto. Ele também possibilita que você execute operações com esse objeto de diferentes maneiras, de acordo com o tipo de dado e com a classe atualmente associada a esse objeto. O comando “abre”, por exemplo, faz um objeto entrar em ação, seja ele uma janela, uma porta ou uma tampa de garrafa.

Várias classes podem implementar a mesma operação de maneira diferente. A mesma operação (com o mesmo nome) tem várias ("poli") formas ("morfismo") em cada classe. Uma característica poderosa do modelo a objetos é que todas as formas de uma operação podem ter o mesmo nome. Assim se torna mais fácil de reconhecer qual operação um método particular implementa. Isso é possível porque cada objeto sabe qual é sua própria classe, e pode executar os métodos apropriados.

e manipulação dos dados vêm depois. A linguagem OO é projetada para permitir a definição dos objetos que compõe os programas e as propriedades que estes objetos contem. O código é secundário. Pode-se programar na forma procedural com estilo OO quando o programa tem um nível tal de sofisticação que você começa a criar seus próprios tipos e estruturas de dados. A linguagem OO pura tem como um parâmetro de referência que todos os dados sejam representados na forma de objetos. A única pura é a Small Talk (tudo via classe, não tem var. global). Eiffel também.

AALLGGUUNNSS^ EEXXEEMMPPLLOOSS^ DDEE^ LLIINNGGUUAAGGEENNSS^ PPRROOCCEEDDUURRAAIISS^ CCOOMM^ EEXXTTEENNSSÕÕEESS^ OOOO::

C++, PASCAL do ambiente DELPHI, PERL, OBJECTIVE C

O JAVA implementa tipos simples de dados (integer, real, char) do C, não sendo objetos mas tudo o mais lida com objetos. O código e os dados residem em classes e objetos.

LLIINNGGUUAAGGEENNSS^ CCOOMMPPIILLAADDAASS^ XX^ IINNTTEERRPPRREETTAADDAASS^ ::

Linguagem Compilada - código gerado tem alta performance pois é ajustado para um tipo específico de processador. Código Objeto em binário para aquele processador. Ex. Pascal (entenda- se também no Delphi).

Linguagem Interpretada - só existe em código fonte. Durante a execução o interpretador pega o fonte e vai executando as ações. Facilita o uso em múltiplas plataformas. Ex. Clipper

Um caso de linguagem Compilada/Interpretada é o Java. O Java edita o fonte e salva como código fonte, depois compila o fonte produzindo arquivo binário chamado arquivo de classe que não é executável direto. Este código intermediário chama-se bytecode que são instruções de máquina mas para um processador virtual (o JVM Java Virtual Machine). Por fim o interpretador Java implementa em software executando os arquivos de classe.

A OO tem a filosofia de implementar uma abstração do mundo real facilitando a reutilização de código, denominado de caixas pretas de softwares ou ainda softwares IC's. (Integrated Circuits) que estã sendo utilizado aqui como uma analogia de chip com objeto.

EEVVEENNTTOOSS,,^ MMÉÉTTOODDOOSS^ EE^ PPRROOPPRRIIEEDDAADDEESS

EEVVEENNTTOOSS

Os programas feitos em Delphi são orientados a eventos. Eventos são ações normalmente geradas pelo usuário e que podem ser reconhecidas e tradadas pelo programa. Ex.: Clicar o mouse pressionar uma tecla, mover o mouse etc. Os eventos podem ser também gerados pelo windows.

Existem eventos associados ao formulário e cada componente inserido neste. Exemplos:

• Ao formulário está ligado on show , que ocorre quando mostramos o formulário na tela.
• Ao componente botão está ligado o evento on click, que ocorre quando damos um click com o mouse sobre o botão.

Eventos comuns ao formulário e aos componentes.

Alguns eventos ligados tanto ao formulário quanto aos componentes estão listados a seguir.

• OnClick: ocorre quando o usuário clica o objeto.
• OndblClick: ocorre quando o usuário da 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 da um clique numa tecla ANSI.
• 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.

Rotinas que Respondem a Eventos

Cada evento gera uma procedure, aonde você deve inserir as linhas de código que envolvem este evento. Por exemplo, o evento OnClick, que é gerado ao clicarmos em um botão chamado BTNSair, cria a procedure:

Procedure TForm1.BTNSairClick(Sender: Tobject);

onde Tform1 é o objeto Tform que contém o botão BTNSair, e Sender é um objeto Tobject que representa o componente que deu origem ao evento. Se você quiser inserir uma rotina que trate um determinado evento de um componente, faça o seguinte:

• clique sobre o componente;
• no Object Inspector, seleciona a página Events;
• dê um duplo clique sobre o evento para o qual quer inserir o código;
• entre no editor de código e escreva as linhas de código.

Exemplo:

Procedure TForm1.BTNSairClick(Sender: Tobject); begin Form1.Close; end;

Obs.: Escreva seu código entre o begin e o end, se por acaso você quiser retirar o evento e o componente, retire primeiro os eventos do componente removendo somente o código que você colocou e depois o componente; os resto dos procedimentos o DELPHI tira para você.

PPRROOPPRRIIEEDDAADDEESS

Uma propriedade representa um atributo de um objeto. No Dellphi todas as coisas que aparecem no Object Inspector são propriedades, inclusive os eventos, porém sua referência é a um método. Como vimos, eventos podem estar associados a modificações em propriedade de componente e formulário, ou seja, você pode modificar propriedades de formulários e componentes durante a execução do sistema. Para isto você deverá usar a sintaxe:

.;

linguagens a Object Pascal providência uma migração de forma natural oferecendo um produto de maior complexibilidade. Object Pascal força a você executar passos lógicos isto torna mais fácil o desenvolvimento no ambiente Windows ©^ de aplicações livres ou que utilizam banco de dados do tipo Cliente/Servidor , trabalha com o uso de ponteiros para a alocação de memória e todo o poder de um código totalmente compilável. Além disso possibilita a criação e reutilização (vantagem de re-uso tão sonhado com a Orientação a Objetos ) de objetos e bibliotecas dinâmicas ( Dynamic Link Libraries - DLL).

Object Pascal contém todo o conceito da orientação a objetos incluindo encapsulamento, herança e polimorfismo. Algumas extensões foram incluídas para facilitar o uso tais como conceitos de propriedades, particulares e públicas, e tipos de informações em modo run-time, manuseamento de exceções, e referências de classes. O resultado de toda esta junção faz com que Object Pascal consiga suportar as facilidades de um baixo nível de programação, tais como:

• Controle e acesso das subclasses do Windows ©^ (API);
• Passar por cima das mensagens de loop do Windows ©;
• Mensagens semelhantes as do Windows ©;
• Código puro da linguagem Assembler. Como deu para perceber a base de toda a programação Delphi é a linguagem Object Pascal , então neste capítulo trataremos exclusivamente deste tipo de programação.

Símbolos Especiais

A Object Pascal aceita os seguintes caracteres ASCII:

 Letras - do Alfabeto Inglês: A até Z e a até z.

 Dígitos - Decimal: 0 até 9 e HexaDecimal: 0 até 9 e A até F (ou a até f )

 Brancos - Espaço ( ASCII 32 ) e todos os caracteres de controle ASCII ( ASCII 0 até

ASCII 31 ), incluindo final de linha e Enter ( ASCII 13 ).

 Especiais - Caracteres: + - * / = < > [ ]. , ( ) : ; ^ @ { } $

 Símbolos - Caracteres: <= >= := .. (* *) (. .) //

+O colchetes esquerdo ( [ ) e equivalente ao (. e o colchetes direito ( ] ) e equivalente a .). A chave esquerda ( { ) e equivalente ao (* e a chave direita ( } ) e equivalente a *).

PPAALLAAVVRRAASS^ RREESSEERRVVAADDAASS

A Object Pascal se utiliza das seguintes palavras reservadas, não podendo as mesmas serem utilizadas ou redefinidas:

And Exports Library Set Array File Mod Shl As Finnaly Nil Shr Asm For Not String Begin Function Object Then Case Goto Of To Class If On Try Const Implementation Or Type Constructor In Packed Unit Destructor Inherited Procedure Until

Div Initialization Program Uses Do Inline Property Var Downto Interface Raise While Else Is Record With End Label Repeat Xor Except

VVAARRIIÁÁVVEEIISS

Nossos dados são armazenados na memória do computador. Para que nós não tenhamos que nos referir a estes dados de forma direta, através de um endereço numérico difícil de memorizar, o compilador nos permite utilizar variáveis com esta finalidade. Escolhendo nomes sugestivos (mnemônicos) para nossas variáveis (tais como nome, funcao, idade, salario ) facilitamos bastante a compreensão de nosso código. Para que o Delphi possa usar nossas variáveis, devemos primeiro declará-las, isto é, informar o nome e o tipo desejados. Por exemplo : o comando a seguir declara idade como sendo uma variável do tipo inteiro ( integer) : idade : integer; As variáveis inteiras podem assumir valores entre -32768 e +32767. Elas ocupam 2 bytes na memória. Asim sendo, a declaração acima faz com que o Delphi reserve 2 bytes para a nossa variável idade. Note que a declaração do tipo de uma variável, em princípio não lhe atribui valores. Um erro comum em programação é tentarmos ler valores de variáveis não inicializadas, ou às quais ainda não se atribuiu valores... Damos a seguir uma lista dos tipos de variáveis mais comuns do Object Pascal com suas faixas de valores e o espaço ocupado em memória:

BOOLEAN - Tipo lógico que pode assumir somente os valores TRUE ou FALSE e ocupa 1 byte de memória. BYTE - Tipo numérico inteiro, pode assumir valores numa faixa de 0 a 255, ocupa 1 byte. CHAR - Tipo alfa-numérico, pode armazenar um caractere ASCII, ocupa 1 byte. COMP - Tipo numérico real, pode assumir valores na faixa de -9.2.10-18^ a 9.2.10+18^ , ocupa 8 bytes, pode ter entre 19 e 20 algarismos significativos. EXTENDED - Tipo numérico real, pode assumir valores na faixa de -3,4.10-4932^ a +1,1.10+4932, ocupa 10 bytes de memória e tem entre 19 e 20 algarismos significativos. INTEGER - Tipo numérico inteiro, pode assumir valores numa faixa de -32768 a +32767, ocupa 2 byte de memória. LONGINT - Tipo numérico inteiro, pode assumir valores numa faixa de -2147483648 a +2147483647, ocupa 4 bytes de memória. REAL - Tipo numérico real, pode assumir valores na faixa de -2,9.10-39^ a +1,7.10+38, ocupa 6 bytes de memória e tem entre 11 e 12 algarismos significativos. CURRENCY - Tipo numérico Real utilizado para armazenar valores monetários. SHORTINT - Tipo numérico inteiro, pode assumir valores numa faixa de -128 a +127, ocupa 1byte de memória. SINGLE - Tipo numérico real, pode assumir valores numa faixa de -1,5.10-45^ a +3,4.10+38, ocupa 4 bytes de memória, e tem de 7 a 8 algarismos significativos. WORD -Tipo numérico inteiro, pode assumir valores numa faixa de 0 a 65535, ocupa 2bytes de memória. STRING - Tipo alfanumérico, possuindo como conteúdo uma cadeia de caracteres. O número de bytes ocupados na memória varia de 2 a 256, dependendo da quantidade máxima de caracteres definidos para a string. O primeiro byte contém a quantidade rela de caracteres da cadeia.

Os nomes de variáveis devem começar com uma letra ou o caractere sublinhado () seguido por uma sequência de letras, dígitos ou caractere sublinhado () e não podem conter espaço em branco nem quaisquer tipos de acentos. Os nomes de variáveis podem ter qualquer tamanho mas somente os 63 primeiros caracteres serão considerados. Exemplos : Para definir uma variável Nome do tipo string e uma variável Salario do tipo double, podemos inserir as seguintes linhas de código na cláusula var da unidade de código correspondente.