pROGRAMAÇÃO c sHARP

Prévia do material em texto

MÓDULO III 
CSHARP 
 
 
 
2 Módulo III: C# 
26 de janeiro de 2011 
Conteúdo 
Bem-vindo ao C# ........................................................................................................................... 4 
Conceitos iniciais ........................................................................................................................... 5 
Programação Orientada a Eventos ........................................................................................... 5 
Definição ............................................................................................................................... 5 
Classes e Objetos ....................................................................................................................... 5 
Definição ............................................................................................................................... 5 
Propriedades, Métodos e Eventos ............................................................................................ 6 
Propriedades ......................................................................................................................... 6 
Métodos ................................................................................................................................ 6 
Eventos .................................................................................................................................. 6 
Namespaces .............................................................................................................................. 6 
Definição ............................................................................................................................... 6 
Namespaces da Framework .Net .......................................................................................... 6 
Namespaces definidos pelo usuário ..................................................................................... 7 
Programando em C#...................................................................................................................... 7 
Trabalhando com Variáveis ....................................................................................................... 7 
Nomeando Variáveis ............................................................................................................. 7 
Declarando Variáveis ............................................................................................................. 7 
Variáveis não atribuídas ........................................................................................................ 8 
Tipos de Dados Primitivos ..................................................................................................... 8 
Usando instruções de decisão ................................................................................................... 8 
Usando operadores Booleanos ............................................................................................. 8 
Tome a decisão! .................................................................................................................... 9 
Somente expressões booleanas, por favor ........................................................................... 9 
Instruções if em cascata ........................................................................................................ 9 
Usando a instrução switch .................................................................................................. 10 
Usando instruções de Iteração .................................................................................................... 12 
While ....................................................................................................................................... 12 
For ........................................................................................................................................... 12 
Entendendo o escopo da instrução for ............................................................................... 14 
As instruções break e continue ........................................................................................... 14 
 
 
 
 
3 Módulo III: C#8 
MXM Sistemas e Serviços de Informática | 2011 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4 Módulo III: C# 
26 de janeiro de 2011 
Bem-vindo ao C# 
A Microsoft desenvolveu a linguagem C# em conjunto com a arquitetura .net, sendo assim 
uma linguagem de programação especialmente desenvolvida para esta plataforma. Todos 
sabemos que a plataforma .net suporta uma gama de linguagens como o C# (como dito), 
VB.Net, J#, C++, Delphi for .Net entre outras, o que torna essa arquitetura produtiva e 
independente de linguagem. Isso quer dizer que o desenvolvedor pode escolher a linguagem 
que mais lhe agrada. Esta liberdade de escolha da linguagem de programação aumenta 
também a produtividade de um time de desenvolvimento, pois enquanto parte dos 
desenvolvedores estão construindo a interface gráfica em VB.Net outro grupo pode estar 
desenvolvendo as classes de negócio em C#, por exemplo. Depois, é só integrar as duas partes 
do projeto. 
Entre tantas linguagens suportadas pelo .net porque, então, escolher o C#? O C# sofre 
influência de várias linguagens; mais notadamente do Delphi, C++ e Java. A linguagem C#, na 
verdade, é a reunião das principais vantagens dessas linguagens, corrigindo seus defeitos e/ou 
limitações e acrescentando alguns outros recursos, o que faz do C# uma linguagem muito 
poderosa e atrativa aos desenvolvedores que desejam migrar para a plataforma Microsoft 
.net, pois é fácil de assimilar pelos novatos no mundo do desenvolvimento de softwares e 
proporciona uma baixa curva de aprendizagem para os mais experientes. É comum escutarmos 
falar que o C# é tão poderoso quanto C++ e tão organizada, flexível e fácil de programar 
quanto o Delphi. 
Vejamos então algumas das características do C#: 
• Como já dito, C# foi criado do zero para funcionar especialmente na 
plataforma .net, sem a necessidade de compatibilidade com código já existente; 
• A maior parte das classes do .Net Framework foram desenvolvidos em C#; 
• Primeira linguagem “orientada à componentes” da família C/C++; 
• Segue os padrões de POO, onde tudo deriva de um ancestral comum 
(System.Object); 
• A linguagem é fortemente tipada, o que ajuda a evitar erros oriundos de uma 
manipulação imprópria de tipo e/ou atribuições; 
• Suporte à COM, COM+ e outras DLLs escritas por linguagens que geram código 
não-gerenciado; 
• É case-sensitive; 
• Os programas escritos em C# rodam sob um ambiente gerenciável, o que 
significa que todo o controle de memória é feito pelo .Net Framework e não 
diretamente pelo programador, reduzindo assim falhas na programação enquanto à 
alocação e liberação de um objeto na memória. 
 
 
5 Módulo III: C#8 
MXM Sistemas e Serviços de Informática | 2011 
 
