Download Exemplos Delphi - Basico

A Seguir Alguns Exemplos Delphi

SOMA 2 VALORES

COMPARA 2 VALORES

CONVERSOR DE KM PARA M

EXEMPLO USANDO COMBOBOX

VERFICA SE É TRIANGULO

Por enquanto é isso logo postarei mais exemplos

Conhecendo Delphi - Estrutura de Units - Conceitos - Introdução

Classe: Definição de tipo dos objetos, modelo de objeto.

Objeto: Instância de classe, variável cujo tipo é uma classe.

Atributos: Variáveis de instância, são os dados de um objeto.

Métodos: Funções e procedimentos de um objeto.

Propriedades: Apelido usado para evitar o acesso direto aos atributos de um objeto, onde podemos especificar métodos que serão usados para ler e atribuir seus valores a esses atributos.

Estrutura de Units

Ao criar uma nova Unit Observe:

Unit: A primeira declaração de uma unit é seu identificador, que é igual ao nome do arquivo.

Interface: Seção interface, onde ficam declarações que podem ser usadas por outras Units.

Uses: Na cláusula uses fica a Lista de Units usadas.

Type: Na cláusula type fica a definição de tipos, aqui temos a declaração da classe do Form.

Var: Na cláusula var são declaradas as variáveis, aqui temos a declaração da instância do Form.

Implementation: Na seção implementation ficam as definições dos métodos.

End: Toda Unit termina com um end a partir de onde qualquer texto é ignorado.

Variáveis Globais

Declaradas da Interface da Unit. Podem ser acessadas por qualquer Unit usuária.

exemplo:

varI: Integer;
sUsuario: string;
nA, nB, nSoma: Double;
bOk: Boolean;

Variáveis Locais

Só existem dentro do método, não podem ser acessadas de fora, mesmo que seja na mesma Unit. Na verdade essas variáveis são criadas quando o método é chamado e destruídas quando ele é finalizado

exemplo

procedure TForm1.Button1Click(Sender: TObject);
var
sAux: string;
begin
Aux := EdtA.Text;
EdtA.Text := EdtB.Text;
EdtB.Text := Aux;
end;

Comentários

Existem 3 tipo de comentário no Delphi, como mostrado abaixo.

(* Comentário *){ Comentário }// Comentário 

Estruturas de Decisão

If - (SE) usada para realizar instruções em determinadas condições
Exemplo:
if idade < 18 then  ShowMessage('de maior')
else  ShowMessage('de menor');


case - (CASO)Permite que o fluxo da execução seja desviado em função de várias condições de acordo com o valor do argumento
var
  iPosicao:integer;
  sOrdem:string;
begin
  case iPosicao of    1: sOrdem:= 'primeiro';
    2: sOrdem:= 'segundo';
    3: sOrdem:= 'terceiro';
  end;
end;

Estruturas de Repetição
While

O laço while executa uma instrução até que uma condição seja falsa.

I := 10;
while I >= 0 dobegin  ShowMessage(IntToStr(I));
  Dec(I);
end;

For

O laço for executa uma instrução um número determinado de vezes, incrementando uma variável de controle automaticamente a cada iteração. 

for I := 1 to alunos do
  ShowMessage('Este é o aluno n° ' + IntToStr(I)  );
Repeat

O laço repeat executa instruções até que uma condição seja verdadeira.

repeat
  S := InputBox('Acesso', 'Digite a senha', '');
until
 S = 'senha';

With

Usado para facilitar o acesso às propriedades e métodos de um objeto.

with Objeto do  begin    Name := 'nomeObj';
  end;

Funções

Funções são muito semelhantes a procedimentos a única diferença é que as funções retornam um valor. O tipo do valor de retorno deve ser informado no cabeçalho da função. Na implementação da função deve-se atribuir o valor de retorno à palavra reservada Result ou ao identificador da função. Pode-se então usar a função em expressões, atribuições, como parâmetros para outras funções, em qualquer lugar onde o seu valor possa ser usado.

function Soma(A, B: Integer): Integer;
begin  Result := A + B;
end;

Métodos

