Programação Pc

Prévia do material em texto

UNIVERSIDADE DE SÃO PAULO
ANDRE ALEXANDRINO SANTOS
PROGRAMAÇÃO DE COMPUTADORES
SÃO PAULO
2020
ANDRE ALEXANDRINO SANTOS
CÓDIGOS E LINGUAGENS DE PROGRAMAÇÃO
Trabalho com uso de três linguagens de programação
SÃO PAULO
2020
Sumário
Declaração de Variáveis	4
Regras para criação de identificadores	4
Exemplos de nomes de variáveis	4
Declaração de Variáveis	5
Inicialização de Variáveis	5
Atribuição de valores a variáveis	6
Exemplo completo de declaração e atribuição de variáveis em Java	6
Precedência dos Operadores	6
Exemplo de utilização	7
Tomada de decisão e Repetição	8
Blocos de comando	8
Tomada de Decisão	9
IF/ELSE	9
SWITCH/CASE	10
Laços de repetição	12
WHILE(enquanto)	12
DO/WHILE (repita)	13
FOR (para)	14
Atribuindo	16
Finalizando	18
Operador de Atribuição	19
Operadores Aritméticos	21
Ordem de operações matemáticas	22
Operadores Aritméticos de Atribuição Reduzida	23
Operadores incrementais e decrementais	24
Operadores Relacionais	27
Operadores Lógicos	29
Operadores Ternários	30
JAVA
Declaração de Variáveis
Nesta lição vamos mostrar como declarar e utilizar variáveis em Java. Uma variável é uma estrutura que permite armazenar dados na memória durante a execução do programa, para processamento de informações.
Todas as variáveis devem ser declaradas antes que possam ser usadas. Declarar uma variável significa criá-la em algum ponto do programa
A linguagem Java é fortemente tipada. Isso significa que cada variável obrigatoriamente deve ter um tipo declarado antes que possa ser utilizada.
Regras para criação de identificadores
Para criar um identificador (nome da variável) em Java, precisamos seguir algumas regras, listadas a seguir:
· Deve conter apenas letras, _ (underline), $ ou os números de 0 a 9
· Deve obrigatoriamente se iniciar por uma letra (preferencialmente), _ ou $
· Deve iniciar com uma letra minúscula (boa prática – ver abaixo)
· Não pode conter espaços
· Não podemos usar palavras-chave da linguagem
· O nome deve ser único dentro de um escopo
Além disso, o Java é case sensitive, o que significa que os nomes de variáveis diferenciam maiúsculas de minúsculas.
Como boa prática, sempre utilize a notação CamelCase do tipo lowerCamelCase, na qual nomes de variáveis compostos por múltiplas palavras devem ser compostas por letras minúsculas, a inicial da primeira palavra também em minúscula, e as iniciais das demais palavras em maiúsculas.
Exemplos de nomes de variáveis
Válidos:
· nomeCliente
· telefone_1
· preco$
· produtoAdquirido
Inválidos:
· 1Telefone
· Nome Cliente
· #Preço
Declaração de Variáveis
Vejamos como proceder para realizar a declaração de variáveis em Java.
Sintaxe:
tipo identificador [= valor];
onde tipo é o tipo de dado que a varável irá armazenar, identificador é seu nome, e valor é o valor inicial atribuído à variável, o qual é opcional (denotado pelos colchetes, que não devem ser digitados na declaração).
Exemplos de declaração:
byte a;char t;int valor;float x, y;int dia = 20;char sexo = ‘F’;String nome = “Fábio”;
Inicialização de Variáveis
A inicialização de uma variável durante sua declaração é opcional. Caso a variável não seja inicializada, poderá um valor padrão, que depende de seu tipo declarado:
· boolean: false
· byte, short, int, long, float, double: 0
· char: \u0000
Atribuição de valores a variáveis
Para atribuir um valor a uma variável, devemos usar o operador de atribuição =
Veja os exemplos de atribuições a seguir:
byte a = 45;char t = ‘T’;int valor = 200;float x = 98.80;char sexo = ‘F’;int dia;  // variável declarada e não inicializadadia = 20; // variável atribuída agora
Exemplo completo de declaração e atribuição de variáveis em Java
public static void main(String[] args) { boolean VouF = true; byte a; char letra = 'F'; int valor = 4500; double x = 3.14; a = 20; System.out.printf("Valor de VouF (boolean): %b\n", VouF); System.out.printf("Valor de a (byte): %d\n", a); System.out.printf("Valor de letra (char): %c\n", letra); System.out.printf("Valor de valor (int): %d\n", valor); System.out.printf("Valor de x (double): %2.2f\n", x);}
Operadores Aritméticos, Relacionais e cálculos
A linguagem Java provê operadores para as operações matemáticas básicas que são a adição (+), subtração (-), multiplicação (*) e divisão (/). Além desses operadores, existe um operador para o resto da divisão (%):
	Operador
	Descrição
	+
	Operador de Adição – Pode ser utilizado para concatenar Strings
	–
	Operador de Subtração
	*
	Operador de Multiplicação
	/
	Operador de Divisão
	%
	Operador de Resto de Divisão
Precedência dos Operadores
Os operadores de multiplicativos são resolvidos primeiro pelo compilador. Os operadores aditivos são resolvidos logo após, conforme mostra a tabela abaixo:
	Ordem
	Tipo de Operador
	Precedência
	1
	Multiplicativo
	*  /  %
	2
	 Aditivo
	+  –
Exemplo de utilização
Abaixo temos uma classe de exemplo que trabalha com os operadores aritméticos:
Java
	1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
	package br.com.mauda.operadores;
 
public class OperadoresAritmeticos {
 
    public static void main (String[] args) {
 
        int resultado = 1 + 2;
        System.out.println("1 + 2 = " + resultado);
        int resultadoOriginal = resultado;
 
        resultado = resultado - 1;
        System.out.println(resultadoOriginal + " - 1 = " + resultado);
        resultadoOriginal = resultado;
 
        resultado = resultado * 2;
        System.out.println(resultadoOriginal + " * 2 = " + resultado);
        resultadoOriginal = resultado;
 
        resultado = resultado / 2;
        System.out.println(resultadoOriginal + " / 2 = " + resultado);
        resultadoOriginal = resultado;
 
        resultado = resultado + 8;
        System.out.println(resultadoOriginal + " + 8 = " + resultado);
        resultadoOriginal = resultado;
 
        resultado = resultado % 7;
        System.out.println(resultadoOriginal + " % 7 = " + resultado);
    }
}
Tomada de decisão e Repetição
Neste artigo iremos abordar o uso das estruturas de seleção e repetição, suas propriedades e aplicações em exemplos de código em Java.
As estruturas de seleção são essenciais para criar tomadas de decisão em nossos algoritmos, com essa ferramenta em mãos podemos verificar se uma afirmação é verdadeira ou falsa e agir de acordo.
As estruturas de repetição são responsáveis pela repetição de blocos de comando. Elas repetem os blocos por quantas vezes desejarmos e cada um dos tipos de estrutura possui um modo próprio de parar a repetição.
Acompanhe mais detalhes nos tópicos abaixo:
Blocos de comando
· São grupos de comandos que devem ser tratados como uma unidade lógica.
· O início de um bloco em Java é marcado por um “{“e o término por um”}”.
· Serve para criar um grupo de comandos que devem ser executados juntos.
· Usa-se quando comandos de teste devem escolher entre executar dois blocos de comandos.
· Pode ser utilizado em qualquer trecho de programa que usará um comando Java.
· Os comandos de controle especificam a ordem em que a computação é feita no programa.
· 
Tomada de Decisão
A tomada de decisão é extremamente importante na execução dos programas. São elas que dão a “inteligência” ao sistema.
Em Java, temos dois blocos de tomadas de decisão: o IF / ELSE e o SWITCH / CASE .
IF/ELSE
O bloco IF/ELSE é o mais utilizado pois aceita qualquer condição e assim sendo mais utilizado que o SWITCH.
Sua sintaxe é a seguinte:
if(<condição>) {
}
Onde na condição colocaremos uma equação lógica ou um valor booleano (variável, método com retorno lógico). Se a condição for verdadeira, o que estiver dentro do bloco será executado.
Esse é um bloco simples, onde só se executa uma ação onde tal condição for verdadeira. Mas podemos forçar outra ação se a condição for falsa. Veja como: 
if(<condição>) {
}else{                  
}  
Nesse caso, o bloco else (se não) será executado se a condição do if(se) for falsa. Podemos ainda alinhar mais blocos, permitindo mais condiçõesa serem avaliadas. Veja o exemplo:
(Podem ser utilizados quantos if/else for preciso).
  “A forma if. . .else permite expressar duas alternativas de execução, uma para o caso da condição” - UNICAMP, Apostila Java, Orientação a Objeto.