Conceitos iniciais 
Programação Orientada a Eventos 
Quando você cria um Windows Form ou Web Application no Visual Studio, você está criando 
uma aplicação orientada a eventos. Aplicações orientada a eventos executam códigos em 
resposta a um evento. Cada formulário e/ou controle que você cria expõe uma quantidade 
pré-definida de eventos. Quando um destes eventos ocorre, e há código associado a ele, este 
código é invocado. 
Definição 
Blocos de código em uma aplicação orientada a eventos são executados apenas quando um 
evento específico é disparado, chamando o bloco associado a este evento. Eventos podem ser 
disparados através do teclado, entrada de dados, ações do mouse,pelo sistema operacional 
ou mesmo por outro bloco de código dentro da aplicação. 
Classes e Objetos 
Uma classe é o tipo definido pelo usuário mais básico do C#. Quando você cria uma classe, 
você organiza informações em comum dentro de uma mesma entidade. Você deve criar uma 
classe antes de criar um objeto. 
Definição 
Uma classe define as características de um objeto. Enquanto as propriedades da classe 
definem os atributos de um objeto, os métodos definem o comportamento deste. Estas 
características determinam como outros objetos poderão interagir com este objeto. 
Um objeto é a instância de uma classe. A classe é a definição de um item e o objeto é o item 
propriamente dito. 
Características de uma classe 
• Uma classe define as características de um objeto; 
• Estas características determinam como o objeto deverá interagir com outros 
objetos; 
• Uma classe na Framework .Net é um tipo personalizado que pode incluir tipos 
de valor, tipos de referência, atributos, métodos e propriedades. 
Características de um objeto 
• O objeto é a instância de uma classe; 
• O objeto é criado quando a aplicação é executada; 
• Quando você cria um objeto, você está criando um novo tipo de referência; 
• No C#, tudo se comporta como um objeto; 
• Cada objeto ocupa seu próprio espaço na memória e executa 
independentemente de todas as outras instâncias daquele objeto. 
 
 
6 Módulo III: C# 
26 de janeiro de 2011 
 