Métodos são funções ou procedimentos que pertencem a alguma classe, passando a fazer parte de qualquer objeto dessa classe. Na implementação de um método precisamos indicar qual a classe à qual ele pertence. Para chamar um método em algum lugar não pertencente à sua classe, como procedimentos, funções ou métodos de outras classes, deve ser indicado o objeto que deve executar o método. Os métodos usam os mesmos níveis de encapsulamento dos atributos.

procedure MostraMsg(sMensagem:string);

begin

  ShowMessage(sMensagem);

end.

Tabela ASCII Delphi

ESC = 27
F1 = 112
F2 = 113
F3 = 114
F4 = 115
F5 = 116
F6 = 117
F7 = 118
F8 = 119
F9 = 120
F10 = 121
F11 = 122
F12 = 123
~ = 192
1 = 49
2 = 50
3 = 51
4 = 52
5 = 53
6 = 54
7 = 55
8 = 56
9 = 57
0 = 48
- = 189
= = 187
\ = 220
<- = 8
Tab = 0
A = 65
S = 83
D = 68
F = 70
G = 71
H = 72
J = 74
K = 75
L = 76
Q = 81
w = 87
E = 69
R = 82
T = 84
Y = 89
U = 85
I = 73
O = 79
P = 80
[ = 219
] = 221
CapsLock = 20
; = 186
' = 222
Shift = 16
Z = 90
X = 88
C = 67
vk_NumLock = $90;
vk_Scroll = $91;
V = 86
B = 66
N = 78
M = 77
, = 188
. = 190
/ = 191
Shift = 16
Ctrl = 17
Win = 91
Alt = 18
Barra = 32
Win = 92
Menu = 93
Ctrl = 17
PrintScreen = 0
ScollLock = 145
Pause = 19
Insert = 45
Home = 36
PageUp = 33
Delete = 46
End = 35
PageDown = 34
Esquerda = 37
Acima = 38
Direita = 39
Abaixo = 40
NumLock = 144
/ = 111
* = 106
- = 109
7 = 103
8 = 104
9 = 105
4 = 100
5 = 101
6 = 102
1 = 97
2 = 98
3 = 99
0 = 96
Del = 110
Enter = 13
vk_LButton = $01;
vk_RButton = $02;
vk_Cancel = $03;
vk_MButton = $04;
vk_Back = $08;
vk_Tab = $09;
vk_Clear = $0C;
vk_Return = $0D;
vk_Shift = $10;
vk_Control = $11;
vk_Menu = $12;
vk_Pause = $13;
vk_Capital = $14;
vk_Escape = $1B;
vk_Space = $20;
vk_Prior = $21;
vk_Next = $22;
vk_End = $23;
vk_Home = $24;
vk_Left = $25;
vk_Up = $26;
vk_Right = $27;
vk_Down = $28;
vk_Select = $29;
vk_Print = $2A;
vk_Execute = $2B;
vk_SnapShot = $2C;
vk_Insert = $2D;
vk_Delete = $2E;
vk_Help = $2F;
vk_NumPad0 = $60;
vk_NumPad1 = $61;
vk_NumPad2 = $62;
vk_NumPad3 = $63;
vk_NumPad4 = $64;
vk_NumPad5 = $65;
vk_NumPad6 = $66;
vk_NumPad7 = $67;
vk_NumPad8 = $68;
vk_NumPad9 = $69;
vk_Multiply = $6A;
vk_Add = $6B;
vk_Separator = $6C;
vk_Subtract = $6D;
vk_Decimal = $6E;
vk_Divide = $6F;
vk_F1 = $70;
vk_F2 = $71;
vk_F3 = $72;
vk_F4 = $73;
vk_F5 = $74;
vk_F6 = $75;
vk_F7 = $76;
vk_F8 = $77;
vk_F9 = $78;
vk_F10 = $79;
vk_F11 = $7A;
vk_F12 = $7B;
vk_F13 = $7C;
vk_F14 = $7D;
vk_F15 = $7E;
vk_F16 = $7F;
vk_F17 = $80;
vk_F18 = $81;
vk_F19 = $82;
vk_F20 = $83;
vk_F21 = $84;
vk_F22 = $85;
vk_F23 = $86;
vk_F24 = $87;