Exemplo do uso de “IF/ELSE”:
Desenvolver programa que peça ao usuário para cadastrar uma senha; na sequência, deve pedir ao usuário que digite duas variáveis reais e irá calcular a divisão da primeira pela segunda. O programa irá pedir ao usuário que digite sua senha, se estiver correta ela mostra o resultado da divisão. Se não, dá mensagem de erro e encerra o aplicativo.
SWITCH/CASE
O comando SWITCH é um comando mais simples e organizado, porém muito limitado.
Não podemos utilizar condições lógicas, apenas tipos primitivos (inteiros, reais e caracteres isolados) são aceitos.
Sua estrutura é a seguinte:
Switch (<equação ou variável>) {
 case <variável primitiva>:
 break;
case <variável primitiva>:
break;
}
“O comando switch...case também expressa alternativas de execução, mas nesse caso as condições estão restritas à comparação de uma variável inteira com valores constantes” - UNICAMP, Apostila Java, Orientação a Objeto.
Exemplo do uso de “switch/case”:
Utilizando a estrutura switch, faça um programa Java que receba um número do
usuário de 1 a 12 e retorne o valor do mês correspondente. Ex: Para a entrada 5
gerar a saída MAIO. Para a entrada 11 gerar a saída NOVEMBRO. Se o valor
de entrada for diferente do intervalo 1-12, gerar a saída INVÁLIDO.
Laços de repetição
Na linguagem Java, possuímos três blocos de repetição. É a recursividade que já passa a ser uma estrutura de algoritmo em vez de uma estrutura da linguagem.
Os três comandos são: WHILE, DO/WHILE e FOR. 
WHILE(enquanto)
O comando while verifica uma condição lógica primeiro e depois executa as ações que estão contidas em seu bloco.
Sua sintaxe é a seguinte: 
while(<condição lógica>){
...comandos...
 }
 
Tudo se repetirá até a condição se tornar falsa. No while não está garantido que seus comandos serão executados pelo menos uma vez porque antes da execução existe uma condição que verifica se o bloco pode ser executado. 
A utilização do while se torna mais útil quando precisamos repetir algo que não seja fixo, algo irregular. Por exemplo, um comando que controla um menu de usuário, onde não sabemos quando o usuário vai fechar o menu.
“O while é um comando usado para fazer um laço (loop), isto é, repetir um trecho de código algumas vezes. A ideia é que esse trecho de código seja repetido enquanto uma determinada condição permanecer verdadeira.” - CAELUM, Apostila Java, Orientação a Objeto.
Exemplo de exercício no uso de “while”:
Programa que calcule a média de salários de uma empresa, pedindo ao usuário a grade de funcionários e os salários em JOptionPane e devolvendo a média.
DO/WHILE (repita)
O comando do/while executa primeiro o bloco e depois verifica a condição lógica. A sintaxe é a seguinte:
do {
 ...comandos...
}while (<condição lógica>);
Todo o bloco se repetirá até a condição se tornar falsa. No do/while, pelo menos uma vez o bloco será executado. Ele executará todo o bloco e depois verificará a condição. Diferente do while, que verificava antes de executar. 
Exemplo do uso de “DO/WHILE”:
Desenvolva um algoritmo que  peça um input em formato String do usuário e que continue repetindo enquanto o input for igual a “churros”.
FOR (para)
O comando for é uma estrutura onde possui todo o controle na sua assinatura. Nela podemos declarar variáveis, verificar condições e incrementar valores à variável de controle.
A sintaxe é a seguinte:
for (<declara variável>; <condição de controle>; <incrementa a variável>){
...comandos... 
}
 
A aplicação do comando for seria ideal quando possuímos um controle exato da repetição, como por exemplo, quando sabemos que iremos percorrer um vetor ou um número certo de repetições. Caso contrário, o ideal seria o while.
Exemplo do uso de “FOR”:
Faça um programa em java que armazene um conjunto de  múltiplos de 10 até 50 e que ao processar o valor “30”, o programa encerre.
C#
Declaração de Variavel
Antes de usar uma variável, você precisa obrigatoriamente declará-la e especificar seu nome e características. O nome de uma variável é referenciado como um identificador. Em C# existem regras específicas na criação de um identificador:
· Um identificador pode conter apenas letras, números e underscore (_);
· Um identificador precisa começar com uma letra ou underscore;
· Um identificador de variável não pode ser uma das palavras chaves que o C# reserva para seu uso.
C# é case sensitive. Isto significa que letras minúsculas são diferentes de letras maiúsculas.
Se você utilizar MeuRegistro como identificador de uma variável, é diferente de meuRegistro. Você pode declarar duas variáveis ao mesmo tempo chamados MeuRegistro e meuRegistro e o C# não irá confundi-los, apesar disto não ser uma boa prática de programação.
Quando declarar variáveis você pode usar nomes significativos, que façam sentido na sua lógica. Isso faz com que seu código seja mais fácil de entender. Lembre-se que estamos desenvolvendo software profissionalmente, então um outro desenvolvedor pode assumir a manutenção/evolução do seu código e demorar a entender o que foi feito (eu já peguei cada código-salada que é até difícil acreditar que ele consiga ser executado…).
Desta forma, adote uma regra para nomear variáveis (existem algumas bastante utilizadas por aí, mas isso fica para um futuro artigo) e vá em frente!
 Declarando
Quando você declara uma variável, é reservado um espaço na memória para ela e o tipo de dado que ela guarda. Você pode declarar várias variáveis em uma só declaração utilizando a vírgula (,) como separador. Todas as variáveis declaradas desta maneira serão do mesmo tipo.
O exemplo abaixo mostra como declarar uma nova variável:
// TipoDado nomeVariavel;
int idade;
// ou
// TipoDado nomeVariavel01, nomeVariavel02;
int idade, dia;
 
Atribuindo
Depois de declarar uma variável, você pode lhe atribuir um valor a ela. Você pode alterar o valor dela quantas vezes forem necessárias durante a execução da aplicação. O operador de atribuição = faz essa atribuição de valor.
O código abaixo mostra como utilizar o operador = para atribuir um valor a uma variável:
// nomeVariavel = valor;
idade = 30;
O valor do lado direito da expressão é atribuída a variável do lado esquerdo da expressão.
Você pode também declarar uma varável e ao mesmo tempo atribuir um valor a ela.
O código abaixo declara um inteiro de nome idade e atribui o valor 30:
int idade = 30;
Quando uma variável é declarada, seu conteúdo é um valor desconhecido até que você atribua um valor a ela.
Isto é o motivo de frequentes bugs em programas C e C++. Criar variáveis e acidentalmente utilizar seu conteúdo antes de lhe atribuir um valor.
O C# impede você de utilizar uma variável que ainda não foi atribuído nenhum conteúdo. É necessário atribuir um valor antes de usá-la, senão seu programa não será compilado;
 Variáveis de tipo implícito
Quando declarar variáveis, você também pode usar a palavra chave var ao invés de especificar explicitamente o tipo de dado com int ou string. Quando o compilador vê a palavra chave var, ele usa o valor atribuído para a variável para determinar seu tipo.
O exemplo abaixo mostra como utilizar a palavra chave var para declarar uma variável
var idade = 20;
Neste exemplo, a variável idade é do tipo implícito. Entretanto, utilizar a palavra chave var não significa que você pode atribuir um valor de tipo diferente depois. O tipo da variável idade é fixa, como se você a tivesse declarado como um inteiro (int).
Variáveis de tipo implícito são uteis quando você não sabe ou é difícil estabelecer explicitamente o tipo de uma expressão que você quer atribuir a uma variável.
 Variáveis objeto
Quando você declara uma variável tipo objeto, ele é iniciado sem atribuição. Para utilizar este objeto é necessário criar uma instância de sua classe correspondente (usando o operador new) e atribui-lo a variáveltipo objeto.
O operador new faz duas coisas: faz o CLR alocar memória para seu objeto e então chama um construtor para inicializar os campos deste objeto. A versão do construtor que será executado depende de parâmetros especificados para o operador new.
O código abaixo mostra como criar uma instância de uma classe utilizando o operador new:
ConfiguracaoServico config = new ConfiguracaoServico();
 