Propriedades, Métodos e Eventos 
Basicamente, métodos representam as ações e propriedades representam os atributos de um 
objeto. 
Propriedades 
As propriedades descrevem as características de um objeto. Por exemplo, as propriedades de 
um balão incluem suas características “visíveis” como sua altura, diâmetro e cor. Outras 
características descrevem seu estado (como inflado; ou não) ou, ainda, atributos que não são 
visíveis como sua data de fabricação. Todos os balões possuem estes atributos, embora o valor 
destes atributos sejam diferentes para cada balão. 
Métodos 
Métodos são as ações que um objeto pode executar. Por exemplo, um balão tem a capacidade 
de inflar, desinflar ou subir. Todos os balões são capazes de executar estas ações. 
Eventos 
Um evento é uma ocorrência na qual podemos responder programaticamente. Por exemplo, o 
balão pode responder ao evento de ser preenchido com gás hélio. 
Ações de usuário podem gerar eventos, como um clique do mouse ou pressionar um botão no 
teclado. Ainda, é possível gerar eventos diretamente pelo código. Os casos mais comuns do 
uso de eventos na Framework .Net são o de resposta a uma atividade na interface do usuário. 
Namespaces 
Utilizamos namespaces para a organização de classes dentro de uma hierarquia lógica. 
Namespaces funcionam tanto como uma organização interna da sua aplicação quanto uma 
organização externa, a fim de evitar conflitos entre nomes de classe entre a sua aplicação e 
outra aplicação. 
Definição 
A biblioteca de classes da Framework .Net é composta por namespaces. Cada namespace 
contém tipos que podem ser utilizados na sua aplicação: classes, estruturas, enumerações, 
delegates, interfaces, etc. Porque diferentes classes podem possuir o mesmo nome, devemos 
organizar nossas classes dentro de uma hierarquia de namespaces. 
Namespaces da Framework .Net 
A Framework .Net é formada por vários namespaces; a mais importante delas é a System. O 
namespace System contém as classes que a maioria das aplicações utiliza para interagir com o 
sistema operacional. Abaixo, existem alguns dos namespaces existente na Framework .Net 
através da System: 
• System.Windows.Form – Contém as classes úteis na construção de aplicações 
Windows Form; 
• System.IO – Contém classes para leitura e escrita de arquivos; 
• System.Data – Contém classes úteis para acesso à banco de dados; 
• System.Web – Contém classes úteis na construção de aplicações Web Forms. 
 
 
7 Módulo III: C#8 
MXM Sistemas e Serviços de Informática | 2011 
Namespaces definidos pelo usuário 
Os namespaces podem ser separados em duas categorias: “definidos pelo usuário” e 
“definidos pelo sistema”. Os namespaces “definidos pelo usuário” são os namespaces 
definidos em nosso código. É uma boa prática de desenvolvimento definirmos todas as nossas 
classes dentro de namespaces. O Visual Studio segue esta recomendação utilizando o nome do 
projeto como a raiz do namespace. 
Programando em C# 
Trabalhando com Variáveis 
Uma variável é um local de armazenamento que guarda um valor. Imagine uma variável como 
uma caixa que guarda uma informação temporária. Por exemplo, se você deseja armazenar o 
valor do custo de um item em uma loja, deve criar uma variável –que podemos chamar de 
custo- e armazenar o custo do item nesta variável. Mais tarde, se você referenciar a variável 
custo, o valor recuperado será o custo do item que você colocou lá anteriormente. 
Nomeando Variáveis 
Adote uma convenção de nomes que ajude a evitar confusão em relação às variáveis que você 
definir. Abaixo, algumas recomendações gerais (lembre-se: são apenas recomendações): 
• Não use sublinhados; 
• Não crie identificadores cuja única diferença seja entre maiúsculas e minúsculas. Por 
exemplo, não crie uma variável denominada myVariable e outra denominada 
MyVariable para serem usadas ao mesmo tempo, porque será muito fácil confundi-las; 
• Comece o nome com uma letra minúscula; 
• Em um identificador de várias palavras, comece a segunda palavra e as palavras 
subseqüentes com uma letra maiúscula (isto é denominado “notação camelCase”); 
• Não use notação húngara (se você não sabe o que é isto, não se preocupe!); 
Declarando Variáveis 
Lembre-se de que variáveis são como caixas na memória que podem armazenar um valor. O 
C# tem muitos tipos diferentes de valores que pode armazenar e processar –inteiros, números 
com ponto flutuante e sequência de caracteres, para nomear apenas três. Quando você 
declara uma variável, deve especificar que tipo de dados ela armazenará. 
Você declara o tipo e o nome da variável em uma instrução de declaração. Por exemplo, a 
instrução a seguir declara que a variável denominada age armazena valores int (inteiro). A 
instrução deve ser terminada com um ponto-e-vírgula. 
int age; 
O tipo de variável int é o nome de um dos tipos primitivos do C# -inteiro que é um número 
inteiro. Após ter declarado sua variável, você pode lhe atribuir um valor. A instrução abaixo 
atribui o valor 42 à variável age. Novamente, você verá que ponto-e-vírgula são necessários. 
age = 42; 
 
 
8 Módulo III: C# 
26 de janeiro de 2011 
O sinal de igual (=) é o operador de atribuição, que atribui o valor à sua direita à variável à 
esquerda. Feito isso, a variável age pode ser usada no seu código para referenciar o valor que 
ela armazena. A próxima instrução escreve o valor da variável age, 42, no console: 
Console.WriteLine(age); 
Variáveis não atribuídas 
Quando você declara uma variável, ela contém um valor aleatório até que lhe seja atribuída 
um valor. O C# não permite que você uma variável não atribuída. É necessário atribuir um 
valor a uma variável antes que você possa usá-la, do contrário seu programa não compilará. 
Essa exigência é denominada Regra de atribuição definitiva. Por exemplo, a instrução a seguir 
gerará um erro de tempo de compilação porque a variável age não possui valor atribuído. 
int age; 
Console.WriteLine(age); //erro de tempo de compilação 
Tipos de Dados Primitivos 
O C# tem vários tipos embutidos denominados tipos de dados primitivos. Abaixo, a lista dos 
tipos primitivos mais utilizados no C#: 
• int - números inteiros; 
• long – números inteiros (com um intervalo maior); 
• float – números de ponto flutuante;• double – números de ponto flutuante com precisão dupla; 
• decimal – valores monetários; 
• string – sequência de caracteres; 
• char – caracter único; 
• bool – valores lógicos (verdadeiro ou falso). 
Usando instruções de decisão 
No mundo da programação tudo é preto ou branco, certo ou errado, verdadeiro ou falso. Por 
exemplo, se você criar uma variável inteira denominada x, atribuir o valor 99 a x e, em seguida, 
perguntar: “a variável x contém o valor 99?”, a resposta será verdadeiro. Se você perguntar: “a 
variável x é menor que 10?”, a resposta será falso. Esses são exemplos de expressões 
booleanas. Uma expressão booleana sempre avalia como verdadeiro ou falso. 
O C# fornece um tipo de dados denominado bool. Uma variável bool pode armazenar um dos 
dois valores: true ou false. Por exemplo, as três instruções a seguir declaram uma variável bool 
denominada areYouReady, atribui o valor true à variável e, em seguida, escreve seu valor no 
console: 
bool areYouReady; 
areYouReady = true; 
Console.WriteLine(areYouReady); //escreve True 
Usando operadores Booleanos 
Um operador booleano é um operador cujo resultado é verdadeiro ou falso. O C# tem vários 
operadores booleanos muito úteis, sendo o mais simples deles o operador NOT, que é 
 
 
9 Módulo III: C#8 
MXM Sistemas e Serviços de Informática | 2011 
representado pelo símbolo do ponto de exclamação (!). O operador ! nega um valor booleano, 
produzindo o oposto desse valor. No exemplo anterior, se o valor da variável areYouReady for 
true, o valor da expressão !areYouReady é false. 
Abaixo, uma lista dos operadores booleanos: 
• == (igual a); 
• != (diferente de); 
• < (menor que); 
• <= (menor ou igual que); 
• > (maior que); 
• >= (maior ou igual que); 
• && (operador lógico AND); 
• || (operador lógico OR) 
Tome a decisão! 
Use uma instrução if quando quiser escolher entre executar dois blocos diferentes de código 
dependendo do resultado de uma expressão booleana. 
A sintaxe de uma instrução if é a seguinte: 
if (expressaoBooleana) 
{ 
 statement -1; 
} 
else 
{ 
 statement – 2; 
} 
Se a expressão expressaoBooleana for avaliada como true, então a instrução statement-1 será 
executada; caso contrário, a expressão expressaoBooleana é false e a instrução statement-2 é 
executada. A palavra-chave else e a instrução statment-2 são opcionais. Se não houver uma 
cláusula else, nada acontecerá quando a expressão expressaoBooleana for false. 
Somente expressões booleanas, por favor 
A expressão em uma instrução if deve estar entre parênteses. Além disto, ela deve ser uma 
expressão booleana. Em algumas outras linguagens, você pode escrever uma expressão do 
tipo inteiro e o compilador silenciosamente converterá o valor inteiro em true ou false. O C# 
não suporta esse tipo de comportamento e o compilador reporta um erro se você escrever 
uma expressão desse tipo. 
Instruções if em cascata 
Você pode aninhar as instruções if dentro de outras instruções if. Dessa maneira, você pode 
encadear uma sequência de expressões booleanas, que são testadas uma após a outra até que 
uma delas seja avaliada como true. No exemplo a seguir, se o valor de day for 0, o primeiro 
teste será avaliado como true e dayName será atribuído a Sunday. Se o valor de day não for 0, 
o primeiro teste falhará e o controle passará para a cláusula else, que executará a segunda 
 
 
10 Módulo III: C# 
26 de janeiro de 2011 
instrução if e comparará o valor de day com 1. A segunda instrução if só é avaliada se o 
primeiro teste for false. Da mesma maneira, a terceira instrução if só será avaliada se o 
primeiro e o segundo teste forem false. 
if (day == 0) 
 dayName = “Sunday”; 
