apostila-sobre-visual-basic

Prévia do material em texto

Apostila sobre Visual basic
Atualidades
117 pag.
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&utm_medium=document&utm_campaign=watermark
1)O que é programação ? ..................................................................................2
2)Apresentando o Visual Basic......................................................................... 3
3)Usando Forms, objetos e controles.............................................................. 5
4)Propridades...................................................................................................... 6
5)O que são Forms(Formulários)........................................................................7
5)Métodos.......................................................................................................... ..7
6)Eventos............................................................................................................. 7
7)Controles........................................................................................................ . 8
 Conhecendo melhor o formulário.................................................................. ..11
 Botão de Comando..........................................................................................14
 Label...............................................................................................................17
 TextBox...........................................................................................................18
 Option Button..................................................................................................22
 Frame..............................................................................................................22
 CheckBox........................................................................................................24
 ListBox.............................................................................................................25
 ComboBox.................................................................................................... ..30
 MaskedBox......................................................................................................32
8)Contruindo um Sistema.................................................................................35
19)Menus............................................................................................................37
10)Menus Dinâmicos.........................................................................................39
11)O Código........................................................................................................40
12)Variáveis........................................................................................................41
13)Modifcadores de Acesso.............................................................................48
14)Constantes....................................................................................................49
15)Operadores...................................................................................................50
16)Comandos Condicionais e Loops..............................................................52
17)Contadores...................................................................................................58
18)SubProcedimentos......................................................................................60
19)Funções........................................................................................................62
20)Matrizes........................................................................................................63
21)Lógica de programação..............................................................................67
22)As Bibliotecas..............................................................................................68
23)Comandos, Funções e Objetos Nativos....................................................69
24)Funções Internas.........................................................................................74
 Funções Numéricas........................................................................................74
 Funções de String.......................................................................................... 75
 Funções de Data e Hora.................................................................................78
 Funções de Conversão...................................................................................81
 Funções para Gerenciamento de Matrizes.....................................................83
 Funções Lógicas.............................................................................................84
 Funções de Disco.............................................................................................85
 Funções de Escolha..........................................................................................88
 Formatação de Dados.......................................................................................91
25)Banco de Dados
 Criando um Banco de Dados............................................................................99
 O que são tabelas?...........................................................................................100
 Criando uma Tabela......................................................................................101
 Criando Índices..............................................................................................106
 Definindo a Chave Primária..........................................................................107
 Acessando o Banco de Dados através do Visual Basic.................................108
26)Objetos de dados
 Data Control...................................................................................................118
 Data Grid........................................................................................................120
27)Impressão
 Printer.............................................................................................................122
 Crystal Reports...............................................................................................129
 Noções de Linguagem SQL............................................................................145
O que é Programação ?
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&utm_medium=document&utm_campaign=watermark
 Se você nunca teve contato direto com programação na vida, talvez esteja se 
perguntando, o que é afinal, programação. Embora talvez, você nunca tenha programado, 
tudo que usamos, foi de alguma forma programado. Isso não acontece só no mundo da 
informática, mas acontece também no mundo real. Por exemplo:
- Nas indústrias, já faz muito tempo que as máquinas vem sendo programadas para fazer 
determinadas tarefas.
- Na sua casa, Você com certeza já programou o rádio-relógio para despertar de manhã, já 
deve ter programado o vídeo-cassete e agora o DVD.
- Um automóvel, por exemplo, pode ser programado para limitar a velocidade máxima 
através de um chip e para injetar mais gasolina depois que ele atingir uma velocidade X.
 Como você pode ver, quase tudo a nossa volta foi de uma certea forma programado e 
com a informática é assim também. OS famosos softwares que todo mundo usa (Windows, 
Word, Excel, etc..) só existem por que foram programados.
 
Como programamos um software?
 
Através de instruções em conjunto, que formarão o código fonte
dele.
Exempo de um código :
Public Sub Main()
 Msgbox “Hello, World”
 End
End sub 
 Claro, que neste exemplo estou usando comandos do Visual Basic, que talvez alguns de 
vocês não conheçam. Não se preocupe em entender esse código agora. Vamosagora usar 
comandos fictícios para ilustrar o que fizemos neste exempo:
Ao iniciar()
 Mostrarmensagem “Hello,World”
 Fim
FinalDoEvento
 Não é necessário ser nenhum gênio para entender o que “msgbox” e “end” do exemplo 
anterior faziam. Pois se olharmos o último exemplo , notamos que no lugar de “msgbox” 
colocamos “mostrarmensagem” e no lugar do “end” usamos “fim”. O Interpretador irá ler 
a primeira instrução(msgbox) e irá exibir uma mensagem dizendo:”Hello,World” e, logo 
após encerrará o programa com o “End”.
 O interpretador sempre segue uma ordem lógica para ler as intruções, então não podemos 
colocar tudo de forma desordenada no código do programa, devemos colocar uma a uma, 
na ordem que precisamos que ele leia primeiro. Mais tarde veremos comandos condicionais 
e de laço para manipular essa execução. 
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&utm_medium=document&utm_campaign=watermark
 Um bom programador tem que ser curioso. Deve gostar de saber como as coisas 
funcionam debaixo da capô, não deve se preocupar em travar a máquina com “loops 
infinitos”(se você não sabe o que é loop, veremos mais tarde) ou de qualquer outra forma. 
Programação é uma arte. Envolve criatividade, análise , dedicação e muita paciência. 
 
Apresentando o ambiente do Visual Basic 6
Ao abrirmos o Visual Basic, ele abrirá uma janela nos perguntando o tipo de projeto a qual 
desejamos criar. 
 No momento nos limitaremos somente a usar o padrão “Standard Exe”, que é o que 
usualmente usamos na maioria dos casos. Ele abrirá um projeto vazio, com os controles 
nativos do Visual Basic á esquerda, um formulário e suas respectivas propriedades a direita.
 Vejamos na figura:
 Figura 1
 Form(Formulário) 
 
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&utm_medium=document&utm_campaign=watermark
Usando Forms, Objetos e Controles
Objetos – Começaremos pelos Objetos já que os demais(Forms e Controles) Também se 
enquadram como objetos. Devemos nos acostumar com os objetos, pois estaremos sempre 
cercado deles. Qualquer Botão, Form, Relatório, Controles, entre outros se enquadram 
como objetos. 
Na figura abaixo temos exemplos de objetos :
Figura 1
Todos os objetos tem propriedades, eventos e métodos a eles associados. Veremos mais 
tarde o que são métodos, eventos e propriedades dos objetos. No entanto o que é necessário 
saber agora é o que são objetos. Vemos que objeto é tudo aquilo que contem métodos, 
eventos e propriedades.
O que são Forms (Formulários)?
 Na verdade, quase todas as janelas que vemos nos aplicativos são Forms(Formulários). 
Ele serve de base para colocarmos nossos controles. 
 Na figura 1 (Exemplo anterior), vemos que existe um formulário, no nosso caso(Form1), 
com controles dentro dele(Caixa de texto, Lista e Botão).
 Os forms(Formulários), como qualquer objeto, possuem métodos, eventos e propriedades 
a qual veremos mais tarde.
O que são Propriedades?
 Propriedades, como o próprio nome sugere, são os atributos que podemos definir para 
cada objeto, seja um formulário , controle, etc...
 Quando selecionamos um objeto, no Visual Basic, aparecerá no canto direito da tela uma 
janela onde poderemos definir as propriedades para esse objeto. Podemos definir a cor, o 
nome e muitas outras propriedades.
 Algumas propriedades de alguns objetos podem ser definidas em tempo de execução, 
outras porém são somente leitura, ou seja, podemos verificar os valores de tais 
propriedades, mas não podemos modicá-los. Para atribuir um valor de propriedade a um 
objeto em tempo de execução usamos o nome do objeto , seguido de ponto, o nome da 
propriedade, o sinal de igual e o valor que você quer atribuir. 
Exemplo :
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&utm_medium=document&utm_campaign=watermark
ObjetoTal.Cor=”Azul”
Claro, que o “ObjetoTal” e a propriedade “Cor” desse objeto são fictícios. Um Exemplo 
real seria :
Text1.Text=”Exemplo”
 Não se preocupe em entender o que quer dizer a propriedade “Text”, mas sim em 
entender apenas como se faz para definir as propriedades em tempo de execução. 
 É importante ressaltar que cada objeto tem propriedades diferentes. Claro que todos tem 
propriedades em comum, mas um tipo de objeto sempre terá propriedades diferentes de 
outro tipo. 
Métodos
 Métodos são ações que agem sobre os objetos, por exempo, se temos um objeto carro, 
teríamos a propriedade “Cor” semdo como Azul. Poderámos ter um método chamado 
“Acelerar” e outro “Freiar”. Poderíamos também ter um método “abastecer”.
 Em exempo prático seria termos um formulário chamado “Form1”. Existe um método 
chamado “Show” que agem sobre formulário e outros objetos. Ele serve para exibir um 
formulário. Como faríamos para exibir o nosso formulário(Form1)?
Form1.Show
Será exibido o formulário. Este é o procedimento para se aplicar os métodos. Assim como 
as propriedades, cada objeto tem vários métodos diferentes. Podemos também passar 
parâmetros para esses métodos. Veremos isso mais tarde
Eventos
 
 Vamos tomar um exemplo prático. Voltaremos ao nosso exemplo do automóvel. Assim 