VK_LBUTTON Left mouse button
VK_RBUTTON Right mouse button
VK_CANCEL Control+Break
VK_MBUTTON Middle mouse button
VK_BACK         Backspace key
VK_TAB   Tab key
VK_CLEAR Clear key
VK_RETURN Enter key
VK_SHIFT Shift key
VK_CONTROL Ctrl key
VK_MENU         Alt key
VK_PAUSE Pause key
VK_CAPITAL Caps Lock key
VK_KANA         Used with IME
VK_HANGUL Used with IME
VK_JUNJA Used with IME
VK_FINAL Used with IME
VK_HANJA Used with IME
VK_KANJI Used with IME
VK_CONVERT Used with IME
VK_NONCONVERT Used with IME
VK_ACCEPT Used with IME
VK_MODECHANGE Used with IME
VK_ESCAPE Esc key
VK_SPACE Space bar
VK_PRIOR Page Up key
VK_NEXT         Page Down key
VK_END         End key
VK_HOME         Home key
VK_LEFT     Left Arrow key
VK_UP         Up Arrow key
VK_RIGHT Right Arrow key
VK_DOWN         Down Arrow key
VK_SELECT Select key
VK_PRINT Print key (keyboard-specific)
VK_EXECUTE Execute key
VK_SNAPSHOT Print Screen key
VK_INSERT Insert key
VK_DELETE Delete key
VK_HELP         Help key
VK_LWIN  Left Windows key (Microsoft keyboard)
VK_RWIN  Right Windows key (Microsoft keyboard)
VK_APPS  Applications key (Microsoft keyboard)
VK_NUMPAD0 0 key (numeric keypad)
VK_NUMPAD1 1 key (numeric keypad)
VK_NUMPAD2 2 key (numeric keypad)
VK_NUMPAD3 3 key (numeric keypad)
VK_NUMPAD4 4 key (numeric keypad)
VK_NUMPAD5 5 key (numeric keypad)
VK_NUMPAD6 6 key (numeric keypad)
VK_NUMPAD7 7 key (numeric keypad)
VK_NUMPAD8 8 key (numeric keypad)
VK_NUMPAD9 9 key (numeric keypad)
VK_MULTIPLY Multiply key (numeric keypad)
VK_ADD   Add key (numeric keypad)
VK_SEPARATOR Separator key (numeric keypad)
VK_SUBTRACT Subtract key (numeric keypad)
VK_DECIMAL Decimal key (numeric keypad)
VK_DIVIDE Divide key (numeric keypad)
VK_LMENU Left Alt key  (only used with GetAsyncKeyState and GetKeyState)
VK_RMENU Right Alt key  (only used with GetAsyncKeyState and GetKeyState)
VK_NUMLOCK Num Lock key
VK_SCROLL Scroll Lock key
VK_LSHIFT Left Shift key (only used with GetAsyncKeyState and GetKeyState)
VK_RSHIFT Right Shift key  (only used with GetAsyncKeyState and GetKeyState)
VK_LCONTROL Left Ctrl key  (only used with GetAsyncKeyState and GetKeyState)
VK_RCONTROL Right Ctrl key  (only used with GetAsyncKeyState and GetKeyState)
VK_PROCESSKEY Process key
VK_ATTN  Attn key
VK_CRSEL CrSel key
VK_EXSEL ExSel key
VK_EREOF Erase EOF key
VK_PLAY  Play key
VK_ZOOM  Zoom key
VK_NONAME Reserved for future use
VK_PA1   PA1 key
VK_OEM_CLEAR Clear key

VK_F1 F1 key
VK_F2 F2 key
VK_F3 F3 key
VK_F4 F4 key
VK_F5 F5 key
VK_F6 F6 key
VK_F7 F7 key
VK_F8 F8 key
VK_F9 F9 key
VK_F10  F10 key
VK_F11 F11 key
VK_F12 F12 key
VK_F13 F13 key
VK_F14 F14 key
VK_F15 F15 key
VK_F16 F16 key
VK_F17 F17 key
VK_F18 F18 key
VK_F19 F19 key
VK_F20 F20 key
VK_F21 F21 key
VK_F22 F22 key
VK_F23 F23 key
VK_F24 F24 key