else if (day == 1) 
 dayName = “Monday”; 
else if (day == 2) 
 dayName = “Tuesday”; 
else if (day == 3) 
 dayName = “Wednesday”; 
else if (day == 4) 
 dayName = “Thursday”; 
else if (day == 5) 
 dayName = “Friday”; 
else if (day == 6) 
 dayName = “Saturday”; 
else 
 dayName = “unknow”; 
Usando a instrução switch 
Algumas vezes, quando você escreve uma instrução if em cascata, todas elas parecem muito 
similares, porque todas avaliam uma expressão idêntica. A única diferença é que cada if 
compara o resultado da expressão com um valor diferente. 
Nessas situações, você frequentemente pode reescrever a instrução if em cascata como uma 
instrução switch para tornar seu programa mais eficiente e legível. 
A sintaxe da instrução switch é a seguinte: 
switch (expressaoControle) 
{ 
 case expressaoConstante: 
 statements; 
 break; 
 case expressaoConstante: 
 statements; 
 break; 
 ... 
 default: 
 statements; 
 break; 
} 
expressaoControle é avaliado uma vez e as instruções abaixo de case, cujo valor 
expressaoConstante é igual ao resultado de expressaoControle, são executadas até a instrução 
break. A instrução switch, então, termina e o programa continua na primeira instrução após a 
chave de fechamento da instrução switch. 
 
 
11 Módulo III: C#8 
MXM Sistemas e Serviços de Informática | 2011 
Se nenhum dos valores de expressaoConstante for igual ao valor de expressaoControle, as 
instruções abaixo do rótulo default opcional são executadas. 
Por exemplo, podemos escrever a instrução if em cascata anterior como a instrução switch a 
seguir: 
switch(day) 
{ 
 case 0: 
 dayName = “Sunday”; 
 break; 
 case 1: 
 dayName = “Monday”; 
 break; 
 case 2: 
 dayName = “Tuesday”; 
 break; 
 ... 
 default: 
 dayName = “Unknow”; 
 break; 
} 
A instrução switch é muito útil, mas, infelizmente, você nem sempre poderá utilizá-la como 
gostaria. Todas as instruções switch devem seguir as seguintes regras: 
• A instrução switch só pode ser utilizada em tipos de dados primitivos, como int ou 
string. Como qualquer outro tipo, você terá de usar uma instrução if; 
• Os rótulos case devem ser expressões constantes, como 42 ou “42”. Se for necessário 
calcular valores do rótulo case em tempo de execução, use uma instrução if; 
• Os rótulos case devem ser expressões únicas. Em outras palavras, dois rótulos case 
não podem ter o mesmo valor. 
Você pode especificar que deseja executar as mesmas instruções para mais de um valor 
fornecendo uma lista de rótulos case sem nenhuma instrução interveniente; nesse caso, o 
código para o rótulo final da lista é executado para todas as instruções case. Entretanto, se um 
rótulo tiver uma ou mais instruções associadas, a execução não poderá prosseguir para os 
rótulos subseqüentes e o compilador gerará um erro. Por exemplo: 
switch(trumps) 
{ 
 case Hearts: 
 case Diamonds: //Permitido – nenhum código entre os rótulos 
 color = “Red”; //Código executado para Hearts e Diamonds 
 break; 
 case Clubs: 
 color: “Black”; 
 case Spades: //Erro – código entre rótulos 
 color: “Black”; 
 break; 
} 
 
 
12 Módulo III: C# 
26 de janeiro de 2011 
Usando instruções de Iteração 
While 
Você usa uma instrução while para executar repetidamente uma instrução enquanto uma 
expressão booleana for verdadeira. A sintaxe de uma instrução while é: 
While (expressaoBooleana) 
{ 
 statement 
} 
A expressão booleana é avaliada e, se for verdadeira, a instrução (statement) é executada e a 
expressão booleana é avaliada novamente. Se a expressão ainda for verdadeira, a instrução é 
repetida e a expressão avaliada mais uma vez. Este processo continua até que a expressão 
booleana seja avaliada como falsa, quando a execução sai da instrução while; a execução, 
então, continua na primeira instrução após a instrução while. Uma instrução while compartilha 
muitas semelhanças semânticas com uma instruçãoif (na verdade, a sintaxe é idêntica exceto 
pela palavra-chave): 
• A expressão deve ser uma expressão booleana; 
• A expressão booleana deve ser escrita entre parênteses; 
• Se a expressão booleana for avaliada como falsa na primeira avaliação, a instrução não 
será executada; 
Abaixo, uma instrução while que escreve os valores de 0 a 9 no console: 
 