como podemos atribuir sua propriedade cor para Azul, executar um método “Acelerar”, 
podemos ter um evento 
“Ao Bater”.
 Um evento é gerado quando acontece algo com o objeto, por exemplo, se tivermos um 
Caixa De Texto e clicarmos em cima dela o Objeto TextBox(Caixa de Texto) vai gerar um 
evento chamado “Click()”. Dentro deste evento colocaríamos um bloco de código com as 
instruções que queremos que o programa faça cada vez eu o usuário clicar na Caixa de 
Texto. Assim como este , exitem muitos outros eventos e cada objeto tem seus eventos em 
comum, assim como tem eventos próprios de cada objeto. 
 Veremos mais tarde detalhadamente vários tipos de eventos.
 
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&utm_medium=document&utm_campaign=watermark
 Os Controles
 
Ao abrirmos o ambiente do Visual Basic, podemos ver á esquerda a Caixa de Ferramentas. 
 
 Esses controles que você está vendo na figura são os controles nativos do Visual Basic. 
Podemos adicionar mais controles a esta Caixa de Ferramentas. Veja como :
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&utm_medium=document&utm_campaign=watermark
Irá aparecer uma lista com todos os controles disponíveis. Para que eles apareçam na nossa 
Caixa de Ferramentas devemos selecion-alos nessa lista. Um controle, na verdade, é 
representado por um Arquivo com extensão “OCX”. Podemos ver nessa janela que o Visual 
Basic 
Mostra o local onde determinado componente, ou seja , o arquivo OCX, se encontra. Se o 
controle que você procura não se encontra nessa lista, basta você saber onde o arquivo 
OCX dele se encontra, podendo assim adicioná-lo a lista.
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&utm_medium=document&utm_campaign=watermark
Conhecendo melhor o Form(Formulário)
Veremos agora as principais propriedades, métodos e eventos do Form. Começremos com 
as principais propriedades. São elas:
Name – Define o nome do formulário. Um nome de objeto deve começar obrigatoriamente 
com uma letra, mas também pode conter números . Espaços em branco e caracteres 
como(#$&+-^) não são permitidos.Caption – É a título do formulário que aparece no seu topo. Podemos colocar qualquer 
valor nessa propriedade.
Appearence – Define se o mode de exibião será 3D ou Normal.
BakColor- Muda a cor de fundo do formulário. 
Como você pode ver, você pode optar entre 2 sistemas de cores. 
O Palette e o System , sendo que o System mostra o sistema de cores do Windows, no caso 
de você querer fazer uma aplicação bem padrão Windows, enquanto o Palette irá lhe 
mostrar várias outras cores e você pode personalizar suas próprias cores também.
BorderStyle: Muda o tipo de borda do formulário. None: sem borda, sem barra de titulo, 
sem menu de controle, sem botão maximizar e sem botão minimizar, e não pode 
redimensionar a janela.
Fixed Single: Borda fixa. Aceita o Menu de Controle, Maximizar, Minimizar, barra de 
título, mas não pode ser redimensionado.
(Default) Sizable: Borda comum. Possui o Menu de Controle, Maximizar, Minimizar, 
barra de título e pode ser redimensionada.
Fixed Dialog: Muito usada para janelas que vão manter um dialogo com o usuário. Ela 
pode ter Menu de controle e a barra de título, mas não terá os botões de maximizar e 
Minimizar. Não pode ser redimensionada.
Fixed ToolWindow: Não possui o menu de controle, o botão Maximizar e o botão 
minimizar. Também não pode ser redimensionada. Aparecerá somente a barra de título e o 
botão Fechar próprio do Windows 95. Este tipo de formulário não aparece na barra de 
tarefas do Windows.
Sizable ToolWindow: Não possui o menu de controle, o botão Maximizar e o botão 
minimizar. Pode ser redimensionada. Aparecerá somente a barra de título e o botão Fechar 
próprio do Windows 95. Este tipo de formulário não aparece na barra de tarefas do 
Windows.
ControlBox: Retira ou coloca o menu de controle e os botões maximizar, minimizar e 
fechar da janela.
8
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&utm_medium=document&utm_campaign=watermark
Enabled: Se esta opção estiver com False, ou seja, estando o Enabled desabilitado, isto 
indicará que nenhum objeto desta janela, e nem a própria
janela, poderá responder a eventos gerados pelo usuário, como clicar do mouse, 
pressionamento de teclas, etc. 
Font: Escolhe a fonte de letra padrão que será usada para todos objetos inseridos neste 
formulário.
Icon: Nesta propriedade escolhemos um arquivo de ícone para associar a esse formulário. 
Esse ícone é o que vai aparecer quando a janela for minimizada e no lado esquerda da barra 
de título ( Menu de Controle ).
KeyPreview: determina se os eventos do teclado no formulário serão executados antes dos 
eventos correspondentes aos Objetos inseridos no formulário.
MaxButton: Habilita ou não o botão de maximização.
MDIChild: Determina se a janela será uma janela filha. Ou seja, terá uma outra janela 
mestre que agrupara o Form que se esta criando.
MinButton: Habilita ou não o botão de minimizar.
MouseIcon: Sempre que o mouse for movido em cima do formulário, o ícone associado a 
esta propriedade aparecerá (desde que a propriedade MousePointer esteja customizada).
MousePointer: Nesta propriedade especificamos o tipo de ponteiro que o mouse terá 
quando se mover sobre o formulário. Veja os tipos existentes:
0 (Default) Ponteiro padrão. 
1 Ponteiro em forma de seta
2 Ponteiro de seleção exata
3 Seleção de escrita
4 Ícone 
5 Seleção de Mover Objetos
6 Redimensionamento na diagonal
7 Redimensionamento na vertical
8 Redimensionamento na diagonal
9 Redimensionamento na horizontal
10 Seleção alternada
11 Sinal de ocupado.
12 Não disponível ( Ocupado )
13 Trabalhando em segundo plano ( Somente 32-bit Visual Basic.)
14 Seleção de Ajuda. (Somente 32-bit Visual Basic.)
15 Todos os Tamanhos. (Somente 32-bit Visual Basic.)
99 Aparece o ícone escolhido na propriedade MouseIcon
Picture: Inseri uma figura em nosso formulário como papel de parede.
ShowInTaskbar: Habilita ou não a possibilidade da janela aparecer na barra de tarefas do 
Windows.
Visible: Determina se quando executarmos o programa essa janela irá ficar visivel ou 
invisível.
9
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&utm_medium=document&utm_campaign=watermark
WindowState: Determina se, quando executarmos o programa, a janela irá aparecer na 
tela do computador Normal, Maximizada ou Minimizada.
Bem, agora que você já conhece as principais propriedades do Form, vamos “Brincar um 
pouco”. 
Abra o Visual Basic e crie um projeto padrão. Você verá que por padrão o Visual Basic já 
coloca um Form no projeto. Então modificaremos este Form. Altera as seguintes 
propriedades:
Name = “FrmCadastro”
Caption=”Cadastro De Clientes”
BorderStyle = 1 – Fixed Single
 Altere a cor de fundo do formulário. Associe um ícone ao formulário e coloque uma 
imagem de fundo. 
 Feito isso, rode o programa teclando <F5>. Feito isso, veja o que acontece. Depois altere 
as propriedades, até mesmo as que não conhece. Procure conhecer todas, mude-as , execute 
o programa e veja o que acontece.
 
CommandButton ( Botão de Comando)
 O Botão de Comando é utilizado pelo usuário para executar determinadas ações. 
Quem determina essas ações é o programador através de instruções associadas aos eventos 
do CommandButton. Existe um padrão para se utilizar os botões de comando. Por exemplo. 
Em um Form(Formulário), com vários botões procure sempre deixá-los do mesmo 
tamanho, mesmo que o texto deles seja de tamanhos diferentes.
 
 
 Errado Certo 
Vamos as propriedades do CommandButton ou Botão de Comando:
Cancel: Se esta opção for ajustada como verdadeira, o botão será associado a tecla ESC, e 
sempre que pressionarmos esta tecla será como se tivéssemos apertado o botão.
Caption: O título que será exibido dentro do botão.
Default: Estando o botão com essa propriedade como True indica que este botão será o 
Padrão da janela, e sempre que apertarmos a tecla Enter será como se tivéssemos apertado 
o botão.
Enabled: Determina se o botão será habilitado para pressionamento por parte do usuário 
ou não.
Font: Escolhe a fonte de letra que o Caption terá.
Name: O nome que daremos para o Objeto botão de comando.
Visible: Determina se o botão será visível para o usuário quando o programa estiver em 
execução.
10
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
Style: Escolhe se o botão terá elemento gráfico em seu interior. Se escolher Style do tipo 
"Graphical" o CommandButton aceitará figuras, e elas devem ser inseridas na propriedade 
Picture do objeto CommandButton.
TabStop: Quando temos um formulário com diversos controles, podemos nos mover 
através desses controles usando o teclado, através da tecla TAB ou através de outras teclas, 
como veremos mais tarde. Quando a propriedade TabStop está desabilitada, ou seja com o 
valor “False” então, ao nos movermos através dos controles o Botão será ignorado e o foco 
movido ao controle seguinte.
TabIndex: o Movimento de troca de foco, que vimos na propriedade TabStop tem uma 
ordem, e essa ordem é seguida pela propriedade TabIndex do botão, a qual devemos 
atribuir um numero, esse número será usado como a ordem que o foco é percorrido pelos 
controles, ou seja, se tivermos um controle com a propriedade TabIndex definido como 1, 
e outro com a propriedade TabIndex definido como 2, o que tem o número 1, receberá o 
foco primeiro do que tem o número 2 na propriedade TabIndex.
ToolTipText – A não muito usada, mas não menos importante propriedade ToolTipText, 
quando não está vazia exibe uma pequena ajuda sobre o controle, quando o usuário passa o 
mouse em cima do respectivo controle.O texto que aparecerá será o definido na 
propriedade ToolTipText.
Vamos agora á um exemplo prático envolvendo Botões de Comando:
- Crie um Form e com as seguintes propriedades:
Caption = “Exemplo do CommandButton”
Name = “FrmExemplo”
- Insira neste Form 3 botões de Comando com as seguintes propriedades:
Botão 1:
Name = “CmdOk”
Caption = “OK”
Botão 2:
Name = “CmdCancelar”
Caption = “Cancelar”
Botão 3:
Name = “CmdSair”
Caption = “Sair”
Feito isso, dê um duplo click no objeto CmdOk. Você verá que ao clicar nesse botão abrirá 
uma janela de código, correpondente ao evento Click() do botão. Esse evento é acionado 
toda vez que o usuário clicar no botão. 
Dentro deste evento vamos inserir a seguinte linha:
Msgbox “Você Clicou OK”
11
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
 Faça o mesmo processo com os demais botões. Apenas troque o texto que exiet dentro 
das aspas pelo texto de sua preferência. Ao fazer esse processo com o botão “CmdSair”, 
insira uma linha a mais:
Unload me
 Execute o projeto e veja o que acontece. Você viu que criar a interface e fazer com que as 
coisas “funcionem” não é nada difícil. Basta conhecer bem as propriedades, eventos e 
métodos dos objetos.
Vamos agora conhecer os principais eventos do objeto CommandButton. Devo lembrar que 
muitos desses eventos e até mesmo propriedades, dependo do caso até métodos, não são 
exclusivo do CommandButton , ou seja, outros objetos também tem as mesmas 
particularidades. 
Eventos do CommandButton
 A maioria dos eventos do CommandButton não são usados, por isso, vamos nos reter 
apenas nos mais importantes. São eles:
Click() – Esse é o mais importante de todos os eventos do CommandButton. Acontece 
sempre que o botão é clicado.
GotFocus() – Um evento que acontece sempre que o CommandButton recebe o foco.
LostFocus() – Esse evento é chamado sempre que o CommandButton perde o foco.
MouseMove() – É chamado toda vez que o usuário mover o mouse por cima do 
CommandButton. Na prática isso não é muito usado, sendo que na maioria das vezes, um 
evento desses seria útil apenas quando quiséssemos que o evento informasse a função do 
botão ao usuário, mas isso pode ser feito facilmente usando a propriedade “ToolTipText” 
do botão.
 
Métodos
 O CommandButton tem 7 métodos, mas na prática, dificilmente usamos todos. Na 
verdade, usamos quase sempre apenas um deles:
SetFocus - Este método que não só é usado por CommandButtons, mas na verdade, é 
usado por quase todos os controles, tem a função de passar o foco para o objeto que 
quisermos. Exemplo:
CmdOk.SetFocus
Irá passar o foco para o objeto CmdOk.
O Label 
 Não há muito segredo para se trabalhar com Labels. O Label na verdade, não passa de 
uma legenda que inserimos no Form. Sua finalidade é inserir um texto no formulário. Isto 
nos será útil quando precisarmos fazer um cadastro ou coisa parecida. Vamos as suas 
principais propriedades:
12
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
Name – O nome que será usado pelo Label.
Caption – Essa é a propriedade principal do Label. A legenda que o Label terá.
Alignment: Determina o alinhamento que o texto terá dentro do label.
AutoSize: Com esta propriedade habilitada indicamos ao Controle para automaticamente 
dimensionar seu tamanho ao tamanho do texto do label.
Note na figura que, quando o AutoSize foi passado para True, as marcas de seleção do label 
foi ajustado para o tamanho do texto “label1”.
BackColor: Escolhe a cor de fundo que envolverá o label.
BackStyle: Escolhe entre o fundo Transparente ou Opaco para o label.
BorderStyle: Escolhe entre colocar uma moldura envolvendo o label ou não.
Enabled: Habilita ou desabilita o objeto. Quando esta em False fica com a cor de seu 
conteúdo acinzentada.
Font: Escolhe a fonte de letra que terá o texto digitado na propriedade Caption.
ForeColor: Escolhe a cor da fonte de letra
Name: Nomeia o Objeto label. Como já foi dito é importante que todos os objetos seja 
nomeado. A inicial do label é “lbl”.
Visible: Indica se o objeto será visível ou não para o usuário.
WordWrap: Quando o AutoSize esta em true, não é possível expandir o texto digitado na 
propriedade Caption em outras linhas. Mas se passarmos essa propriedade WordWrap para 
True isto poderá ser feito, bastando para isto dimensionarmos o label.
O TextBox 
 O TextBox é, com certeza, um dos controles mais importantes que você vai usar. 
Formulários de cadastro, entradas de dados e até mesmo consultas necessitam que você 
entre com os dados. Claro que temos outros controles disponíveis para isso, mas na maioria 
dois casos, usamos o TextBox. Vamos as suas principais propriedades:
BackColor: Escolhe a cor de fundo da Caixa de Texto. Geralmente é branco. 
BorderSytle: Tipo da borda: Fixa e simples, ou sem borda.
Enabled: Estando False o objeto não estará habilitado para interagir com o usuário.
Font: Escolhe a fonte de letra que será mostrada dentro da caixa de texto.
ForeColor: Escolhe a cor da fonte de letra.
Locked: Estando em false trava qualquer digitação na caixa de texto
MaxLength: Quantidade máxima de caracteres dentro da caixa de texto.
MultiLine: Habilita a possibilidade de se digitar mais de uma linha na caixa de texto.
Name: Nomeia o objeto TextBox. Geralmente com a inicial txt. Exemplo: Se formos usar 
essa caixa de texto para que o usuário digite o nome do paciente, poderíamos abreviar 
assim: txtNomePaciente.
PasswordChar: Se durante a digitação de qualquer dado na caixa de texto, quisermos que 
o Visual Basic mostre outro caractere no lugar do caractere digitado, é só especificarmos 
aqui qual queremos que seja mostrado. Muito usado para digitação de senhas.
13
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
ScrollBars: Estando a propriedade MultiLine habilitada, é interessante colocarmos um 
ScrollBars na caixa de texto, pois ele acrescentará uma barra de rolagem que poderá ser:
rolagem que poderá ser:
Text: A propriedade Text é a mais importante deste Objeto. Todo o texto digitado pelo 
usuário dentro da caixa de texto é incorporado nesta propriedade. 
Eventos do TextBox
Irei citar aqui alguns dos principais eventos relacionados a caixa de texto. 
Lembramos que todos os Eventos ocorre quando o usuário faz alguma ação. Por exemplo: 
se ele aperta um botão aciona o Evento Click, se ele digita algo numa caixa de texto, 
aciona o evento Change e KeyPress, se ele movimento o mouse sobre um objeto, aciona o 
evento MouseMove. 
Vamos explicar esses eventos aqui, mas antes é importante entendermos que cada 
movimento ou ação do usuário dispara um evento no programa. Mas esses eventos somente 
terão alguma reação se programarmos isto na janela de codificação.
Change: Ocorre sempre que o usuário altera o valor contido na caixa de texto.
Click: Ocorre quando o usuário pressiona o botão esquerdo do mouse sobre a caixa de 
texto.
DlbClick: Se o usuário apertar duas vezes o botão esquerdo do mouse sobre a caixa de 
texto
KeyDown: Ocorre quando o usuário aperta uma tecla no teclado.
KeyUp: Ocorre quando o usuário solta a tecla apertada.
KeyPress: Ocorre quando uma tecla é pressionada e solta. Como argumento possui uma 
variável cujo conteúdo é a tecla pressionada (código correspondente na tabela ASCII).
Cod. Cod. Cod. Cod.
0 · 32 Espaço 64 @ 96 `
 1 · 33 ! 65 A 97 a
 2 · 34 " 66 B 98 b
 3 · 35 # 67 C 99 c
 4 · 36 $ 68 D 100 d
 5 · 37 % 69 E 101 e
 6 · 38 & 70 F 102 f
 7 · 39 ' 71 G 103 g
 8 Backspa
ce
 40 ( 72 H 104 h
 9 Tab 41 ) 73 I 105 i
 10 42 * 74 J 106 j
 11 · 43 + 75 K 107 k
12 · 44 , 76 L 108 l
13 Enter 45 - 77 M109 m
 14 · 46 . 78 N 110 n
 15 · 47 / 79 O 111 o
14
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
 16 · 48 0 80 P 112 p
 17 · 49 1 81 Q 113 q
 18 · 50 2 82 R 114 r
 19 · 51 3 83 S 115 s
 20 · 52 4 84 T 116 t
 21 · 53 5 85 U 117 u
 22 · 54 6 86 V 118 v
 23 · 55 7 87 W 119 w
 24 · 56 8 88 X 120 x
 25 · 57 9 89 Y 121 y
 26 · 58 : 90 Z 122 z
 27 Esc· 59 ; 91 [ 123 {
 28 · 60 < 92 \ 124 |
 29 · 61 = 93 ] 125 }
 30 · 62 > 94 ^ 126 ~
 31 · 63 ? 95 _ 127 ·
· Estes caracteres não são aceitos pelo Microsoft Windows.
MouseMove: Ocorre quando movemos o ponteiro do mouse sobre a caixa de texto.
MouseDown: Ocorre quando o usuário aperta o botão do mouse (seja da direita ou da 
esquerda) sobre a caixa de texto.
MouseUp: Ocorre quando o usuário solta o botão do mouse (seja da direita ou da esquerda) 
sobre a caixa de texto.,
 Bem, agora que você já conhece as propriedades do TextBox, assim como os seus 
eventos, vamos colocar em prática tudo isso. Que tal um exemplo envolvendo Labels, 
TextBoxs e CommandButtons ?
 Lembra-se daquele formulário que fizemos como exemplo do CommandButton ? 
 Vamos melhorá-lo:
 Quanto aos botões, você pode deixar todos. Apenas os arraste para o canto direito do 
formulário. Coloque 3 Labels. Você verá que ao colocar a Label dentro do formulário ela 
tem a propriedade Caption
Definida como o nome do Label. Você deve trocá-la. Coloque uma com o Caption = 
“Código”, outra =”Nome” outra = “Endereço”. O formulário deve ficar assim :
Agora coloque 3 TextBoxs na seguinte ordem, de cima pra baixo:
TxtCodigo
Text=””
TxtNome
Text=””
TxtEndereco
Text=””
15
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
 Defina para que a TxtCodigo aceita no máximo 5 caracteres e txtnome no máximo 20. 
Defina para que ao pressionarmos a tecla <TAB> o foco passe primeiro pelas caixas de 
texto, de cima para baixo, e depois pelos botões, novamente, de cima para baixo. Veremos 
mais tarde como fazer as TextBoxs aceitarem somente números, ou fazer o inverso(fazem 
com que elas não aceitem números) através do evento keypress ou keydown.
OptionButton 
 O OptionButton ou botão de opção serve para escolhermos entre várias opções dentro do 
formulário. Podemos ter vários dentro do formulário, mas apenas um poderá ser marcado, 
pois quando marcamos um, o outro é automaticamente desmarcado. Para usarmos vários 
grupos de opções dentro do mesmo formulário, teríamos que usar um Frame, Objeto que 
veremos mais tarde. 
Na figura acima você pode ver dos grupos de OptionButtons operando independentemente, 
fazendo uso dos Frames. Se eles estivessem soltos no formulário, só poderíamos marcar 
uma opção, ou seja, ou marcaríamos o Estado Civil ou marcaríamos o Sexo.
Vejamos agora as principais propriedades do Frame:
Alignment: Determina se o texto ficará do lado direito ou esquerdo do botão de opção.
Caption: O texto que será anexado ao Objeto.
Enabled: Habilita ou não o objeto. Estando desabilitado o usuário não poderá selecionar a 
opção, e a cor do texto será acinzentado.
Name: O nomeia o Objeto. A inicial abreviada que se usa é “opt”.
Value: True para quando a opção esta selecionada e False para quando a opção não esta 
selecionada.
Eventos do OptionButton
 Os eventos do OptionButton são praticamente os mesmo usados pelas TextBox, sendo 
que não há nenhum em especial.
 
O Frame 
 É claro que, depois do exemplo anterior não poderíamos deixar de conhecer o Frame. 
Esse controle, como você viu anteriormente serve para organizarmos melhor os controles 
dentro do formulário. Todos os controles existentes dentro do Frame podem ser 
desabilitados ou habilitados definindo a propriedade Enabled de Frame como True ou 
False. Além desses recursos de aninhar controles, o Frame também traz uma interface mais 
limpa para o usuário. Vamos conhecer algumas de suas propriedades:
Caption: Coloca um texto no topo da moldura. Não é obrigatório. 
16
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
Enabled: Determina se todos todos os objetos colocados no interior da moldura estará ou 
não disponível para o usuário.
Name: Nome dado ao objeto. A inicial abreviada é “fra”. Cuidado para não colocar “frm” 
é a abreviatura do Objeto Form.
Um exemplo de Frame com a propriedade Enabled definida como False:
Como você pode ver o Frame da esquerda está com a propriedade Enabled definida como 
False. Estando assim não conseguiremos acessar nem mesmo os controles que estão dentro 
do Frame. 
 Esse recurso é muito útil quando queremos restringir ao usuário o acesso a certas opções.
 O frame, assim como o OptionButton, também não possui nenhum evento em especial, 
sendo a maioria idênticos aos do OptionButton.
CheckBox 
 A CheckBox ou Caixa de checagem é utilizado para marcar opções. Não funciona igual 
ao OptioButton, pois com a CheckBox podemos marcar várias opções, uma, ou nenhuma 
opção, sendo que com o OptionButton, podemos selecionar apenas uma.
Alignment: Especifica se o texto ficara do lado esquerdo da caixa.
 
Caption: O texto anexado ao Objeto CheckBox.
Enabled: Habilita ou não esse Objeto. Estando desabilitado não aceitará que o usuário faça 
evento com a caixa de checagem.
Font: Escolhe uma fonte de letra para o texto digitado no Caption
Name: Nomeia o Objeto. A inicial abreviada para este tipo de controle é “chk”.
Value: Determina o estado o objeto: 0 - Unchecked, 1 - Checked e 2 - Grayed.
Eventos
 O CheckBox tem praticamente os mesmo eventos do OptionButton.
Bem, agora que já conhecemos vários controles, assim como suas respectivas propriedades, 
métodos e eventos, vamos criar um Form utilizando vários desses objetos. Faremos o 
seguinte:
Primeiro – Crie um Form com as fontes, cores e ícones de sua preferência. Será um 
cadastro de clientes. Nesse cadastro será necessário:
Nome, endereço, bairro e cidade. Para isso serão necessárias 4 TextBoxs e 4 Labels, Certo ?
Nomeia-as e defina as suas propriedades de acordo com o que você acha necessário(Não 
esqueça que você vai se referir aos controles dentro do código através dos seus respectivos 
nomes, por isso siga a regra de nomenclatura adequada ou utilize um nome que você tem 
certeza de que não irá esquecer).
17
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
Segundo – Insira 2 Frames: Um que terá um grupo de opções com OptionButtons e se 
referirá ao sexo do cliente, que obviamente terá 2 opções(Masculino ou Feminino). O outro 
Frame se referirá ao estado civil do cliente. Teremos as seguintes opções:
1- Solteiro
2- Casado
3- Divorciado
4- Viúvo
 Todas essas opções serão representadas pelos OptionButtons que você vai inserir dentro 
do respectivo Frame. Siga as regras de nomenclatura padrão para atribuir os nomes aos 
Frames e Optionbuttons.
Terceiro – Insira 3 botões no formulário, um botão de Ok, um botão de Cancelar e um 
botão de Sair. Defina as suas propriedades (nomes, fontes, legendas, ícones, etc...).
Quarto – Insira um CheckBox, que vai ser utilizado para saber se o cliente reside em 
Cachoeira do Sul. A legenda desse CheckBox poderia ser “Reside em Cachoeira do Sul” ou 
qualquer outra de sua preferência desde que pergunte se o cliente mora ou não em 
Cachoeira do Sul.
Quinto – Deixe todos os controles de modo que o foco passe primeiro pelas TextBoxs, de 
cima para baixo, depois pelas opções, da esquerda para direita, e depois pelos botões, de 
cima para baixo.
No eventoClick() do Botão OK coloque o seguinte código:
MsgBox “OK”
Prossiga com os demais da mesma forma, trocando apenas o “OK” pelo nome do botão. 
Sexto - Bem, agora que já criamos a interface vamos fazer com que as coisas funcionem. 
Se você observar no Form, poderemos ver que existe uma Caixa de Texto, onde é 
perguntado ao usuário a cidade do cliente. No entanto, existe um CheckBox ou caixa de 
checagem que pergunta ao usuário se o cliente reside em Cachoeira do Sul. Ora, se 
soubermos que o cliente reside em Cachoeira do Sul não seria necessário informar a 
cidade.Para isso, será necessário associar a um evento do CheckBox, uma instrução que 
limpasse a caixa de texto, para caso já tivéssemos digitado alguma valor como Cidade, e 
desabilitasse a mesma para que não colocássemos nenhum valor, sendo que o cliente reside 
em Cachoeira do Sul. Mãos a obra.
O ListBox 
 O ListBox ou caixa de listagem é uma caixa a qual podemos adicionar itens, removê-los 
ou selecioná-los.
 
 O ListBox cria um índice com o número do item selecionado. Este índice sempre inicia 
pelo zero, ou seja, se selecionarmos o primeiro item, o número dele será zero. Se 
18
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
selecionarmos o segundo, ele retornará um. Este índice é visível através de uma 
propriedade em tempo de execução que veremos mais tarde.
O ListBox é útil para selecionamos nomes ou outro tipos de dados, removê-los ou 
adicioná-los de acordo com a nossa necessidade.
 Vamos conhecer agora as suas propriedades:
Columns: Determina a quantidade de colunas que a caixa de lista terá. Quando esta com 0 
(zero) significa que terá somente uma coluna e a barra de rolagem será vertical. Se o valor 
desta propriedade for 1 será formado também somente uma coluna mas a barra de rolagem 
será horizontal. Valor 2 significa que os itens inseridos no ListBox serão ajustados em 2 
colunas, e assim por diante.
 
Enabled: Habilita ou não o ListBox para o usuário selecionar algum item no objeto.
IntegralHeight: Determina a possibilidade dos itens dentro da caixa de lista ser exibido de 
forma parcial. 
 
List: é o Local onde digitamos os itens que estarão dentro do ListBox.
 
MultiSelect: Quando esta propriedade esta habilitada significa que a caixa de lista aceitará 
múltiplas seleções, ou seja, poderá ser selecionado mais de um ítem. As opções são 0 - 
None para seleção somente de 1 ítem. 1 - Simple para seleção de vários itens usando 
apenas o clicar do mouse ou barra de espaço. 2 - Extended é o padrão do Windows para 
multiplas seleções. Para selecionar mais de 1 item usa-se a combinação de tecla CTRL + 
Click do mouse ou barra de espaço.
Name: Nome que o Objeto ListBox terá. A abreviação padrão é “lst”.
Sorted: Classifica os itens existentes dentro do ListBox em ordem alfabética ou numérica 
ascendente. Esta propriedade em tempo de execução tem a finalidade de informar o estado 
que se encontra o Sorted. 
Style: O Estilo Standard é o padrão, a partir do Visual Basic 5 acrescentou-se o Estilo 
CheckBox, onde os itens existentes no ListBox são acompanhados de um quadradinho do 
lado esquerdo para se fazer a seleção dos itens. Para multiplas seleções esse tipo de ListBox 
é mais intuitivo para o usuário. 
Vamos agora conhecer as propriedades em tempo de execução. Essas propriedades são de 
extrema importância para manipularmos os dados existentes no ListBox, pois nos permitem 
saber o texto do itemselecionado, número do índice do itemselecionado, número de itens 
existente no ListBox,etc...
São elas:
19
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
ListCount: Retorna a quantidade de itens existente dentro de um ListBox.
ListIndex: Retorna o número correspondente ao índice do item selecionado.
NewIndex: Retorna o número correspondente ao índice do ultimo item inserido no 
ListBox.
SelCount: Quando a propriedade MultiSelect esta ativada, possibilitando a seleção de 
vários itens dentro da caixa de lista, o SelCount retorna a quantidade de itens que foi 
selecionado.
Selected: Retorna True ou False sinalizando se algum item foi selecionado. É necessário 
informar o índice correspondente. Exemplo: Selected(2): Se o item que possui o índice 2 
for selecionado retornará True, se qualquer outro for selecionado retornará False.
Text: Retorna o texto do item selecionado. Não necessita de índice.
List: Retorna o texto do item especificado no índice. Exemplo: List(2) irá mostrar o texto 
existendo na lista referente ao índice 2.
Eventos do ListBox
 De novo aqui só temos o evento DblClick(), que é gerado toda vez que dermos um duplo 
clique sobre um item do ListBox. 
 Procure usar sempre o DblClick(), e não o evento Click(). Pois para o usuário é mais 
intuitivo dar dois cliques numa caixa de listagem para abrir um certo item do que apenas 
um.
Métodos do ListBox
AddItem – Usamos este método sempre que queremos adicionar um item ao ListBox. A 
sintaxe usada é a seguinte:
ListBoxTal.AddItem “Texto a ser adicionado”
RemoveItem – Este outro método é usado para removermos um item do ListBox. A sintaxe 
á seguinte:
ListBoxTal.RemoveItem <número do índice a ser removido>
Você pode notar que é necessário informar o índice do item que se deseja remover. 
Geralmente para remover um certo item que encontra-se selecionado pelo usuário usamos:
ListBoxTal.RemoveItem ListBoxTal.ListIndex
Usamos “ListBoxTal.ListIndex”. Usando a propriedade listindex da nossa ListBox 
conseguimos automaticamente o número do índice selecionado, necessário para podermos 
remover o item que precisamos.
Clear – O mais simples de todos os métodos do ListBox. Serve para limparmos 
completamente a nossa caixa de listagem. Sua sintaxe também é muito simples:
ListBoxTal.Clear
20
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
 Agora que já conhecemos as principais propriedades, métodos e eventos dos ListBox, 
vamos fazer algo que “funcione” usando-os. 
Crie um formulário, com uma caixa de listagem, uma caixa de texto e 3 botões. Altere as 
propriedades dessa caixa para que esteja vazia sempre que abrirmos o formulário. Agora 
selecione todas as propriedades necessárias para os botões(legenda,nome,etc...) e codifique 
os seus eventos, de forma que um botão servirá para adicionar item, outro para excluir item 
e outro para limpar a caixa de listagem. Ao clicarmos no botão de AdicionarItem este botão 
pegaria o texto existente na Caixa de Texto e o adicionaria na Caixa de Listagem. Quando 
isso fosse feito, a caixa de texto deveria ser limpa para que um novo texto pudesse ser 
digitado nessa caixa de texto. A interface do formulário poderia ficar assim:
Claro que você pode incrementar com algumas legendas para facilitar para o usuário.
 Por se tratar de um exemplo, vamos padronizar os nomes dos controles existentes no 
formulário:
O botão de AdicionarItem irá se chamar “CmdAdd”
O botão de RemoverItem irá se chamar “CmdRemove”
O botão de Limpar irá se chamar “CmdLimpa” 
A Caixa de Texto irá se chamar “TxtItem”
A Caixa de listagem simplesmente “Lista”
 Bem, vamos ao que interessa. Começaremos primeiramente codificando o botão de 
AdicionarItem. Para isso, demos um duplo clique no botão de AdicionarItem. Abrirá então 
a janela de código referente ao evento Click() do respectivo botão. O que precisamos fazer 
então?
Fazer com que cada vez que clicarmos neste botão ele limpe a caixa de texto.
Primeiro devemos adicionar o texto existente na caixa de texto, para depois limpá-lo. 
Faríamos assim:
 Vamos agora ao botão de “RemoverItem”,a qual usaremos o mesmo evento click() para 
usar as instruções que farão que o item selecionado seja excluído caixa de listagem ao 
clicarmos na mesma. Para isso usaremos o método “RemoveItem” do ListBox. Como você 
sabe, quando usamos o método “RemoveItem” é necessário que informemos o número do 
índice para isso usaríamos a propriedades ListIndex do ListBox, a qual retorna em tempo 
de execução o índice do item selecionado. Ficaria assim:
21
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
Bem, já codificamos o botão de “AdicionarItem”, o de “RemoverItem”, resta apenas o de 
“Limpar” a caixa de listagem. O mais fácil de todos. Basta colocar no evento Click() do 
respectivo botão a linha que usa o método Clear do ListBox:
Você vai notar que ao tentarmos remover um item sem ter selecionado nada na lista o 
sistema vai gerar um erro, pois o valor da propriedade ListIndex, que deveria se referir ao 
índice do item selecionado estará como “-1”, isso por quê não há nenhum item selecionado. 
Logo mais veremos comandos condicionais, a qual poderemos manipulá-los para que não 
deixem esses tipos de erros acontecerem.
O objeto ComboBox 
 O ComboBox ou caixa de combinação é uma combinação de um TextBox(caixa de 
texto) com um ListBox(caixa de listagem). Podemos digitar caracteres dentro dela, além de 
podermos teclar na seta que existe á sua direita e selecionarmos dados previamente 
inseridos em sua lista.
 O ComboBox é de ampla utilização, pois poupa o tempo do usuário em precisar digitar 
dados, assim como pode evitar que o usuário digite dados incorretos também, além de 
ocupar pouco espaço no formulário. Imagine um formulário enorme com vários controles e 
tivéssemos que colocar uma lista de nomes para o usuário escolher, uma lista de cidades e 
uma lista de bairros, ao invés de colocarmos três ListBox que ocupariam um espaço maior 
poderíamos colocar três ComboBox . Vamos conhecer agora as suas propriedades:
O ComboBox usa as mesmas propriedades que aprendemos para o ListBox. A diferença 
esta somente em duas que veremos agora.
Style: Aqui escolhemos o tipo de Caixa de Combinação iremos colocar no formulário: 
0 - Dropdown Combo: é a opção padrão do Objeto. Aqui pode-se digitar qualquer nome na 
área de digitação, clicar a seta para baixo e escolher qualquer um dos itens que ele será 
automaticamente inserido na área de texto.
1 - Simple Combo: Caixa de Combinação simples. Aparece em destaque a área de edição 
de texto, onde podemos digitar algum item; ou selecionar qualquer um que esteja na caixa 
de lista, que será inserido na área de texto. O botão em forma de seta para baixo não existe 
neste tipo de ComboBox. Se aumentarmos o tamanho da Caixa de Combinação na vertical, 
aparecerá a lista e esta ficará fixa. Caso deixamos ela somente do tamanho da área de texto, 
então a lista não aparecerá, e se quisermos saber quais nomes existe teremos que apertar no 
teclado a seta para baixo ou para cima, para que os itens existentes dentro da Lista 
apareçam.
2 - Dropdown List: Neste tipo de Caixa de Combinação o usuário pode somente escolher 
um item relacionado na lista, não podendo digitar nada. A área de texto não aceitará 
digitação.
22
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
Text: Nesta propriedade digita-se um texto que ficará, como padrão, fixo na área de texto 
na caixa de combinação. Geralmente deixa-se em branco. Podemos usar essa propriedade 
também, em tempo de execução, para saber qual texto o usuário digitou ou selecionou.
Métodos do ComboBox
 Os métodos usados pelo ComboBox são os mesmo usados pelo ListBox(AddItem, 
RemoveItem e Clear). 
MaskedBox 
 O MaskedBox aparenta ser uma caixa de texto. A diferença é que ele tem vários recursos 
adicionais. Ele tem recursos que possibilitam a colocação de uma máscara onde ele só vai 
aceitar caracteres digitados de acordo com a máscara. Por exemplo, se quisermos que ele 
aceite apenas números, basta colocar a máscara correspondente que todos os caracteres que 
não são números serão ignorados automaticamente. Vamos agora conhecer as propriedades:
Este objeto é semelhante a uma caixa de texto, entretanto ele possui alguns recursos 
adicionais, como a possibilidade de colocar uma máscara para o texto que irá ser digitado e 
validar a digitação automaticamente.
Veja as principais propriedades:
AllowPrompt : Determina se o caractere informado como prompt é válido durante 
a digitação.
AutoTab : Determina se quando o usuário terminar de preencher a mascara do 
objeto o foco é automaticamente passado para o objeto seguinte, sem necessidade do 
usuário apertar TAB ou o mouse.
ClipMode : Determina se, diante de um evento de copiar ou recortar dados do 
objeto Maskedit para a área de transferência, devem ser enviados os dados digitados com 
os caracteres que compõem a máscara ou não.
* ClipText : Retorna o texto digitado no objeto sem os caracteres que compõem a 
máscara.
Format : Determina o formato que os dados serão exibidos. 
Use a propriedade Format para exibir dados em um formato consistente, ou seja, os 
dados serão exibidos neste formato, mesmo que o usuário digite os dados diferentemente 
do formato. Por exemplo, se você definir a propriedade Format para “dd/mmm/yyyy”, 
todas as datas digitadas serão exibidas no formato 18/Set/1995. Se o usuário digitar a data 
como 18/09/95 (ou qualquer outro formato de data válido), o Visual Basic converterá a 
exibição para o formato estabelecido, que é dia / mês-por-extenso-abreviado / ano-com-4-
digitos.
A propriedade Format afeta apenas a maneira como um valor é exibido e não como 
ele é armazenado. Da mesma forma, um formato de exibição não é aplicado até que o 
usuário termine a digitação e o controle perca o foco. 
Nada é exibido no campo para sugerir ou controlar o formato no qual os dados são 
inseridos. 
23
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
Se você precisar controlar a maneira como os dados são digitados, use uma máscara de 
entrada além de ou ao invés de um formato de exibição de dados. Se você quiser que os 
dados sejam exibidos exatamente como foram inseridos, não defina a propriedade Format.
* FormattedText : Retorna o texto digitado, incluindo os caracteres que compõem 
a máscara.
Mask : Máscara que moldará o controle.
O Visual Basic fornece duas propriedades que produzem resultados parecidos: a 
propriedade Format e o Mask.
Use a propriedade Mask para exibir caracteres de exibição literais no campo com 
espaços em branco a serem preenchidos. Por exemplo, se todos os números de telefones 
que inserir em um campo tiverem o mesmo formato, você poderá criar uma máscara de 
entrada: 
(###) ###-#### F 0D C (___) ___ -____ 
F 0
D C (062) 621-3862
Uma máscara de entrada garante que os dados se ajustem ao formato definido e 
você poderá especificar os tipos de valores que poderão ser inseridos em cada espaço em 
branco. Por exemplo, a máscara de entrada anterior solicita que todas as entradas 
contenham exatamente os dígitos necessários para completar um código de área e número 
de telefone, e que somente dígitos possam ser inseridos em cada espaço em branco.
Você pode definir uma máscara de entrada usando os seguintes caracteres.
0 Dígito (de 0 a 9, entrada requerida, sinais de mais (+) e menos (-) 
não permitidos).
9 Dígito ou espaço (entrada não requerida, sinais de (+) e menos (-) 
não permitidos).
# Dígito ou espaço (entrada não requerida, os espaços são exibidos 
como vazios enquanto os dados são editados, mas são removidos 
quando perde o foco, sinais de mais e menos permitidos).
L Letra(de A a Z, entrada requerida).
? Letra (de A a Z, entrada opcional).
A Letra ou dígito (entrada requerida).
a Letra ou dígito (entrada opcional).
& Qualquer caractere ou espaço (entrada requerida).
C Qualquer caractere ou um espaço (entrada opcional).
, . : ; - / Marcador de posição decimal e separadores de milhares, de data e 
de hora. (O caractere realmente usado depende das configurações 
do Painel de Controle do Windows).
< Faz com que todos os caracteres sejam convertidos para 
minúsculos.
> Faz com que todos os caracteres sejam convertidos para 
maiúsculos.
\ Faz com que o caractere seguinte seja exibido literalmente (por 
exemplo, \A é exibido simplesmente como A).
24
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
Quando você define uma máscara de entrada e a propriedade Format para o mesmo objeto, 
a propriedade Format tem precedência quando os dados são exibidos. Isso significa que 
mesmo você tendo salvo uma máscara de entrada, ela é ignorada quando os dados são 
formatados. O dado original como foi digitado não é alterado; a propriedade Format só 
afeta a maneira como os dados são exibidos.
MaxLength : Determina a quantidade máxima de caracteres que o MaskEdBox 
pode ter.
Name: Nomeia o objeto. Geralmente inicia o nome com “msk”
PromptChar : Escolhe o caractere padrão que será exibido simbolizando o estado 
vazio. Por default possui o caractere “_”, e aconselho a substituir pelo caractere de espaço. 
Esta propriedade não aceita vazio.
PromptInclude : Determina se o caractere inserido na propriedade PromptChar 
será incluído na propriedade Text.
* Text : Contém o texto digitado pelo usuário no objeto.
Evento ValidationError : Este evento ocorre sempre que o usuário digita alguma 
entrada que não corresponde a máscara estabelecida.
 
Construindo um sistema
 Um sistema em VB é constituído por vários componentes e dividido em várias partes. 
Nós já conhecemos os formulários(Forms), mas num sistema podem conter vários outros 
componentes:
- MDI Forms
- Módulos(Módule)
- Módulos classe(Class Module)
- Relatórios (Data Report)
- User Controls
Estes são os principais componentes. Existem muitos outros que fogem ao objetivo do 
nosso curso. Alguns, como o Módulo Classe
E o User Control também não serão abordados neste curso, apenas você terá uma noção do 
que é e para que serve. 
MdiForms – O MdiForm na verdade é um Form que suporta vários outras Forms dentro 
dele. Ele tem a função de ser o formulário principal numa aplicação. Numa aplicação 
média ou grande, sempre vamos ter que adicioná-lo no projeto.
Módulos – Os módulos são usados a todo momento no Visual Basic. Qualquer projeto seja 
ele médio ou grande tem vários deles. Dentro desses módulos, existirá um código que 
poderá se dividir em subprocedimentos e funções de usuário. Veremos logo a seguir o que 
são subprocedimentos e funções.
Módulos Classe – Módulos classes são na verdade, blocos de código que agem como 
objetos. Nosso curso não vai abordar a construção de objetos, no entanto aprenderemos a 
usá-los.
25
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
Relatórios – São relatórios gerados por uma ferramenta. Existem para facilitar o nosso 
trabalho de gerar relatórios. Tem várias funções úteis a quais veremos mais tarde. Há outros 
geradores de relatório além do Data Report. Trataremos disso na seção Impressão.
User Controls – São controles construídos pelo próprio programador de acordo com 
alguma necessidade específica a qual os controles normais não poderiam suprir.
DataEnvironment – Este componente é muito útil para tratarmos com banco de dados. 
Facilita muito o acesso aos dados e nos possibilita manipular o Banco de Dados com 
poucas linhas de código.
 Para adicionar um componente, acesse o menu Project e selecione qual componente você 
deseja adicionar.
Antes de nos aprofundarmos em alguns componentes, principalmente nos módulos, vamos 
aprender a manipular as propriedades do projeto. Quando você inicia um projeto, ele por 
padrão sempre coloca um objeto Form dentro do projeto. De nada for alterado nas 
propriedades do projeto, o interpretador sempre inicia por esse Form, o abrindo. Existem 
alguns eventos do Form que talvez você ainda não conheça e são de extrema importância 
quando começamos a trabalhar com o código. São eles:
Initialize – Este evento ocorre quando o Form é chamado, seja pelo Visual Basic, ou por 
um módulo onde definimos uma instrução para chamá-lo.
Load – Ocorre sempre que o Form é carregado na memória. Poderámos dizer que é o 
ponto de entrada em qualquer formulário. Quando o formulário é chamado, antes mesmo 
de podermos visualizar ele na tela, o evento Load já está ocorrendo.
Activate – Este evento ocorre logo após o evento Load. Quando este evento ocorre já 
podemos ver o Formulário.
Unload – Ocorre quando o formulário é descarregado da memória. È o oposto do evento 
Unload .
Terminate – Este evento ocorre após o evento Unload . Quando ele ocorre o formulário já 
não está mais na memória, e muito menos podemos visualizá-lo.
 Bem, é fácil deduzir que se criarmos um projeto, não alterarmos nada, e colocarmos esse 
projeto pra rodar, o interpretador primeiro percorreria o evento Initialize do formulário, 
depois o evento Load e depois o evento Activate. Ao fecharmos ele percorreria o evento 
Unload e depois o evento Terminate.
 No entanto, um projeto pode iniciar também por um módulo. Existe um evento chamado 
Main que o Visual basic sempre procura nos módulos do seu projeto, caso você defina para 
que ele procure. Podemos optar entre 2 pontos de entrada em sua aplicação:
- Um formulário que você mesmo define qual é
 OU
26
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
- Um módulo que tem um procedimento chamado “Main”. 
Vamos conhecer as propriedades de projeto onde podemos definir isso. Acesse o menu 
“Project” e selecione “Properties”. No caso de você ter um projeto com o nome de 
“Exemplo” aparecerá “Exemplo Properties”. Aparecerá a seguinte janela:
 Um projeto médio ou grande sempre começa em um módulo, através do 
subprocedimento Main .
 
Menus
 Até agora vimos como inserir botões e muitos outros controles em um formulário. Mas e 
se quiséssemos inserir menus.
 O Visual Basic oferece um editor de menus muito simples. Acessando o menu Tools, 
Menu Editor ou teclando <F2> você abrirá o Menu Editor.
 Agora que já conhecemos as propriedades, vamos aprender a criar os menus. 
Primeiramente, você define o Caption e o Name do item de menu. Devo lembrar que o 
Name é obrigatório.
 Note que podemos criar submenus dentro dos menus. Usando e , sendo que avança um 
nível e recua um nível.
 Menus que são antecipados com “....” representam submenus. Quanto mais “....” tiver na 
frente do submenu, mais avançado é o seu nível. 
27
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
Menus dinâmicos
 Menus dinâmicos são aqueles menus que aparecem quando clicamos com o botão direito 
do mouse em cima de algum item.
 O comando que chama esses menus é o PopUpMenu e sua sintaxe é a seguinte:
PopUpMenu <Nome do menu a chamar>
 Claro que ainda temos que saber quando usar esse comando. Podemos usá-lo então no 
evento MouseUp do objeto que vai ter o menu. Como sabemos, o evento MouseUp 
acontece toda vez que clicamos o botão do mouse em cima do objeto. Vamos conhecer 
melhor o evento MouseUp :
MouseUp (Button asInteger, Shift As Integer, X as Single, Y as Single)
Como você pode ver, o evento MouseUp nos passa parâmetros dizendo que botão foi 
pressionado, que tecla estava pressionada no momento em que pressionamos o botão do 
mouse, a linha e a coluna onde foi pressionado o botão.
Button : retorna um número inteiro que informa qual dos botões foram apertados:
1 Botão esquerdo pressionado. vbLeftButton
2 Botão direito pressionado. vbRightButton
4 Botão do centro pressionado. vbMiddleButton
Shift : retorna um número inteiro que informa qual tecla estava pressionada no 
momento em que algum botão do mouse também foi pressionado.
1 SHIFT pressionado. vbShiftMask
2 CTRL pressionado. vbCtrlMask
4 ALT pressionado vbAltMask
X : Coordenada para linha
Y : Coordenada para Coluna
Exemplo:
Private Sub List1_MouseUp(Button As Integer, Shift As Integer, X As Single, Y As 
Single)
 If Button = 2 then 
 PopUpMenu MenuLista
 End if
End Sub
No código acima usamos o evento MouseUp do objeto List1 e depois verificamos se o 
botão do mouse que foi pressionado é o direito. Caso seja, usamos o comando 
PopUpMenu para chamar o menu com o nome de MenuLista.
28
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
O código
 Já falamos várias vezes sobre código aqui, no entanto nosso código se resumiu a atribuir 
propriedades em tempo de execução a alguns objetos. Não iríamos muito longe apenas com 
isso. Precisaríamos de comandos, funções e muitos outros. 
 Antes de vermos cada um desses itens detalhadamente, seria necessário dividir o código 
em:
- SubProcedimentos
- Funções de Usuário
- Propriedades
- Eventos
 Nosso curso tratará apenas subprocedimentos e funções de usuário. Propriedades e 
eventos, na maioria dos casos não são muito usados. Antes de vermos esses itens 
detalhadamente, assim como o método de declará-los no código, vamos conhecer a nossa 
amiga “Janela de Código”. É nela que estaremos trabalhando a maior parte do tempo.
 
 Vamos tratar primeiramente sobre os subprocedimentos. Um subprocedimento são 
blocos de código com tarefas específicas. Tem uma série de instruções dentro dele que 
devem fazer alguma coisa. Dentro de um subprocedimento podemos ter comandos e 
funções. Além disso, um subprocedimento também pode receber parâmetros que 
especificam os valores que serão tratados pelo respectivo subprocedimento. Os 
subprocedimentos existem para facilitar a organização de nosso projeto. Imagine um 
projeto enorme com milhares de linhas de código. Seria difícil organizar tudo isso. Não é 
mesmo? Então foram criados os subprocedimentos para que cada tarefa em nosso projeto 
pudesse ser dividida, organizando assim o código. Veremos exemplo mais tarde e vamos 
aprender a declará-los também.
 Quanto as Funções de Usuário , serão vistas logo mais, sendo que vamos precisar 
conhecer primeiro o que faz uma função para que depois aprendemos a construí-la. 
 Devemos agora primeiramente ter uma noção boa sobre variáveis, comandos e funções 
de depois mergulharemos em subprocedimentos e funções de usuário.
Variáveis
 
 Você já deve conhecê-las da matemática, onde geralmente tínhamos a variável X ou 
variável Y.
 Em programação, ela tem a mesma função com vários recursos adicionais.
29
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
 Na matemática, só tínhamos a variável numérica. Na programação temos vários tipos de 
variáveis. Vamos conhecê-las:
Nome Descrição Abrangência
Integer Numérico Inteiro -32.768 a 32.767
Long Numérico Inteiro -2.147.483.648 a 2.147.483.648
Byte Numérico Inteiro 0 a 255
Single Numérico real -3,402823E38 a -1,401298E-45 
1,401298E-45 a 3,402823E38 
Double Numérico real -1,79769313486232E308 a 
4,94065645841247E-324
4,94065645841247E-324 a 
1,79769313486232E308
Currency Numérico -
Valores monetários
-922.337.203.685.477,5808 a 
922.337.203.685.477,5807
String Texto 2.147.483.648 de caracteres nos sistemas 32 
bits
65.536 de caracteres nos sistemas 16 bits 
Date Data e Hora entre 01/01/100 a 31/12/9999
Boolean True (verdadeiro) False (falso)
Object Contém um objeto
Variant Pode ser numérico, string, objeto ou valor nulo.
 Quando atribuímos um determinado valor a uma variável esse valor fica armazenado na 
memória e quando nos referenciamos a essa variável novamente esse valor é lido na 
memória. Portanto, devemos pensar bem antes de escolher qual variável usaremos 
para o nosso valor.
 Você viu que existem cinco tipos de variáveis apenas para tratar com números. A Integer 
abrange um certo valor, a Long outro, a Single outro, a Double outro e a Currency é a mais 
adequada para tratarmos com valores monetários .
 Devemos usar exatamente o tipo de variável que precisamos. No caso de você precisar 
colocar o número 100 numa variável, o tipo Integer se enquadra perfeitamente. Já se 
usarmos Long para um valor desse porte, estaríamos desperdiçando memória.
 O tipo Variant, por exemplo, permite-nos, de antemão, atribuí-lo com um valor a qual não 
sabemos qual é. No entanto, devemos usar o tipo Variant com muito cuidado, pois tem um 
consumo de memória bem superior aos outros tipos de variáveis. 
 O Visual Basic nos permite atribuir um valor a uma variável sem precisarmos declarar o 
seu tipo. No entanto essa prática apesar de facilitar o trabalho, não é recomendada. Você 
deve estar se perguntando por quê:
 Bem, em primeiro lugar, imagine você um sistema com milhares de linhas de código. E 
nessas linhas você tivesse a seguinte linha:
Nome = “Maria Da Silva”
Digamos que você se distraia e digite:
30
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
Nomex = “Maria Da Silva”
 O que irá acontecer é que o compilador não vai dar nenhum aviso de erro, por quê assim 
como existe a variável “Nome” pode existir também a variável “Nomex”. Tudo bem, o 
programa irá compilar sem problema o seu código. Mas e, quando você precisasse desse 
valor dentro da variável “Nome”? 
Resposta: Ela não estaria lá!
E seu código?
Se quebraria. 
 Daria erro em um certo ponto. Talvez você demoraria para notar o erro, mas cedo ou 
tarde, em determinada parte, iria ver que o valor não estava sendo gravado ou qualquer 
outro tipo de erro. 
 Esse tipo de problema é comum se você não optar que o Visual Basic exija 
obrigatoriamente a Declaração de Variáveis. Para isso, acessamos o Tools, Options e 
selecionamos “Require Variable Declaration”, como mostra a figura.
 Podemos também usar a instrução Option Explicit na seção General-Declarations do 
módulo em que deverá ser forçada a declaração de variáveis.
 Com este procedimento, se uma variável não for declarada o Visual Basic vai gerar um 
erro dizendo que a variável não foi declarada.
 Você deve estar se perguntando onde, e, como se declara uma variável. Há várias 
palavras chave para se declarar uma variável. Trataremos primeiro do comando Dim. Sua 
sintaxe é a seguinte:
Dim VariávelTal as <TipodaVariável>
Exemplo:
Dim Nome as string
Declaramos a variável “Nome” como sendo do tipo “String”
Dim Numero as Integer
Declaramos a variável “Número” como sendo do tipo “Integer”
Dim Valor as Currency
Valor = “58,34”
Declaramos a variável “Valor” como sendo do tipo “Currency”, que é o tipo que usamos 
para valores monetários, e, logo após atribuímos a ela o valor de “58,34”
 Vamos tratar agora os diferentes tipos de variáveis que se dividem em numéricas, string, 
lógicas, datas , objects e variants.
31
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermarkVariáveis numéricas
 Uma variável numérica pode ser do tipo Integer, Long, Single ou Double como já vimos 
anteriormente. Você escolhe a variável de acordo com as suas necessidades. Procure 
sempre utilizar o tipo de variável de acordo com o que você precisa. Por exemplo, se você 
irá armazenar um número entre zero e 100 em uma variável numérica do tipo Long, você 
estaria utilizando mais recursos do que seu valor necessita. Pois numa caso destes, a 
variável Single seria totalmente cabível. É muito importante que o programador leve em 
consideração casos como este. Pois em um programa grande o gerenciamento de recursos 
é de extrema importância.
 Procure usar as variáveis numéricas apenas quando estas forem objetos de cálculos, ou 
seja, use-as apenas quando for realizar operações matemáticas com os seus valores. Por 
exemplo, você não precisa utilizar um tipo numérico para uma variável numérica que vai 
conter um “Cpf” ou um “número de identidade”.
Variáveis Lógicas(Boolean)
 Permitem somente dois valores: True or False. Ou seja, verdadeiro ou falso. 
 Este tipo de variável parece não nos prometer nada, mas são de extrema importância 
dentro de um programa. Quando declaramos uma variável do tipo Boolean, ele é definida 
automaticamente como False(Falso) e só passa a ser True(Verdadeiro) quando assim for 
definida. Exemplo:
Dim Nome as String
Dim NomeIgual as Boolean
Nome = “Maria da Silva”
NomeIgual = (Nome = “Maria”)
A variável lógica “NomeIgual” retornaria False
Declaramos duas variáveis, uma do tipo String, e outra do tipo lógica(Boolean). A variável 
lógica “NomeIgual” tem a função de analisar a comparação entre a variável nome e uma 
string qualquer. Se essa comparação for verdadeira, ele retornará true, e vice-versa. No 
nosso exemplo acima, temos a variável “Nome” com o conteúdo “Maria da Silva”. A 
comparamos com a string “Maria” e o resultado que a variável “NomeIgual” dará é False, 
por quê a comparação não é verdadeira. Vejamos agora como a variável “NomeIgual” 
poderia retornar True:
Dim Nome as String
Dim NomeIgual as Boolean
Nome = “Maria da Silva”
NomeIgual = (Nome = “Maria da Silva”)
“NomeIgual” retornaria True
Convém observar que se trocássemos uma letra que fosse, de maiúscula para minúscula a 
variável lógica “NomeIgual” já retornaria False.
32
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
Dim Nome as String
Dim NomeIgual as Boolean
Nome = “Maria da Silva”
NomeIgual = (Nome = “Maria da silva”)
“NomeIgual” retornaria False Observe o “s” minúsculo
 
Variável String
 
 Ao tratarmos sobre as variáveis lógicas falamos sobre “String”. Uma string na verdade 
pode ser o conteúdo de uma variável do tipo “String” ou qualquer conteúdo delimitado por 
“” aspas. Uma string aceita caracteres alfanuméricos, símbolos, etc. Podemos fazer 
concatenação com essas strings, assim como extrair uma parte de seu conteúdo e até fazer 
comparações.
 Concatenação seria juntarmos duas strings em uma só. Podemos usar para isso o 
operador “+” ou o “&”. Exemplo:
 “Visual “ + “Basic” resultaria “Visual Basic”
 “13” + “12” resultaria “1312”
 “Visual ” & “Basic” resultaria “Visual Basic” 
 “13” & “12” resultaria “1312”
 Bem, olhando assim parece que o operador “+” e operador “&” são iguais, mas na 
verdade não. A diferença está que o operador “+” força a soma e operador “&” força a 
concatenação. Vejamos:
12 + ”13” resultaria 25
Note que ao tentarmos concatenar com o operador “+” uma string e um dado numérico ele 
somou e transformou o resultado em um valor numérico. 
12 & “13” resultaria “1213”
 Agora ficou bem claro que o operador “+” ao encontrar 2 tipos diferentes, ou seja, um 
valor numérico e uma string, ele os somará e irá transformá-los em um valor numérico, 
enquanto que o operador “&”, ao encontrar 2 tipos diferentes irá forçar a concatenação, 
pegando o valor numérico e concatenando com a string, transformando assim o resultado 
em uma string. 
 Resumindo, podemos usar tanto o operador “+” quanto o operador “&” para concatenar 
strings, apesar de que geralmente é mais usado o “&”.
 
Variável Date
 
 A variável Date nos possibilita o armazenamento de datas, porém, também podemos 
armazenar horas. Quando atribuímos uma data a uma variável devemos usar o operador #. 
Exemplo:
Data = #01/01/2001#
33
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
Se tentarmos atribuir uma variável data assim:
Data = 01/01/2001
Ou assim:
Data = ”01/01/2001”
 Se a variável foi já foi declarada como Date, o programa retornará um erro dizendo que 
o que estamos tentando passar não é uma data. Se a variável ainda não foi declarada, no 
primeiro exemplo, ele pensará que estamos tentando dividir 01 por 01 por 2001 e colocará 
o resultado na variável. No segundo ele armazenará uma string na variável tornando assim 
uma variável do tipo String.
 A variável Date nos possibilita fazer alguns cálculos:
a = #15/07/96#
b = #30/07/96#
b - a = 15 (Uma data menos outra retorna o intervalo em dias)
a + 3 = #18/07/96# ( uma data mais um valor numérico soma a quantidade de dias na data)
a - 3 = #12/07/96# ( uma data menos um valor numérico subtrai a quantidade de dias na 
data.
Variável Variant
 A variável do tipo Variant como o próprio nome sugere é uma variável que se transforma 
em qualquer tipo, dependendo do conteúdo que lhe é atribuído. Por exemplo, se tivermos 
uma variável “A” e atribuímos A=”José”, A será do tipo String, já se atribuirmos A = 1, A 
será do tipo Integer.
 A uso desse tipo de variável só é aconselhado quando não temos a menor idéia do 
conteúdo que será atribuído a ela, pois uma variável do tipo VARIANT utiliza mais 
recursos do que os outros tipos.
Variável Object e instanciação
 A variável Object representa um objeto. Podemos atribuir objetos ás variáveis, caso 
precisarmos. Essa prática é chamada de instanciação. 
 Como o Visual Basic trabalha com objetos, é bom se acostumar a instanciar objetos a 
todo o momento. O que acontece, na verdade, no momento em que instanciamos o objeto é 
que a variável que contém a variável passará a se comportar como o objeto. Podemos 
definir um tipo de variável como sendo TextBox, ComboBox, Form ou qualquer outro 
objeto. O Tipo Object aceita qualquer um desses objetos. Seria como a variável Variant dos 
objetos.Podemos instanciar qualquer objeto existente em nosso projeto. Para instanciar um 
objeto, temos de usar a palavra chave SET antes da variável. Exemplo:
Dim Objeto as Object
Set Objeto = Text1
Objeto.text=”olá”
34
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
 Crie um projeto novo no VB. Insira um TextBox no formulário. Agora coloque o código 
acima no evento LOAD do Form e rode o projeto. Você verá que aparecerá a caixa de texto 
com o texto “olá” em seu interior. Bem, vejamos como isso aconteceu.
 Primeiro, criamos uma variável chamada Objeto, como sendo do tipo OBJECT. 
Dim Objeto as Object
Depois á instanciamos. Imagine o ato de instanciar como estar apontando para objeto. 
Como tornar a variável um espelho do objeto. 
 
Set Objeto = Text1
 
 Depois de instanciarmos a variável Objeto, fazendo que ela aponte para “Text1”(nossa 
TextBox), podemos modificar as suas propriedades através da variável:
Objeto.text=”olá”
 Simples, não é mesmo. Note que, ao declarar a variável, poderíamos usar diretamente o 
tipo TEXTBOX. Pois como já falamos anteriormente, o Tipo Object seria como o Tipo 
VARIANT, só que para objetos. Este exemplo usou um TextBox, mas poderíamos usar