Finalizando
Vimos aqui as regras básicas de declaração e atribuição de variáveis.
Em C# precisamos declarar e atribuir um valor antes de poder utilizar uma variável.
Não podemos começar o nome de uma variável com número e nem utilizar uma das palavras chave da linguagem.
Podemos declarar implicitamente uma variável com a palavra chave var, porém precisamos atribuir algo a ela. O tipo do objeto atribuído a ela será utilizado para “tipar” a variável. Aguardem outro artigo detalhando melhor este tipo de declaração de variável.
No caso de variáveis tipo objeto, utilizamos a palavra chave new para lhe atribuir uma nova instância da classe.
Operadores Aritmeticos, Relacionais e calculos
Neste artigo veremos os conceitos e exemplos com os Operadores da linguagem C#. Começaremos com os operadores de atribuição, aritméticos e aritméticos de atribuição reduzida.
Os operadores indicam o tipo de operação que será executada, gerando assim novos valores a partir de um ou mais operandos (itens à direita ou à esquerda do operador). Geralmente, o resultado é do tipo booleano (boolean) ou numérico (int, decimal, double). É importante sabermos como usá-los e é isso que vamos aprender a partir de agora.
Operador de Atribuição
O símbolo igual (=) representa a atribuição de um valor à uma variável, onde ela e o valor atribuído devem obrigatoriamente ser de tipos compatíveis, ou seja, uma variável do tipo int por exemplo não pode receber um valor do tipo string (a menos que usemos as conversões, mas vamos deixar isso mais para frente).
Veja a sintaxe: variável = atribuição;
A Listagem 1 deixa tudo mais claro (feito dentro do método Main, em uma Console Application).
	1
2
3
4
5
6
7
8
9
10
11
	//variável idade recebe o valor 21
int idade = 21;
 
//declaro variável maiorIdade como boolean
bool maiorIdade;
 
//exibe ambos em tela, atribuindo valor ao booleano
Console.WriteLine("\n" + idade + "\n");
Console.WriteLine(maiorIdade = true);
 
Console.ReadKey();
Listagem 1. Operadores de Atribuição
O resultado do código acima é o seguinte:
Podemos também atribuir uma variável primitiva a outra variável primitiva. Veja no exemplo da Listagem 2.
	1
2
	int a = 10;
int b = a;
Listagem 2. Atribuição de variáveis
Assim, temos duas situações: primeiro a recebe o valor 10, depois b recebe a variável a. Portanto, podemos dizer que a variável b contém o valor 10.
Os conceitos acima são de Tipos por Valor e por Referência.
Operadores Aritméticos
Os operadores aritméticos descritos na Tabela 1 são os mesmos usados em cálculos matemáticos.
	Operador Aritmético
	Descrição
	+
	Adição
	-
	Subtração
	*
	Multiplicação
	/
	Divisão
	%
	Módulo (resto da divisão)
Tabela 1. Operadores aritméticos
Veja na Listagem 3 o exemplo com o uso dos cinco operadores da tabela.
	1
2
3
4
5
6
7
	int a = 5, b = 10, c = 15, d = 20; // declaramos quatro variáveis do tipo int
Console.WriteLine(a + d); // operação de soma
Console.WriteLine(c - a); // operação de subtração
Console.WriteLine(b * c); // operação de multiplicação
Console.WriteLine(d / b); // operação de divisão
Console.WriteLine(c % b); // operação de módulo (resto de divisão)
Console.ReadKey();
Listagem 3. Operadores aritméticos
No código acima realizamos as operações aritméticas:
· soma dos valores das variáveis a e d (a + d)
· subtraímos o valor da variável a do valor da variável c (c - a)
· multiplicamos o valor da variável b pelo valor da variável c (b * c)
· dividimos o valor da variável d pelo valor da variável b (d / b)
· obtemos o resto da divisão do valor da variável c pelo valor da variável b (c % b)
e em cada operação temos como resultado um valor inteiro que será exibido no prompt de comando.
O resultado do código acima é o seguinte:
Ordem de operações matemáticas
Em uma expressão matemática existe uma ordem para executar as operações. A linguagem C# respeita esta ordem em que as operações de multiplicação e divisão serão executadas antes de operações de soma e subtração. A ordem pode ser forçada pelo uso de parênteses. Por exemplo, se colocarmos uma soma entre parênteses ela será executada antes de uma multiplicação em uma mesma expressão. Veja dois exemplos na Listagem 4.
	1
2
3
4
	int a = 5, b = 10, c = 15, d = 20;
Console.WriteLine(a + b * c); // a operação de multiplicação será executada primeiro
Console.WriteLine((a + b) * c); // a operação de soma será executada primeiro porque está entre parênteses
Console.ReadKey();
Listagem 4. Ordem de operações matemáticas
No código acima temos as operações:
· multiplicamos o valor da variável b pelo valor da variável c e somamos com o valor da variável a (a + b * c)
· somamos o valor da variável a com o valor da variável b, que está entre parênteses, e multiplicamos pela variável c ((a +b) * c)
A primeira operação segue a ordem de precedência e a segunda operação força a ordem com parênteses.
Operadores Aritméticos de Atribuição Reduzida
Esses operadores são usados para compor uma operação aritmética e uma atribuição, conforme é descrito na Tabela 2.
	Operador Aritmético
	Descrição
	+ =
	mais igual
	- =
	menos igual
	* =
	vezes igual
	/ =
	dividido igual
	% =
	módulo igual
Tabela 2. Operadores Aritméticos de Atribuição Reduzida
Na Listagem 5 é acrescentado o valor 10 a variável x.
	1
2
3
4
	int x = 5;
x += 5; // é a mesma coisa que x = x + 5
Console.WriteLine("Valor do x = " + x);
Console.ReadKey();;
Listagem 5. Exemplo de Operadores Aritméticos de Atribuição Reduzida
O resultado do código acima é o seguinte:
Devemos usar operadores de atribuição desta forma, como boa prática, já que é implementado de uma forma mais eficiente pelo compilador, e ainda temos a economia de código.
Operadores incrementais e decrementais
Os operadores incrementais e decrementais têm a função de aumentar ou diminuir exatamente em 1 o valor de uma variável. Eles podem ser pré ou pós incremental e pré ou pós decremental. Veja os conceitos de cada um deles e um exemplo prático a seguir:
· Incremental (++):
1. Pré incremental ou prefixo – Significa que, se o sinal for colocado antes da variável, primeiramente será somado o valor 1 para esta variável, continuando em seguida a resolução da expressão.
1. Pós incremental ou sufixo – Significa que, se o sinal for colocado após a variável, é resolvido primeiro a expressão, seja ela adição, subtração, multiplicação ou qualquer outra, para em seguida ser adicionado o valor 1 à variável.
· Decremental (--)
2. Pré incremental ou prefixo – Significa que, se o sinal for colocado antes da variável, primeiramente será subtraído o valor 1 para esta variável, continuando em seguida a resolução da expressão.
2. Pós incremental ou sufixo – Significa que, se o sinal for colocado após a variável, é resolvido primeiro a expressão, seja ela adição, subtração, multiplicação ou qualquer outra, para em seguida ser subtraído o valor 1 à variável.
Como prometido, veja o exemplo na LIstagem 6.
	1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
	Console.WriteLine("Pré-Incremento:\n");
 
int x = 0;
Console.WriteLine("x = " + x);
 
Console.WriteLine("\n++x +20 = \n");
Console.WriteLine(++x +20 + "\n");
 
Console.WriteLine("\nPós-Incremento:\n");
x = 0;
 
Console.WriteLine("\nx++ +20 = \n");
Console.WriteLine(x++ + 20 + "\n");
 
Console.WriteLine("\nPré-Decremento:\n");
x = 0;
 
Console.WriteLine("x = " + x);
 
Console.WriteLine("\n--x +20 = \n");
Console.WriteLine(--x + 20 + "\n");
 
Console.WriteLine("\nPós-Decremento:\n");
x = 0;
 
Console.WriteLine("\nx-- +20 = \n");
Console.WriteLine(x-- + 20 + "\n");
 
Console.ReadKey();
Listagem 6. Exemplo de pré-incremento
Após a compilação, esse será o resultado:Dica: use o Breakpoint no código acima, assim você pode ver passo-a-passo todo o processo de incremento e decremento da variável x.
Operadores Relacionais
Os operadores relacionais comparam dois valores e retornam um valor booleano (true ou false). Veja na Tabela 3 esses operadores.
	Operador Relacional
	Descrição
	==
	Igual a
	!=
	Diferente de
	>
	Maior que
	<
	Menor que
	>=
	Maior do que ou igual a
	<=
	Menor do que ou igual a
Tabela 3. Operadores relacionais
O exemplo da Listagem 7 ajuda a ilustrar o uso destes operadores.
	1
2
3
4
5
6
7
8
9
10
	int a = 10, b = 25, c = 50, d = 100; // declaramos quatro variáveis de tipo int
 
Console.WriteLine(a == d); // avaliamos a igualdade entre a e d
Console.WriteLine(b != c);  // avaliamos a desigualdade entre b e c
Console.WriteLine(a > b); // avaliamos se a é maior que b
Console.WriteLine(c < d);  // avaliamos se c é menor que d
Console.WriteLine(c >= a); // avaliamos se c é maior ou igual que a
Console.WriteLine(d <= b); // avaliamos se d é menor ou igual que b
 