int i = 0; 
while (i != 10) 
{ 
 Console.WriteLine(i); 
 i++; 
} 
Todas as instruções while devem terminar em algum ponto. Um erro comum do iniciante é 
esquecer de incluir uma instrução que faça a expressão booleana ser avaliada como falsa e 
terminar o loop. No exemplo, a instrução i++ executa esta função. 
For 
A maioria das instruções while tem a seguinte estrutura geral: 
inicialização 
while (expressaoBooleana) 
{ 
 statement; 
 atualizar variável de controle; 
} 
Uma instrução for permite que você escreva uma versão mais formal deste tipo de construção 
combinando a inicialização, a expressão booleana e a atualização. Você achará a instrução for 
 
 
13 Módulo III: C#8 
MXM Sistemas e Serviços de Informática | 2011 
útil porque é muito mais difícil de esquecer qualquer uma de suas três partes. Abaixo, a 
sintaxe da instrução for: 
 
for (inicialização; expressaoBooleana; variavelControle) 
{ 
 statement; 
} 
 
O loop while mostrado anteriormente, que exibe os números inteiros de 0 a 9, pode ser 
reconstruído como o loop for a seguir: 
 
for (int i = 0; i != 10; i++) 
{ 
Console.WriteLine(i); 
} 
 
A inicialização ocorre uma vez no início do loop. Se a expressão booleana for avaliada como 
verdadeira, a instrução é executada. A variável de controle é atualizada e a expressão 
booleana é reavaliada. Se a condição ainda for verdadeira, a instrução é executada 
novamente, a variável de controle é atualizada, a expressão booleana é avaliada mais uma vez 
e assim por diante. 
Observe que a inicialização ocorre apenas uma vez e que a instrução no corpo do loop sempre 
é executada antes que a atualização ocorra e que a atualização ocorre antes da expressão 
booleana ser avaliada. 
Você pode omitir qualquer uma das três partes de uma instrução for. Se você omitir a 
expressão booleana, ela será predeterminada como verdadeira. A instrução for a seguir é 
executada continuamente: 
 