Variavéis Delphi

Lista das Variaveis Delphi

Byte
0 a 255

Integer
-2.147.483.648 a 2.147.483.647

Cardinal
0 a 4.294.967.295

LongInt
-2.147.483.648 a 2.147.483.647

LongWord
0 a 4.294.967.295

ShortInt
-128 a 127

SmallInt
-32.768 a 32.767

Word
0 a 65.535

Int64
-2 63 a 2 63 -1

Reais (números em ponto flutuante):
Real
±5.0 x 10 -324 a 1.7 x 10 308

Double
±5.0 x 10 -324 a 1.7 x 10 308

Extended
±3.6 x 10 -4951 a 1.1 x 10 4932

Comp
-2 63 a 2 63 -1

Real48
2.9 x 10 -39 a 1.7 x 10 38

Single
±1.5 x 10 -45 a 3.4 x 10 38

Currency
-922.337.203.685,5808 a 2.337.203.685.477,5807

Caracteres e Strings:
Tipo

Char
1 Caractere

AnsiChar
1 Caractere

WideChar
1 Caractere

String
Até 255 Caracteres ou ~3 GB

ShortString
255 Caracteres

AnsiString
Até ~3 GB

WideString
Até ~1.5 GB

Booleanos:
Boolean
True ou False

Operadores Delphi

Operadores Delphi

*    - Multiplicação aritmética.
/     - Divisão de números que obtém um número real (exemplo: 5/2 = 2.5).
div - Divisão de números que obtém um número inteiro (exemplo: 5/2 = 2).
+    - Adição.
-     - Subtração.
=    - Igual.
<>  - Diferente.
>    - Maior.
>=  - Maior ou igual.
<    - Menor.
<=  - Menor ou igual.

Atalhos Delphi

A seguir a lista de alguns atalhos utéis:

F9 - compila o programa.

F8 - compila passo a passo.

F5 - adiciona um breakpoint.

F4 - compila até a linha que o cursor está.

F11 - Object Inspectot

F12 - Alterna entre o modo Code e design

Ctrl+Espaço - Abre uma lista de variáveis e procedimentos disponiveis.

Ctrl + Shift + C - Adiciona a Declaração de uma função ou procedimento.

Ctrl+Shift+I: Indentar multiplas linhas de código de uma única vez em "n" espaços. 

Ctrl+Shift+U: Recuar indentação em "n" espaços (ídem acima).

Alt+G: Ir para uma determinada linha.

Ctrl+Mouse: Clique com o botão esquerdo do mouse mantendo pressionada a tecla Ctrl sobre a chamada a uma procedure/function/variável para localizá-la na unit atual ou em outra unit.

Ctrl+F12 - Lista as Units do projeto. 

Shift+F12 - Lista os Forms do projeto. 

Ctrl+S - Salvar.

Ctrl+Tab - Permite alternar entre as Units abertas. 

Ctrl+K+O - Letras em minusculo.

Ctrl+K+N - Letras em maiúsculo.

Primeiro Programa com Delphi

Vamos por a mão na massa.
Criar uma nova aplicação.(Talvez o visual do delphi esteja um pouco diferente mais em breve ensinarei a alterar esses detalhes).

File - New - VCL Form Application.

Apareceu isso.

Próximo passo adicionar um botão (Encontra - se na aba lateral, no meu caso inferior direito, pode ser acessa pelo caminho),

Para adicionar, duplo clique no botão ou clique e arrate pra tela...

Adicionado vamos mudar a propriedade Caption do botão, ou seja a descrição dele.

Depois de um duplo clique sobre ele, aparecerá a tela onde você digitará o código para essa ação.

Note que Abaixo mudou a Aba, foi de design, para code.

Observe a linha 26, automaticamente, o dar o duplo clique no botão foi criado a seguinte linha:

procedure TForm1.Button1Click(Sender: TObject);

procedure - indica que é um procedimento.

TForm1 - indica que está que este procedimento está criado no Formulario TForm1.

.Button1Click - Button1(essa é um propriedade diferente de Caption, não confundir)  é o nome do botão adicionado, Click é a ação que esse procedimento é executado ou seja é executado na tela TForm1 no clique do Button1.