Console.ReadKey();
Listagem 7. Exemplo de operadores relacionais
No código acima fazemos as seguintes avaliações:
· se a variável a é igual a variável d (a == d)
· se a variável b é diferente da variável c (b != c)
· se a variável a é maior que a variável b (a > b)
· se a variável c é menor que a variável d (c < d)
· se a variável c é maior ou igual que a variável a (c >= a)
· se a variável d é menor ou igual que a variável b (d <= b)
e a cada avaliação teremos um resultado do tipo lógico true ou false que será exibido no prompt de comando.
Após compilarmos o código acima, o resultado é esse:
Operadores Lógicos
Os operadores lógicos trabalham como operandos booleanos e seu resultado também será booleano (true ou false). Eles são usados somente em expressões lógicas, e são descritos na Tabela 4.
	Operador Lógico
	Descrição
	&&
	AND = E
	||
	OR = Ou
	!
	NOT = Não
Tabela 4. Operadores lógioos
Assim, em um teste lógico usando o operador && (AND), o resultado somente será verdadeiro (true) se todas as expressões lógicas forem avaliadas como verdadeiras.
Já, se o operador usado for o || (OR), basta que apenas uma das expressões lógicas seja verdadeira para que o resultado também seja verdadeiro.
Completando, o operador lógico ! (NOT) é usado para gerar uma negação. Desta forma, é invertida toda a lógica da expressão.
Veja o exemplo na Listagem 8 e o resultado em seguida.
	1
2
3
4
5
6
7
	int a = 5, b = 10, c = 15, d = 20; // declaramos quatro variáveis do tipo int
 
Console.WriteLine(a == 5 && d == 10); // avaliamos se a é igual a 5 e se d é igual a 10
Console.WriteLine(c < b || d == 20); // avaliamos se c é menor que b ou se d é igual a 20
Console.WriteLine(! (b > a)); // negamos que b é maior que a
 
Console.ReadKey();
Listagem 8. Exemplo de operadores lógicos
No código acima fazemos as avaliações:
· se a variável a é igual a 5 E se a variável d é igual a 10 (a ==5 && d == 10)
· se a variável c é menor que a variável b OU se a variável d é igual a 20 (c < b || d == 20)
· nega o resultado da avaliação se a variável b é maior que a variável a (! (b>a))
e a cada avaliação o resultado será do tipo lógico, true ou false que será exibido no prompt de comando.
O resultado pode ser visto a seguir:
Operadores Ternários
O operador ternário é composto por três operandos separados pelos sinais ? e : e tem o objetivo de atribuir o valor a uma variável de acordo com o resultado de um teste lógico. A sintaxe dele é: teste lógico ? valor se verdadeiro : valor se falso;
Onde:
· teste lógico é qualquer valor ou expressão, que pode ser verdadeiro ou falso.
· valor se verdadeiro é atribuído ao valor true;
· valor se falso é atribuído ao valor false.
Finalizando, veja o exemplo na Listagem 9 e o resultado em seguida.
	1
2
3
4
5
6
	int x = 5, y = 10; // declaradas duas variáveis de tipo int
 
Console.WriteLine(x < y ? "sim" : "não"); // expressão x < y é avaliada
// se for verdadeira exibe "sim"
// se não for verdadeira exibe "não"
Console.ReadKey();
Listagem 9. Exemplo de operadores ternários
No código acima avaliamos se o valor da variável x é menor do que o valor da variável y (x < y) e se for menor será exibido o texto "sim" e se não for menor será exibido o texto "não".
O resultado é apresentado a seguir:
Estrutura de decisão e repetição
Neste quarto artigo da série vamos aprender sobre estruturas de decisão da linguagem C#. Basicamente temos dois tipos básicos de instruções de decisão:
if... else;
switch.. case.
if... else
A instrução "if...else" é usada para executar blocos de código condicionalmente através de uma expressão Booleana ( verdadeiro ou falso ). A clausula "else" é opcional e seu conteúdo será executado somente se o resultado da expressão booleana for false ( falso ). Veja o exemplo:
If ( a == 5 )
 System.Console.WriteLine("a é igual a 5");
else
 System.Console.WriteLine("a é diferente de 5");
No código acima na instrução "if" ( Se ) fazemos uma verificação muito simples, onde testamos se "a" é igual a "5" caso seja verdadeiro ( true ) o código logo abaixo é executado, ou seja: "System.Console.WriteLine("a é igual a 5");". Caso o resultado dessa expressão lógica seja falso, ou seja, "a" não seja igual a "5" o código do bloco "else" (se não) será executado, nesse caso: "System.Console.WriteLine("a é diferente de 5");".
Para casos onde nosso código tem mais de uma linha ( o que é mais comum ) devemos usar as chave "{" e "}" para delimitarmos os blocos if e/ou else, veja:
if ( a == 5 && b != 2 )
{
 System.Console.WriteLine("a é igual a 5");
 System.Console.WriteLine("b é diferente a 5");
}
Neste caso temos uma verificação composta, ou seja, verificamos duas condições se "a" é igual a "5" E(&&) se "b" é diferente de "2" essa condição só resultará em verdadeiro caso as duas condições sejam verdadeiras pois estamos usando o operador lógico "&&".
else if
A instrução "else if" é usada quando temos varias condições e pra cada condição temos códigos diferentes, ou seja, fazemos coisas diferentes para cada caso veja o exemplo:
if ( a== 1)
{
 // perceba que mesmo com uma linha só de código eu posso usar os delimitadores
 System.Console.WriteLine("a é igual a 1");
}
else if ( b ==2 )
{
 System.Console.WriteLine("b é igual a 2");
}
else if( c ==3 )
{
 System.Console.WriteLine("c é igual a 3");
}
else
{
 System.Console.WriteLine("Faz algo caso nenhuma condição seja atendida");
}
Podemos "traduzir" o "else if" para "se caso".
A instrução "if" ainda pode ser emulada de forma mais simples através do operador "?" (interrogação) veja:
int a = (expressãoBooleana) ? 1 : 0;
Nesse caso se a expressão Booleana seja verdadeira ( true ) a variável "a" receberá o valor "1" e caso seja falso ( false ) a variável recebe "0". Veja um exemplo prático:
System.Console.WriteLine(a == 5 ? "Sim a é igual à 5" : "Não a é diferente de 5");
Se "a" for igual a 5 o resultado será: "Sim a é igual à 5", caso "a" não seja igual a "5" o resultado será: "Não a é diferente de 5".
switch... case
A instrução "switch.. case" prove um caminho mais limpo para escrever múltiplas instruções "if..else", veja o exemplo:
switch(a)
{
 case 1:
 System.Console.WriteLine("a é igual a 1");
 break;
 case 2:
 System.Console.WriteLine("a é igual a 2")
 break;
 default:
 System.Console.WriteLine("a não é igual a 1 e nem igual a 2");
 break;
}
Colocamos a variável "a" dentro do "switch" e dentro de nosso código vamos verificando com o "case" o valor de nossa variável. No nosso código temos duas possibilidades para caso seja 1 e caso seja 2 e ainda temos a opção "default" que é conhecida como "case else", ou seja, se nenhum "case" for atendido ela será executada, lembrando que é opcional colocar o "default".
VB
Declaração de Variaveis
1- Múltiplas declarações em uma única linha de código
Nas versões anteriores do Visual Basic , quando tínhamos múltiplas declarações aparecendo na mesma linha , para definir o tipo correto de dados de cada variável deveríamos usar a cláusula AS explicitamentena frente de cada variável , ou seja , se você fizer uma declaração assim : Dim a , b c as String .
O que teria ? Vejamos:
	Declaração
	Resultado no Visual Basic 6.0
	Resultado no Visual Basic .NET
	Dim a , b c as String
	a e b será do tipo Variant e c será do tipo String
	a, b e c serão do tipo String
Para obter o mesmo efeito no VB 6.0 teríamos que fazer a declaração assim :
Dim a AS String , b AS String , c AS String
No VB.NET podemos fazer assim :
Dim a , b , c AS String
2- O tipo de dados padrão
No VB 6.0 se você declarar uma variável sem definir explicitamente seu tipo (sem usar a cláusula AS) o tipo padrão assumido é o tipo Variant. Assim na declaração :
	 Dim a 
	 A variável a será do tipo Variant => 
	 Dim a AS Variant 
no VB.NET a mesma declaração tornará a variável a do tipo Object .
Object é o valor padrão para variáveis no VB.NET.
	 Dim a 
	 A variável a será do tipo Object => 
	 Dim a As Object