for (int i = 0; ; i++) 
{ 
 Console.WriteLine(“alguém me pare!”); 
} 
Se você omitir as partes da inicialização e atualização, terá um loop while escrito de forma 
estranha: 
 
int i = 0; 
for (; i != 10;) 
{ 
Console.WriteLine(i); 
i++; 
} 
Ainda, é possível fornecer várias inicializações e várias atualizações em um loop for (você só 
pode ter uma expressão booleana). Para conseguir isso, separe as várias inicializações e 
atualizações por vírgula, como mostrado no exemplo a seguir: 
 
 
 
 
14 Módulo III: C# 
26 de janeiro de 2011 
for (int i = 0, j = 10; i <= j; i++, j--) 
{ 
 ... 
} 
Entendendo o escopo da instrução for 
Você talvez tenha observado que pode declarar uma variável na parte da inicialização de uma 
instrução for. Essa variável tem o escopo definido para o corpo da instrução for e desaparece 
quando a instrução for termina. Essa regra tem duas consequencias importantes. Em primeiro 
lugar, você não pode usar essa variável após a instrução for ter terminado, porque ela não 
pertencerá mais ao escopo. 
Segundo, você pode escrever duas ou mais instruções for próximas entre si que usam o 
mesmo nome de variável, porque cada variável está em um escopo diferente. 
As instruções break e continue 
Você já viu a instrução break sendo utilizada para sair de uma instrução switch. Você também 
pode usar uma instrução break para sair do corpo de uma instrução de iteração. Quando você 
sai de um loop, ele pára imediatamente e a execução continua na primeira instrução após o 
loop. Nem a atualização nem a condição de continuação do loop são reexecutadas. 
Por outro lado, a instrução continue faz com que o programa execute imediatamente a 
próxima iteração do loop (após a reavaliação da expressão booleana). 
Muitas diretrizes de programação recomendam o uso cauteloso da instrução continue ou 
simplesmente não utilizá-la, porque ela está frequentemente associada a um código difícil de 
entender. O comportamento do continue é também muito sutil. Por exemplo, se você executar 
uma instrução continue de dentro de uma instrução for, a parte da atualização será executada 
antes da execução da próxima iteração do loop.