Esse procedimento nada mais é do que um evento criado automaticamente e pode ser acessado pela aba Events da tela Object Inspector(a mesma das propriedades)

Atenção esses eventos são criados quando se da um duplo clique sobre algum componente da tela, nas próximas postagens ensinarei a criar procedimentos específicos para realizar algumas ações no programa.

Vamos por o código para mostrar uma mensagem qualquer neste evento.

escreva no evento   ShowMessage('Mensagem qualquer!!');

Assim: 

Entendendo: Você criou um programa que tem uma tela chamada Form1, nessa tela você adicionou um botão com o nome Button1 e a descrição Olá, você deu um duplo clique nele ele criou um evento automaticamente, o procedure TForm1.Button1Click(Sender: TObject);

nesse evento você adicionou um código para mostrar um mensagem qualquer.

esse código, para mostrar a mensagem é originalmente escrito assim ShowMessage( );

se adicionar só isso dará um erro, pois falta a mensagem, então dentro dos parenteses e com aspas simples você coloca a mensagem desejada exemplo: 

ShowMessage('Olá Mundo!');

ShowMessage('Primeiro Programa com Delphi!');

ShowMessage('Divulgue meu blog!');

entre outras.

Assim está pronto nosso primeiro exemplo.

Vamos salvar, clique em Save All no menu File, e neste primeiro exemplo não precisa mudar o nome é só salvar cada arquivo. Lembre - se, é aconselhável você criar uma pasta pra cada projeto pra não gerar confusão.  

Se nada deu errado aparecerá 2 arquivos para você salvar, o Project1 e a Unit1.pas

Agora vamos Compilar ele ou seja gerar um executável para testar. 

Aperte a tecla F9 ou clique no icone verde na barra de ferramentas

Durante alguns segundos aparecerá: 

Automaticamente seu programa iniciará:

Clique no botão para ver o resultado.

Se tudo ocorreu bem dever deverá acontecer algo assim:

Pois bem esse foi o primeiro programa super básico, agora você pode brincar com as propriedades do botão, e da tela para aprender mais, em breve estarei postando novas aulas com novos recursos, aumentando o nível de aprendizado, caso tenha acontecido algo errado, você pode baixar o projeto no link abaixo e ver o que deu errado.

Dicas:

  Altere as propriedades Color, Caption, Border da tela para personalizar a aplicação.

  Adicione novos botões com novos eventos e novos Captions.

  Altere o tamanho da tela.

  Explore novos eventos como OnMouseMove na tela de Events do Botão.

  Envés de por ShowMessage() coloque: Close;

Etc.

Até a próxima postagem!!!

LINK PARA DOWNLOAD

Nos ajude a crescer, divulgue nosso blog, duvidas pedidos, reclamações mande um e-mail para ffabricadesoftware@gmail.com

Inicio - Conhecendo o Delphi

 Delphi, é uma linguagem de programação, produzido antigamente pela Borland Software Corporation e atualmente produzido pela Embarcadero. O Delphi, originalmente direcionado para a plataforma Windows, chegou a ser usado para desenvolvimento de aplicações nativas para Linux através do Kylix (o Kylix é um IDE para as linguagens C++ e Object Pascal), e para o framework Microsoft .NET em suas versões mais recentes. O desenvolvimento do Kylix foi descontinuado.
Origem Wikipedia

Depois dessa introdução basica patimos para prática:
Interface:

Object Inspector: Nessa Tela normalmente do lado esquerdo da tela se encontram as propriedades de cada elemento do seu programa, exemplo: ao adicionar um botão nesta tela você pode alterar a cor, tamanho, descrição, fonte e muitas outras propriedades além de eventos como por exemplo adicionar uma ação ao clicar no botão.

Unit1.pas: é o nome de arquivo da sua tela porem aqui você digitará o código (progamará).

Form1 : é o nome da tela onde você colocará os botões, a Unit1 está ligada ao Form1, no momento que você cria a tela essas duas telas aparecem automaticamente.

Acima você encontra a barra de ferramentas, nas próximas postagens você ficará sabendo mais sobre ela.