3- O escopo das variáveis
O Visual Basic .NET trouxe um novo escopo para as variáveis: o escopo a nível de blocos. Assim no VB.NET quando você declara uma variável dentro de um bloco de código : FOR...NEXT , DO WHILE , IF..THEN , SELECT...CASE , TRY ... CATCH, etc... ela deixa de existir fora do bloco de código onde foi declarada.
Assim no VB.NET o código abaixo :
	For i = 0 to 10
  Dim nome as String
  nome = "Carlos"
Next i
nome=""
	A variável nome será visível somente dentro do bloco de código definido por FOR/NEXT
Se você tentar usar a variável nome fora do bloco vai obter a seguinte mensagem de erro:
Name 'nome' is not declared.
No VB 6.0 usando a mesma declaração , a variável nome poderia ser usada dentro da função sem problemas.
No VB.NET
4- Declaração de variáveis e conversão entre tipos.
No VB 6.0 quando a fazer a declaração abaixo , você terá :
	 Dim a , b as Long 
	 a será do tipo Variant e b do tipo Long 
Se você fizer a seguinte atribuição : a = "Copa 2002" não vai obter nenhuma mensagem de erro.
No VB.NET a mesma declaração irá resultar em
	 Dim a , b as Integer 
	 a será do tipo Integer e b do tipo Integer 
Se você fizer a seguinte atribuição : a = "Copa 2002" vai obter uma mensagem de erro.
Se a opção Option Strict estiver definida como ON a mensagem será :
Option Strict disallows implicit conversions from String to Integer.
Se a opção Option Strict estiver definida como OFF a mensagem será :
An unhandled exception of type 'System.InvalidCastException' occurred in microsoft.visualbasic.dll.
Additional information: Cast from String ("Hello world") to Integer is not valid.
Sabe porquê? Porque a variável a é do tipo de dados Integer e o valor literal "Copa 2002" é considerado do tipo String e isto resultará em tipos incompatíveis de dados, ou seja, você não poderá converter String para Integer.
Por outro lado, se Option Strict estiver OFF você pode converter entre tipos de dados implicitamente. Veja:
	Dim a , b 
a = " Copa "
b = 100
a = 2002
	 Quando você não declara as variáveis explicitamente ( não usa a cláusula AS)
 Se Option Strict for OFF os tipos dados podem ser convertidos
 na atribuição das variáveis.
5- Inicializando variáveis
No VB.NET podemos inicializar uma variável da seguinte forma:
Dim N as Integer = 7 ou ainda:
Dim X as integer = 1 , Y AS String = "COPA" , Z AS Integer = 2002
Todas estas formas são válidas e não são suportadas pelo Visual Basic 6.
Mas você não pode inicializar mais de uma variável, assim: Dim X, Y as Integer = 10
Resumindo: para inicializar uma variável temos que declará-la usando o tipo e a cláusula AS.
Operadores Aritmeticos, Relacionais e calculos
Operadores são unidades de código que executam uma operação e retornam elementos como resultado. Podem ocorrer operações aritméticas; operações de concatenação; operações de comparação; operações lógicas.
As operações de atribuição e os operadores gerais, entretanto podem não retornar elementos como resultado, apenas executam operações gerais.
. Operadores aritméticos
Considere as variáveis abaixo :
Dim X as integer
Dim Y as integer
Dim Z as double
Soma : X = 4 + 3 retorna 7
Subtração : X = 4 – 3 retorna 1
Y = – X ainda utilizando o exemplo acima – X retorna -1 (Muda o sinal)
Multiplicação : Y = 5 * 5.55 retorna 28 porque Y é Integer e arredonda números decimais
Divisão : Y = 4 / 3 retorna 1 porque Y é Integer e arredonda números decimais
Exponenciação : Y = 4 ^ 2 retorna 16
Divisão Inteira : Y = 23 \ 5 retorna 4
A divisão inteira retorna o número de vezes que um número pode ser divido por outro, no exemplo acima 23 pode ser dividido por 5 apenas 4 vezes. Em outras palavras, divisão inteira retorna apenas a parte inteira da divisão.
Módulo Aritmético : Y = 5 Mod 2 retorna 1
O módulo aritmético retorna apenas o resto da divisão entre dois inteiros.
Z = 100.3 Mod 4.13 retorna 1.18
O módulo aritmético retorna apenas o resta da divisão em ponto flutuante se os dois divisores forem ponto flutuante.
Divisão por Zero :
· Pode retornar NaN se for zero.
· Pode retornar +Infinito (>0)
· Pode retornar –Infinito (<0)
. Operadores de Comparação
Esses operadores comparam duas expressões e retornam um valor Boolean como resultado.
Comparação entre números :
Igualdade ( = ) : 23 = 23 retorna True
Diferença (<>) : 23 <> 23 retorna False
Maior que (>) : 23 > 2 retorna True
Menor que (< ) : 23 < 2 retorna False
Menor ou igual (<=) 23 <= 23 retorna True
Maior ou igual (>=) 23 >= 23 retorna True
Comparação entre strings :
O compilador usa o operador Like interno para executar as comparações entre strings usando um padrão, se o padrão for igual retorna True senão retorna False, funcionando da mesma forma que os números. Exemplo :
“73” > “9” retorna True
“73” = “73” retorna True
“aaa” > “aa” retorna True
No primeiro exemplo o compilador usou um padrão de ordem de classificação para comparar duas strings, o padrão especifica que 73 está em último lugar na ordem de classificação então a comparação > é True. No segundo exemplo, as duas strings têm a mesma ordem de classificação e a comparação é = , portanto o resultado é True. No terceiro exemplo, a string “aaa” tem um prefixo a mais que “aa”e toda a string maior é classificado primeiro que a string menor, logo o resultado é True.
O padrão de comparação é alterado pelo comando de comparação Option Compare.
Option Compare
O comando Option Compare indica ao compilador o padrão para comparar strings. O comando possui esta sintaxe:
Option Compare Text
Option Compare Binary
Option Compare Binary – (Default) O compilador reconhece o ordem de classificação dos caracteres da seguinte forma:
A < B < E < Z < a < b < e < z < À < Ê < Ø < à < ê < ø
Assim, os caracteres em maiúsculos, acentuados, e outros possuem uma ordem de classificação binária interna no VB, segundo a ordem acima.
Option Compare Text – O compilador reconhece a ordem de classificação dos caracteres de forma insensitiva, isto é não importa se os caracteres estão em maiúsculos ou minúsculos. Assim:
(A=a) < (À=à) < (B=b) < (E=e) < (Ê=ê) < (Ø=ø) < (Z=z)
Exemplo:
" Muda o comportamento das comparações para Binário.
Option Compare Binary " "AAA" é menor que "aaa".
" Muda o comportamento das comparações para Texto.
Option Compare Text " "AAA" é igual à "aaa".
Comparação entre Objetos
Para comparar objetos é obrigatório usar o operador Is. O compilador compara os 2 objetos testando se eles se referem a mesma cópia (instância) de um objeto.Exemplo :
Dim x As MyClass
Dim y As New MyClass()
x = y
If x Is y Then
‘msgbox (“São iguais”)
end if
No exemplo acima foram criadas duas variáveis que são instâncias (cópias) da classe MyClass ( ), em seguida foi atribuída a variável inicializada y para outra não inicializada x, neste caso é a mesma cópia do objeto. O último comando executa um teste comparando o valor de uma com o valor de outra, em caso afirmativo vai exibir uma mensagem “São Iguais”.
Dim x As New MyClass()
Dim y As New MyClass()
If x Is y Then
‘msgbox (“São iguais”)
end if
No exemplo acima, foram também criadas duas variáveis que são cópias da classe MyClass( ), observe porém que as cópias são do mesmo objeto, isto é MyClass, mas as instâncias (cópias) são diferentes. A variável X criou uma cópia separada do objeto, pois utilizou o comando New, enquanto que a variável Y criou outra cópia separada do mesmo objeto, pois também utilizou o comando New.
É possível descobrir o tipo do objeto criado utilizando o operador TypeOf...Is. Exemplo:
Dim x As Button
x = New Button()
If TypeOf x Is Control Then
 " Continuação do programa.
No exemplo acima, o operador é chamado para verificar se a variável X é uma instância de uma classe, neste caso o resultado é True.
Operadores de Concatenação
Os operadores de concatenação juntam duas strings em uma única string. Dois são os operadores de concatenação : & , + .
O operador & foi especialmente criado para junções de variáveis do tipo string:
Dim X as string = “Meu fusca “
X = X & “Amarelo” ‘atribui a string “Meu fusca Amarelo”
O operador + além de ser um operador aritmético, também pode ser usado para concatenar strings. O compilador do VB tem comportamentos diferentes quando a opção Option Strict está ligada (on) ou desligada (off).:
Strict On – o compilador utiliza tanto & quanto + para concatenar variáveis strings da mesma forma.
Strict Off – o compilador utiliza + para fazer conversões implícitas entre diversos tipos, enquanto que & não pode executar essas conversões.
Exemplo:
Dim myNumber As Integer
Dim var1 As String
Dim var2 As Integer
myNumber = 2 + 2 " Retorna 4.
myNumber = 4257.04 + 98112 " Retorna 102369.04.
Option Strict On
" inicializa as variáveis de diferentes tipos.
var1 = "34"
var2 = 6
myNumber = var1 + var2 " Gera um erro de compilação.
Option Strict Off
Var1 = "34"
Var2 = 6
myNumber = var1 + var2
" Retorna o número 40 como resultado da soma após a
‘string Var1 ser convertida para número. O uso de
Option Strict Off não é recomendada.
No último exemplo acima, o operador + faz uma conversão implícita de Var1 para integer, e o resultado final é a soma de duas variáveis do tipo integer.
Operadores Lógicos
Os operadores lógicos comparam duas expressões do tipo verdadeiro ou false e retornam um valor do tipo Boolean, além disso, os operadores lógicos também podem processar comparações em Bitwise que comparam dois valores em formato binário (base 2).
Os operadores lógicos são: And, Or, AndAlso, OrElse, Xor, Not.
Operações com Expressões
Dentre os operadores acima, todos trabalham com dois operadores, mas somente Not trabalha com um operador (unário). Exemplos
Dim x As Boolean
x = Not 23 > 12 " x é False.
x = Not 23 > 67 " x é True.
No exemplo acima, o operador Not executa uma operação de negação, e simplesmente muda a forma de avaliação proposta. Assim X não avalia 23 > 2, portanto é falso, em seguida X não avalia 23 > 67 então é verdadeiro.
Dim x As Boolean
x = 23 > 12 And 12 > 4 " x = True
x = 12 > 23 And 12 > 4 " x = False
Acima, o operador And executa uma operação de junção entre duas expressões, e retorna verdadeiro se todas as expressões forem verdadeiras. Se todas as expressões forem falsas, o resultado é falso. Se uma delas for verdadeira e outra false, ainda assim o resultado é falso.
Dim x As Boolean
x = 23 > 12 Or 4 > 12` " x = True
x = 23 > 45 Or 4 > 12 " x = False
O operador Or acima, executa uma operação de disjunção entre duas expressões, Se ambas as expressões forem verdadeiras o resultado é True. Se ambas as expressões forem false, o resultado é false. Mas se uma das expressões forem verdadeiras, então o resultado é True.
Dim x As Boolean
x = 23 > 45 Xor 12 > 4 " x = True
x = 23 > 12 Xor 12 > 4 " x = False
x = 12 > 23 Xor 4 > 12 " x = False
No exemplo acima, o operador Xor executa uma operação de exclusão entre duas expressões. Se ambas as expressões forem verdadeiras, o resultado é False. Se ambas as expressões são falsas, o resultado ainda é False. Mas se uma das expressões for verdadeira e outra falsa, o resultado final é verdadeiro.
Dim x As Boolean
x = 23 > 12 And msgbox(“Olá”) " exibe a mensagem Olá
x = 12 > 23 And msgbox (“Olá”) " Não exibe a mensagem Olá
No exemplo acima, o operador AndAlso executa uma operação de junção, semelhante ao operador And, a única diferença é que se a primeira expressão for falsa o operador AndAlso não avalia a segunda expressão, e o resultado será false. Ao passo que o operador And, avalia as duas expressões obrigatoriamente e também retorna false.
Dim x As Boolean
x = 23 > 12 OrElse msgbox (“Olá”) " não exibe a mensagem Olá
x = 23 > 45 OrElse Msgbox ( “Olá”) Exibe a mensagem Olá
Acima, o operador OrElse executa uma operação de disjunção entre duas expressões, semelhante ao operador Or, a única diferença é que se a primeira expressão for verdadeira o operador Or não avalia a segunda expressão e o resultado será false. Ao passo que o operador Or, avalia as duas expressões obrigatoriamente e também retorna false.
Portanto os operadores AndAlso e OrElse economizam tempo e recursos de processamento e também são conhecidos como operadores Short-Circuiting.
Operadores Bitwise
As operações Bitwise avaliam valores em formato binário, e comparam os bits em suas posições correspondentes, em seguida retornam o resultado da comparação. Exemplo:
Dim x As Integer
x = 3 And 5 " x = 1
No exemplo acima, não há comparação entre expressões, mas entre números inteiros com o operador And. Portanto o compilador transforma os números em formato binário e executa a comparação em bitwise.
Primeiro o valor é convertido para formato binário:
3 em binário é = 011
5 em binário é = 101
Em seguida os binários são comparados uma posição por vez. Se ambas as posições forem 1, então 1 será o resultado da comparação dessa posição. Se uma delas for zero, então zero será o resultado da comparação dessa posição:
011 3 em decimal
101 5 em decimal
001 O resultado em formato binário
Convertendo para o formato decimal, 001 é o formato binário do número 1, então x = 1.
Dim x As Integer
x = 3 or 5 " x = 7
No exemplo acima, o compilador transforma os números em binário e executa uma comparação em bitwise com o operador Or a seguir:
011 3 em decimal
101 5 em decimal
111 O resultado em formato binário.
Convertendo para o formato decimal, 111 é o formato binário do número 7, então x = 7
Dim x As Integer
x = 3 Xor 5 " x = 6
No exemplo acima, o compilador transforma os números em binário e executa uma comparação em bitwise com o operador XOr a seguir:
011 3 em decimal
101 5 em decimal
110 O resultado em formato binário.
Convertendo para o formato decimal, 110 é o formato binário do número 6, então x = 6
Dim x As Integer
x = Not 5 " x = -6
No exemplo acima, o compilador transforma os número em binário e executa uma comparação em bitwise com o operador Not, que inverte a ordem dos bits incluindo o sinal, por isso o resultado é -6.
Resumindo : As operações em Bitwise só podem ser efetuadas com tipos de dados Integer. Os outros tipos de dados devem ser convertidos obrigatoriamente para Integer.
Operadores de atribuição
Os operadores de atribuição executam a tarefa de pegar um valor a direita do operador e atribuí-lo a variável a esquerda do operador. Os valores de atribuição podem ser outras variáveis, expressões, funções, entretanto todas devem obedecer às formas de conversão já estudadas.
Operador =
Usado para atribuir um valor a uma variável ou propriedade. 
Exemplo:
myInt = 42
Operador ^=
Usado para elevar o valor da variável à potência definida a direita do operador, e atribui o resultado a variável. 
Exemplo:
Dim var1 As Integer = 10
Dim var2 As Integer = 3
var1 ^= var2 " O valor de var1 é agora 1000.
Observe que o operador substitui a expressão var1 = 10 ^ 3. Essa é a forma mais eficiente para efetuar cálculos.
Operador *=
Usado para multiplicar o valor da variável pelo valor definido a direita do operador, e atribui o resultado a variável. 
Exemplo:
Dim var1 As Integer = 10
Dim var2 As Integer = 3
var1 *= var2 " O valor de var1 é agora 30.
Observe que o operador substitui a expressão var1 = 10 * 3. Essa é a forma mais eficiente para efetuar cálculos.
Operador /=
Divide o valor da variávelpelo valor definido a direita do operador, e atribui o resultado a variável. 
Exemplo:
Dim var1 As Integer = 12
Dim var2 As Integer = 3
var1 /= var2 " O valor de var1 é 4.
O operador substitui a expressão var1 = 12 / 3. É a forma mais eficiente para efetuar esse cálculo.
Operador \=
Usado para dividir os inteiros da variável pelo valor definido a direita do operador, e atribui o resultado a variável. 
Exemplo:
Dim var1 As Integer = 10
Dim var2 As Integer = 3
var1 \= var2 " O valor agora de var1 é 3.
O operador substitui a expressão var1 = 10 \ 3. É a forma mais eficiente para efetuar esse cálculo.
Operador +=
Adiciona o valor definido a direita do operador a variável. Além disso concatena a string definida a direita do operador a variável string. Todos os resultados obtidos são atribuídos a variável. 
Exemplo:
Dim var1 As Integer = 10
Dim var2 As Integer = 3
var1 += var2 " O valor agora da var1 é 13.
" Este exemplo usa variáveis string.
Dim var1 As String = "10"
Dim var2 As String = "3"
var1 += var2 " O string agora da variável var1 é "103".
O operador substitui as expressões var1 = 10 + 3, e var1 = “10” & “3”. São as formas mais eficientes para executar essas operações. As conversões devem obedecer ao comportamento de acordo com a opção Option Strict.
Operador -=
Usado para subtrair o valor definido a direita do operador da variável, e atribui o resultado a variável. 
Exemplo:
Dim var1 As Integer = 10
Dim var2 As Integer = 3
var1 -= var2 " O valor de var1 é agora 7.
O operador acima substitui a expressão var1 = 10 – 3. É a forma mais eficiente para executar essa operação.
Operador &=
Usado para concatenar a string definida a direita do operador com a string da variável, e atribui o resultado a variável. 
Exemplo:
Dim var1 As String = "Hello "
Dim var2 As String = "World!"
var1 &= var2 " A string de var1 é agora "Hello World!"
O operador substitui a expressão var1 = “Hello ” & “World”. É a forma mais eficiente para concatenar essas strings.
Todos os operadores descritos acima aceitam expressões, funções, constantes após os operadores. Como por exemplo:
‘esse exemplo utiliza operador com uma expressão
Dim Var1 as integer = 2
Var1 += (1+2) ^ 2 ‘ o valor retornado é 11
Operadores Gerais
Os operadores gerais são todos os operadores que não se enquadram nas divisões acima. São dois os operadores gerais.
Operador AddressOf
Usado para criar uma referência que aponta para um procedimento ou função definidos após esse operador, isto significa que o operador vai sempre executar o nome da função a direita do operador.
Esse tipo de operador é usado com o recurso Delegate do VB .Net, que será estudado mais tarde, para manter um ponteiro para uma função ou procedimento mesmo que esta já tenha sido descartada na memória.
Em versões anteriores do VB, esse operador era usado para passar o endereço de memória de um procedimento para uma Função API do Windows.
De forma clara, o operador AddressOf muda o “curso” de um procedimento qualquer para o procedimento que foi informado a direita do operador. 
Exemplo:
Public Sub ButtonClickHandler(ByVal sender As Object, e As System.EventArgs)
 Msgbox (“Outro evento para o botão.”) ‘Exibe a mensagem ‘Outro evento para o botão’
End Sub
 
Public Sub New()
 AddHandler Button1.Click, AddressOf ButtonClickHandler
End Sub
No exemplo acima, foi criado um procedimento ButtonClickHandler que exibe a mensagem “Outro evento para o botão”. Em seguida, no evento New de uma janela do VB, foi criado um método para mudar o curso do evento Clique de um botão para o novo procedimento ButtonClickHandler utilizando o operador AddressOf.
Observe que o não existe código algum no evento Click do botão de comando.
Operador GetType
Usado para informar o tipo de objeto que uma variável pertence, além disso pode retornar propriedades, métodos e eventos do respectivo tipo. 
Exemplo:
Dim t As Type() = 
 {GetType(Integer),GetType(System.Int32),GetType(String),GetType(Double())}
Dim i As Integer
For i = 0 To t.Length - 1
 Console.WriteLine(t(i).Name)
Next i
O resultado do teste é:
Int32
Int32
String
Double()
O exemplo acima, cria uma variável como uma matriz de tipos Type( ) e inicializa seus valores com o operador GetType. Em seguida, escreve os resultados na janela Output do Visual Studio.
Precedência de operadores
O VB dentro de uma expressão, executa os cálculos de operadores nessa ordem :
Operadores Aritméticos e Concatenação
. Exponenciação (^)
. Negação (–)
. Multiplicação e Divisão (*, /)
. Divisão Inteira (\)
. Módulo aritmético (Mod)
. Adição e Subtração (+, –), Concatenação de strings (+)
. Concatenação de strings (&)
Operadores de Comparação
. Igualdade (=)
. Diferenciação (<>)
. Menor que, Maior que (<,>)
. Maior ou igual à (>=)
. Menor ou igual à (<=)
. Like
. Is
. TypeOf...Is
Operadores Lógicos e Bitwise
. Negação (Not)
. Junção (And, AndAlso)
. Disjunção (Or, OrElse, Xor)
É possível alterar a ordem de precedência dentro de uma expressão, utilizando parênteses entre os membros da expressão. 
Exemplo:
x = ((4 +2) ^2) – (5 * 3) ‘x retorna 21
x = 4 + (2 ^ 2) - (5 * 3) ‘x retorna -7
Estrutura de decisão e repetição
Para construir um programa de computador que seja interativo e que responda de forma diferente dependendo das informações fornecidas pelo usuário vamos precisar usar um tipo de instrução chamada de instrução de controle.
Neste artigo irei abordar as duas categorias de instruções de controle: instruções condicionais e instruções de laço.
O VB.NET suporta as seguintes estruturas ou instruções de controle:
	If ... Then ... Else
	Select / Case
	For ... Next
	Do ... While
	While ... End While
	Do ... Loop
	Do .. Until
	 
	 
If... Then ... Else
É utilizada para avaliar uma determinada expressão e definir se um bloco de código deve ou não ser executado. A sintaxe de sua estrutura completa é a seguinte:
	if  <condição #1 > Then
	- Na estrutura básica If Then Else ao lado temos:
- condição - É a condição a ser avaliada ; pode usar os operadores de comparação ( = , < , > , <> , >= , <=). Se uma condição satisfazer a avaliação o bloco de código associado ao if ou ao ElseIf será executado e sairemos da estrutura.
- Else - O bloco de código associado a esta instrução somente será executado se nenhuma das condições em If ou ElseIf for satisfeita.
- End If - Indica o fim da estrutura de controle.
	          [ código #2 ]
	
	ElseIf <condição #2> Then
	
	          [ código #2 ]
	
	ElseIf <condição #3> Then
	
	            [ código #3 ]
	
	......
	
	Else
	
	          [ código #n ]
	
	End If
	
Podemos ter as seguintes variações:
	a estrutura na forma mais simples
	Avaliando uma condição com duas possibilidades de execução.
	  Aninhando duas instruções - If ... Then... Else
		if <condição #1> then
	      [ codigo #1]
	End If
		If  <condição #1> then
	        [ codigo #1 ]
	Else
	        [ codigo #2]
	End If
		if <condição #1> then
	        [ código #1]
	else
	       if <condição #2> then
	              [ código #2]
	       End If
	End If
Além da forma de bloco acima exibida podemos também expressar uma instrução If em uma única linha. Assim:
	Instruções If em sequência na mesma linha
	a-  If < condição #1 > then  [ código #1 ]                             
Ex: If x=0 then Valor = 100
	 
	b-  if < condição #1 > then  [ código #2 ]  Else [ código #3 ]  
Ex: If hora > 12 then msg="Boa Tarde" Else msg="Bom dia"
	 
	c- if < condição #1 > then  [ código #2 ] : [ codigo #3 ]  Else [ código #4 ]
	Ex: If hora > 12 then msg="Boa Tarde" : msg2=" >12"  Else msg="Bom dia"
Nota: Embora as instruções em uma única linha as vezes possam dar ao código uma melhor aparência (caso a) você dever considerar se a leitura do código não vai ficar mais difícil.
Existe ainda a instrução IIF que pode ser aplicada em situações em que existam apenas duas ações, uma verdadeira e outra falsa. Sua sintaxe é:
iif ( <condição #1> , < código executado se a instrução for verdadeira> , <código se a instrução for falsa>)
Ex:
	Function Verifica (ByVal Teste As Integer) As StringVerifica = IIf(Teste > 1000, "Grande", "Pequeno")
End Function
Operadores de comparação
Geralmente nas condições usamos expressões de comparação onde duas expressões não booleanas utilizam um operador para realizar uma comparação. Os operadores disponíveis são:
	   >
	 maior que
	   <
	 menor que
	   =
	 igual a
	   <>
	 diferente de
	   >=
	 maior ou igual a
	   <=
	 menor ou igual a
	   Like
	  verifica correspondência de padrões entre strings
Estes operadores são usados com strings e com valores numéricos.
No caso do operador especial Like podemos comparar uma variável de string com padrões que usam caracteres especiais e comuns. Estes caracteres podem ser:
	  *
	 indica a quantidade de caracteres adicionais
	  ?
	 repesenta um único caractere
	  #
	 representa um dígito {0-9}
	  intervalos [a-z] , [j-k] , etc.
	 especifica que qualquer caractere dentro do intervalo dever ser considerado uma correspondência
Ex:  if  "Macoratti"  Like  "M*tti" then [código]
Operadores Lógicos
Os operadores lógicos trabalham com expressões ou valores booleanos e retornam um resultado booleano ( Verdadeiro / Falso , Sim / Não ). Nesta categoria temos os seguintes operadores :
	AND
	 Usando este operador entre dois valores/expressões só obtemos um resultado igual a verdadeiro SE os dois forem verdadeiros.
	OR
	 Com este operador se um dos valores/expressões for verdadeiro o resultado será verdadeiro
	XOR
	 Gera um resultado verdadeiro  se um dos valores/expressão for verdadeiro e o outro for Falso.
	NOT
	 Operador de negação e retorna o oposto a qualquer valor que for usado com ele.
A seguir temos um tabela com algumas combinações possíveis entre os operadores lógicos.
	 TRUE AND TRUE
	 TRUE
	 FALSE AND TRUE
	 FALSE
	 TRUE AND FALSE
	 FALSE
	
	
	 FALSE AND FALSE
	 FALSE
	 TRUE OR TRUE
	 TRUE
	 TRUE XOR FALSE
	 TRUE
	 NOT TRUE
	 FALSE
	 NOT FALSE
	 TRUE
A estrutura Select Case : múltiplas possibilidades
A estrutura Select Case é usada quando temos que verificar muitas condições , neste caso , embora você ainda possa usar a estrutura If.. Then ... Else ela poderia se tornar muito complexa e difícil de tratar.  Sua sintaxe é a seguinte:
	Select Case < expressão >
	- <expressão> é a variável ou expressão que esta sendo comparada
- <condicao> é a condição lógica a ser avaliada
- Case Else -  executa o bloco de código associado se nenhuma condição anterior for verdadeira.
	        Case < condicao #1>
	
	                  [ codigo #1]
	
	        Case < condicao #2>
	
	                  [ codigo #2]
	
	 .....
	
	        Case Else
	
	                  [ código #3]
	
	End Select
	
A utilização da instrução Select Case pode simplificar muito o código,  abaixo as possibilidades :
	Select Case  quantidade
	 
	     Case 1
	 
	         call rotina1()         
	 
	     Case 2,4
	- podemos trabalhar com mais de uma opção para a condição :  Case x,y
	         call rotina2()
	 
	     Case 5 to 9
	-  podemos definir uma faixa de valores  : Case x to y
	         call rotina3()
	 
	     Case else
	 
	         call rotina4()
	 
	End Select
	 
Laços
Quando você precisar executar um bloco de código mais de uma vez deverá usar o tipo de instrução laço (loop). Vejamos os principais:
For ... Next
Repete o mesmo bloco de código um determinado número de vezes independente de qualquer condição lógica: Sua sintaxe é :
	For <contador = valorinicial > To <valorfinal> [step]
	 - contador :  variável númerica que controla o número de vezes que  o código será executado.
- ValorInicial - Valor inicial atribuído ao contador
- Valorfinal - valor final que o contador irá assumir antes de encerrar a execução do laço.
- Step - especifica o valor de incremento do contador.O valor padrão é de uma unidade.
- Exit For - interrompe a execução do laço
	      [ código #1]
	
	      exit for
	
	Next [contador]
	
Abaixo um exemplo de utilização de For / Next:
	For x=1 to 100 step 2
        x = x+10
        if x > 68 then
           exit for
       endif
Next      
Você usa o laço for/next quando sabe exatamente quantas vezes o bloco de código deverá ser executado.
Para percorrer vetores ou objetos com um número determinado de elementos podemos usar o laço For Each/Next:
	O laço For Each...Next é idêntico ao laço For...Next mas executa o bloco de código para cada elemento em uma coleção , ou invés de executar um determinado número de vezes. Sua sintaxe é :
 
	For Each elemento In coleção
 '[código a ser executado para cada valor do elemento]
Next [ elemento ]
 
Os elementos da coleção podem ser qualquer tipo de dados. Para cada interação no laço o VB.NET define a variável elemento para um dos elementos na coleção e executa o código.
While ... End While
Este laço é mais flexível que o laço for/next . Ele executa o bloco de código enquanto uma expressão booleana for verdadeira.
	While < expressão booleana >
      [ código #1]
End While
 
	 - Você pode usar qualquer expressão booleana
Nota: No visual basic 6 havia a instrução While/Wend , no VB.NET a instrução Wend foi substituida por End While.
Ex:
	While contador  < 10 And valor = 5
        contador = contador + 1
End While
Do ... Loop
Este laço além de ser simples é um dos mais flexíveis , ele executa o bloco de código enquanto uma condição for verdadeira. A sintaxe é a seguinte :
	Do [ {While | Until} <expressão >
    [bloco de código]
    [Exit Do]
Loop
	- <expressão> - qualquer expressão numérica ou de string avaliada pelo laço
- Exit Do - interrompe a execução do laço.
Temos então as seguintes estruturas possíveis:
	Do While <condição >
     [ código ]
Loop
	Do Until <condição >
     [ código ]
Loop
	Faça enquanto a expressão for verdadeira
	Faça até que a expressão torne-se verdadeira
A diferença entre Do While e Do Until é o modo como a estrutura avalia a expressão lógica. Para o Until o bloco será executado enquanto o valor da expressão for Falsa.
Ao escolher entre um laço While e Until use o laço que não precisar de uma negação na expressão condicional.
Tenha cuidado a posicionar a sua instrução condicional. Se você colocar a condição no início do laço , o código no interior do laço nunca será executado se a condição não for atendida.
Você pode colocar a condição de saída no final do laço, assim:
	Do
     [Código #1}
Loop Until <condição #1>
Nota: se a expressão da condição for Null o VB.NET tratará a condição como False.
Você deve tomar cuidado com o seu código dentro dos laços pois isto pode afeta o desempenho de sua aplicação. Abaixo algumas dicas para ajudar a você ter um código rápido:
· Evite fazer chamadas a funções dentro de laços
· Tenha sempre uma condição de saída de um laço
· Não torne a condição de saída de um laço muito complexa pois ele precisa ser avaliada a cada passo
· Ao utilizar expressões booleanas coloque a parte mais simples da expressão do lado esquerdo
Laço Infinito - Um laço infinito é um laço que executa o código no seu interior e não tem condição de saída , ou seja, o código será executado infinita vezes...
Dica: Se por um erro de lógica seu código entrar em um laço infinito use as teclas CTRL+Break para encerrá-lo. Abaixo um exemplo de um laço infinito:
	Dim i as integer = 0
 While i < 100
       Console.Writeline(i)
End While
	Adivinhe por que o laço ao lado é infinito ????
Para evitar um laço infinito procure adotar os seguintes procedimentos:
· Inicialize a variável de controle
· Teste o valor da variável de controle
· Execute o bloco de código e verifique se ele está correto
· Verifique se o valor da variável de controle está sendo alterado
Recursão
É claro que os laços nem sempre são a melhor solução para todos os problemas. Em alguns casos você pode usar a recursão como uma alternativa aos laços. 
A recursão ocorre quando um programa ou rotina chama a ele próprio. Um exemplo clássico para mostrar como a recursão funciona é o cálculo do um fatorial.
A fórmula para calcular um fatorial de um valor n  é = n! onde fazemos n ! = (n -1)(n-2)...(n-(n-1))(1). Assim para o fatorial para o número 5 seria :5! = 5x4x3x2x1 = 120 .
A fórmula geral para calcular o fatorial pode ser então expressa como :  n * (n-1) ! ( n multiplicado pelo fatorial de n menos 1).
A seguir temos o código que usa a recursão ao invés de laços para calcular o fatorial de um número inteiro.
	Public Class Fatorial
 
Shared Sub Main()
 
   Dim entrada As String
   Dim numero As Integer
   Dim contador As Integer
 
   Console.Write(" >>> Calculo do Fatorial <<< ")
   Console.WriteLine("")
   Console.WriteLine("Informe o número para calcular o fatorial ")
 
   entrada = Console.ReadLine()
   numero = CInt(entrada)
 
   Console.Write("")
   Console.Write(" O valor do fatorial para " & numero & " é : ")
   Console.WriteLine(Fatorial(numero))
   Console.ReadLine()
 
End Sub
Shared Function Fatorial(ByVal n As Integer) As Integer
 
  If n = 1 Then
      Return 1
  Else
      Return n * Fatorial(n - 1)
  End If
End Function
 
End Class
Referências Bibliográficas
Fonte: http://www.macoratti.net/vbn_econ.htm
Fonte: http://www.bosontreinamentos.com.br/java/declaracao-de-variaveis-em-java/
Fonte: http://www.mauda.com.br/?p=1109
Fonte:http://tdsb2014.blogspot.com/2014/05/estrutura-de-repeticao-e-selecao.html
Fonte: https://celsokitamura.com.br/declaracao-e-atribuicao-de-variaveis-c-sharp/
Fonte: https://www.devmedia.com.br/tipos-de-operadores-do-csharp/18873
fonte: http://www.linhadecodigo.com.br/artigo/1160/serie-aprenda-csharp-estrutura-de-decisao.aspx#ixzz6LZy3r2pT
Fonte: http://www.macoratti.net/vbn_var.htm