Aula 1 - Java

Prévia do material em texto

Interfaces de BD
Aula 1: Java – características gerais e ambiente de
desenvolvimento
Apresentação
Com origem na década de 1990, a linguagem Java trouxe características que a tornaram muito popular, sendo
amplamente utilizada em sistemas críticos. Entre essas características podemos citar o padrão de escrita CamelCase,
paradigma orientado a objetos e processamento paralelo nativo.
Devemos conhecer a sintaxe básica da linguagem para utilizar corretamente todos os ferramentais disponíveis e, mais
que isso, precisamos utilizar um ambiente de desenvolvimento adequado para ganhar produtividade na implementação de
novos produtos.
Compreenderemos a utilização do NetBeans, um dos principais ambientes para programação em Java, e testaremos
diversas funcionalidades da plataforma, enquanto exploramos os elementos básicos da sintaxe.
Objetivos
Identi�car as características gerais do ambiente Java;
Usar um ambiente de desenvolvimento integrado para Java;
Revisar a sintaxe básica da linguagem Java.
Características do Java
Java é uma linguagem de programação orientada a objetos
desenvolvida na década de 1990 por uma equipe de
programadores che�ada por James Gosling, na empresa
Sun Microsystems. Atualmente, a linguagem está sob o
controle da Oracle, após a compra da Sun.
Desde a concepção, o Java trouxe alguns princípios básicos
que norteiam a sua própria evolução, destacando-se a
preocupação de executar em múltiplas plataformas e
garantir elementos de conectividade.
Fonte: Shuttershock por Wright Studio
Embora o Java seja considerado multiplataforma, ele executa em apenas uma plataforma, que é a máquina virtual Java (JVM),
mas como existem versões da JVM para os mais diversos sistemas operacionais, os programas criados em Java executam
em todas as plataformas que tenham uma versão da máquina virtual, o que o torna conceitualmente um sistema
multiplataforma. Note que os programas criados em Java não passam por um processo de linkedição, como C++ e Pascal,
mas também não podem ser interpretados no nível do código-fonte, como Java Script e Python, precisando ser apenas
compilados para execução na JVM.
Com o artifício da máquina virtual, que permite a execução de programas Java em qualquer plataforma, temos essa
abordagem, em que os programas são compilados, não podendo ser classi�cados como interpretados, mas sem gerar
executáveis para o sistema operacional.
Cada plataforma tem uma versão da máquina virtual Java, normalmente exigindo a instalação do Java Runtime Environment
(JRE), disponível no site da Oracle (www.oracle.com) de forma gratuita. Os programas feitos em Java executarão nessas
máquinas virtuais, sem qualquer preocupação com o sistema hospedeiro.
Comentário
A �loso�a básica do Java é a de que todos devem ser capazes de executar sistemas Java, e aqueles que executam Java
devem ser capazes de se comunicar com os demais que também executam.
 Outras características do JAVA
 Clique no botão acima.
Considerando a conectividade, temos uma grande facilidade para efetuar a conexão de rede com o uso de Java, pois
ele traz uma extensa biblioteca de componentes para a criação de Sockets, conexão HTTP e FTP, criação de clientes e
servidores de e‑mail, entre diversos outros, o que garante a segunda premissa básica da linguagem, referente à
manutenção da comunicação.
Outra característica inovadora no lançamento do Java, e que rapidamente foi adotada por outras linguagens, foi a
inclusão de um sistema coletor de lixo, ou Garbage Collector, que efetua a desalocação da memória de forma
automática. Algumas bibliotecas em C++ conseguem trabalhar com esse modelo de gerência de memória pelo uso de
Smart Pointers.
Com o uso do ambiente Java temos acesso a bibliotecas diversas, que nos permitem criar sistemas com interfaces
grá�cas complexas, com acesso a qualquer tipo de banco de dados, contando ainda com ferramentais muito práticos
para o mapeamento objeto-relacional. E se o objetivo não for o usuário �nal, mas a comunicação entre empresas
(B2B), podemos trabalhar com a construção de Web Services e Sockets, entre outros, garantindo a interoperabilidade
com outras plataformas.
O mecanismo de processamento paralelo é uma característica nativa do Java, facilitando a criação de processos que
envolvam a comunicação em rede, muitas vezes com chamadas assíncronas, bem como a construção de servidores.
Também podemos utilizar o paralelismo no processamento de múltiplos arquivos simultâneos, em operações de carga
no banco de dados, apenas para citar um exemplo.
Em termos de sintaxe, devemos estar atentos ao fato de que o Java é fortemente tipado, além de ser case-sensitive,
diferenciando maiúsculas e minúsculas, e adotar o padrão de escrita CamelCase. A linguagem utiliza diversos
paradigmas, tendo a base na orientação a objetos, mas com a inclusão de outros, como programação funcional e
comportamental.
JDK e NetBeans
Podemos desenvolver programas em Java com o simples uso de um editor de texto e os programas de compilação e execução
oferecidos a partir do Java Development Kit (JDK), o qual pode ser obtido gratuitamente no site da Oracle. Por exemplo, vamos
criar um pequeno programa de exemplo no bloco de notas.
 
public class Exemplo001 {
public static void main(String args[ ]) {
System.out.println("Alo Mundo");
}
}
Salve esse programa com o nome Exemplo001.java, depois, no prompt, digite dois comandos, no mesmo diretório em que o
arquivo foi salvo, lembrando que o diretório bin do JDK deve estar no PATH.
 
javac Exemplo001.java
java Exemplo001
Nós utilizamos o primeiro comando para compilar o arquivo de código-fonte .java e gerar o arquivo-objeto .class, enquanto o
segundo comando executa este .class, efetuando a chamada ao método main, ponto inicial de execução, e imprimindo a
mensagem "Alô Mundo".
Note que as linhas de código em Java são terminadas com o uso de ponto e vírgula, e o esquecimento desse terminador é uma
fonte de erros muito comum para os programadores da linguagem.
Atenção
O nome da classe pública deve ser exatamente igual ao nome do arquivo com extensão .java, caso contrário, ocorrerá um erro
de compilação.
Apesar de ser possível trabalhar apenas com o JDK e o bloco de notas, precisamos de um ambiente que garanta a
produtividade, e para isso devemos adotar um ambiente integrado de desenvolvimento (IDE). Vários desses ambientes estão
disponíveis para Java, alguns gratuitos e outros pagos, mas todos precisam do JDK instalado na máquina.
Alguns exemplos de IDEs para Java:
1
Eclipse;
2
NetBeans;
3
IntelliJ IDEA;
4
JDeveloper;
5
BlueJ;
6
JCreator.
Adotaremos o NetBeans, por ser mais didático e já trazer uma con�guração completa, sem a necessidade de novas
instalações. Como a versão gratuita do NetBeans foi desvinculada da Oracle e deixada aos cuidados do projeto Apache, você
poderá baixar a versão mais atual no site netbeans.apache.org.
Atenção
Você precisa ter instalado o JDK antes de instalar o NetBeans. Esteja atento à versão do JDK, pois, segundo informado no site,
há instaladores que não executam a partir do JDK14, devido à remoção de algumas funcionalidades existentes anteriormente.
O processo de instalação é bastante simples, não sendo necessário utilizar qualquer tipo de customização. Ao �nal da
instalação, poderemos abrir o ambiente e começar a entender o funcionamento dele.
O ambiente do NetBeans apresenta algumas divisões principais, conforme a numeração mostrada na �gura anterior:
1
Menu principal
Controle global das diversas opções da IDE, ativação e
desativação de painéis internos, instalação de plataformas,
entre diversas funcionalidades. É o controle de mais alto
nível do NetBeans.
2
Toolbar
Acesso rápido, de forma grá�ca, às opções mais utilizadas,
como criar arquivos e projetos, salvar arquivos e executar o
projeto.
3
Painel de controle
Aceita várias con�gurações, mas no padrão normal
apresenta uma divisão em três abas, com a visão lógica dos
projetos (Projetos), visão física (Arquivos), e acesso a
bancos de dados e servidores(Serviços).
4
Navegador
Permite o acompanhamento das características de qualquer
elemento selecionado da IDE, como classes em meio ao
código.
5
Editor de código
Voltado para a edição do código, com diversos auxílios
visuais e ferramentais de complementação.
6
Saída
Simula o prompt do sistema, permitindo observar a saída da
execução, bem como efetuar entrada de dados via teclado.
Com o NetBeans instalado, podemos criar nosso primeiro projeto. Note que a plataforma abrange diversos per�s de software,
como programas de console e baseados em janelas, Servlets, Web Services, e diversos outros. O primeiro passo na criação de
um projeto é a escolha do tipo correto.
As versões mais antigas do NetBeans iniciavam com todos os módulos ativados, o que deixava o ambiente mais pesado que o
necessário em diversas situações, mas as versões atuais ativam os módulos à medida que eles vão sendo solicitados pelo
desenvolvedor.
Também �cávamos restritos ao gerenciador de projeto Apache Ant nas versões antigas, mas as versões atuais permitem o
uso de projetos com base em Maven, padrão do Eclipse, e Gradle, utilizado no Intellij IDEA e derivados, como Android Studio.
No menu principal, escolha a opção File..New Project, ou na versão em português Arquivo..Novo Projeto, podendo ser
utilizada a tecla de atalho Ctrl+Shift+N;
Na janela que se abrirá escolha inicialmente Java with Ant, para o formato padrão de projetos do NetBeans, e nas opções
apresentadas escolha o tipo de projeto como Java Application, ou Aplicação Java, clicando em Next para acessar a tela
seguinte;
De�na o nome do projeto (Exemplo001) e diretório para armazenar seus arquivos (C:\MeusTestes), clicando em Finish ao
término. Deixe marcada a opção para a criação da classe principal.
Seguindo corretamente esses três passos, o seu projeto estará criado, e a classe principal, com o nome Exemplo001, estará
disponível para edição.
Para �ns de teste, vamos modi�car o código da nossa classe principal.
 
public class Exemplo001 {
public static void main(String[] args) {
for(int i=1; i<=10; i++)
System.out.printf("%d\n", i);
}
}
Para executar o projeto você terá várias opções, como pressionar F6, clicar no menu Run..Run Project, ou Executar..Executar
Projeto, na versão em português, ou ainda clicar no botão de execução da Toolbar.
Execute o projeto e você poderá observar a saída com a impressão dos números de 1 a 10 na área de acompanhamento de
saída do ambiente.
Dica
Uma característica essencial para qualquer ambiente de desenvolvimento é a presença de boas ferramentas de depuração de
código, e o NetBeans traz um ótimo conjunto delas. Com as ferramentas de depuração nós podemos executar o programa
passo a passo e veri�car a evolução dos valores das diversas variáveis, de forma a facilitar a correção de erros sistêmicos.
Vamos testar o depurador do NetBeans com o nosso projeto. Para isso, clique na parte cinza do editor de código, na qual �cam
os números de linhas, escolhendo a linha do comando for, e veri�que o aparecimento de um quadrado rosa, assim como a
marcação da linha na mesma cor.
Aqui criamos um ponto de parada, ou breakpoint, que indicará o local do código em que será interrompido o �uxo de execução
padrão e iniciado o acompanhamento passo a passo por meio da IDE.
Agora, em vez de executar da forma que �zemos antes, vamos depurar o projeto, o que pode ser iniciado a partir do menu,
botão de depuração da Toolbar, ou com a tecla de atalho CTRL+F5.
Você verá que a execução será paralisada na linha marcada, adicionando uma marcação na cor verde, e poderemos utilizar a
tecla F8 para executar cada passo no código. Note que a Toolbar se modi�ca, adicionando botões referentes às ações de
depuração.
Aqui utilizamos inicialmente a tecla F8 (Step Over), que executa cada linha de forma integral, mas temos várias outras opções.
Saber utilizar esses atalhos, na detecção de erros do sistema, trará grande benefício e produtividade para o desenvolvedor.
Ainda temos muitas outras características, além da execução passo a passo, como o acompanhamento do valor das variáveis
durante a execução.
No decorrer da disciplina, exploraremos mais características do NetBeans, mas por hora essas são su�cientes para
implementar nossos exemplos.
Tipos e operadores do Java
Quase tudo em Java é baseado em objetos. Basicamente, apenas os tipos nativos são considerados de forma diferente, mas
para cada tipo nativo existe uma ou mais classes Wrapper.
Sempre devemos lembrar que um tipo nativo corresponde a uma simples posição de memória, enquanto uma classe Wrapper,
além de comportar o valor correspondente ao tipo, oferece métodos para tarefas comuns, como conversões para outros tipos.
Tipo Nativo Wrapper Descrição do Tipo
byte Byte Inteiro de 1 byte
short Short Inteiro de 2 bytes
int Integer Inteiro de 4 bytes
long Long Inteiro de 8 bytes
char Character Caracteres ASCII
float Float Real de 4 bytes
double Double Real de 8 bytes
boolean Boolean Valores booleanos: true ou false
As variáveis aceitam diferentes formas de declaração e inicialização, como podemos observar a seguir:
 
int a, b, c;
boolean x = true; // Variável declarada e inicializada
char letra = 'W';
String frase = "Teste";
double f = 2.5, g = 3.7;
Para programas simples não há necessidade do uso extensivo de classes Wrapper, mas é aconselhável utilizá-las na criação de
sistemas que usem tecnologias de Web Services, ou frameworks de persistência, entre outros.
Atenção
Nas versões antigas do Java, as classes Wrapper deveriam ser alocadas com o uso de new. Atualmente podem ser associadas
ao valor representado de forma direta, exceção feita à classe String, que sempre permitiu a inicialização direta.
Lembre-se sempre de comentar seu código para que você e outros programadores possam revisá-lo com maior facilidade em
adaptações posteriores. Podem ser utilizados dois tipos de comentários:
Comentário de linha, com uso de //
Comentário longo, iniciado com /* e �nalizado com */
Cada tipo de variável aceitará um conjunto de operações a serem efetuadas sobre elas. Operadores aritméticos e binários
recebem variáveis numéricas e retornam resultados numéricos, enquanto relacionais fazem comparações entre números com
resultados booleanos e, �nalmente, os lógicos efetuam operações entre valores booleanos com retorno booleano.
Tipo Op Operação Observações e Exemplos
Aritmético
+ Soma int a, b = 2, c = 3; a = b + c;
* Subtração int a, b = 3, c = 2; a = b - c;
* Multiplicação float a = 2.0f, b = 3.0f; a *= b;
/ Divisão Com entradas inteiras trunca o resultado para o valor inteiro
% Resto Resto da divisão exige entradas inteiras
Binário
& And (E) int a = 5 & 3; // 0101 & 0011 = 0001
| Or (Ou) int a = 5 | 3; // 0101 | 0011 = 0111
^ Ou exclusivo int a = 5 ^ 3; // 0101 ^ 0011 = 0110
Relacional
> Maior que boolean b1 = 5.0f > 2.0f; // true
< Menor que boolean b1 = 6.0f < 3.0f; // false
>= Maior ou igual boolean b1 = 2 >= 2; // true
<= Menor ou igual boolean b1 = 2 <= 2; // true
== Igual a boolean b1 = 2 == 2; // true
!= Diferente de boolean b1 = 2 != 2; // false
Lógico
&& And (E lógico) boolean b1 = (2>3)&&(3>2);// false && true = false
|| Or (Ou lógico) boolean b1 = (2>3)||(3>2); // false || true = true
! Not (Negação) boolean b1 = !(2>3); // ! false = true
Algumas simpli�cações de escrita costumam ser bastante úteis na utilização dos diversos operadores da linguagem, como a
possibilidade de explicitar o operador à esquerda quando a operação é feita sobre a própria variável.
 
int a = 5, b = 2;
a += b; // Equivalente a escrever a = a + b;
Outros operadores interessantes são incrementos e decrementos unitários, podendo ocorrer de forma antecipada ou posterior
ao comando.
 
int a, b = 2, c = 2, d = 2;
a = ++b;
// b vai para 3, a recebe 3
a = c++;
// a recebe 2, c vai para 3
a = d--;
// a recebe 2, d vai para 1
Como a própria atribuição é um operador, nas linguagens derivadas do C, como o Java, ela também pode ser sequenciada. O
operador de atribuiçãosempre retorna o valor atribuído, permitindo o uso em cadeia.
 
 int a, b, c;
a = b = c = 2;
// Todos recebem o valor 2
a = a + b;
c = c – a;
// Forma padrão de escrita
a += b;
c -= a;
// Explicitando o operador à esquerda
c -= a += b;
// Utilizando o sequenciamento
Agora que vimos alguns detalhes acerca dos operadores, vamos criar um pequeno programa de exemplo no NetBeans. Após
codi�car, execute para veri�car a saída, e teste com a depuração para acompanhar a evolução dos valores nas variáveis.
 
package exemplo002;
public class Exemplo002 {
public static void main(String[] args) {
int a = 5, b = 32, c = 7;
System.out.printf("A: %d\t B: %d\t C: %d\n",a,b,c);
b = b - c;
b /= a;
System.out.printf("A: %d\t B: %d\t C: %d\n",a,b,c);
b = a ^ c;
System.out.printf("A: %d\t B: %d\t C: %d\n",a,b,c);
b++;
System.out.printf("A: %d\t B: %d\t C: %d\n",a,b,c);
}
}
/*
A saída deste programa deverá ser:
A:5 B:32 C:7
A:5 B:5 C:7
A:5 B:2 C:7
A:5 B:3 C:7
*/
Algo muito interessante nesse exemplo é o uso do comando printf, que só
foi possível no Java quando passou a incorporar conjuntos variantes de
parâmetros, ou varargs, na sintaxe. Nesse comando temos um parâmetro
obrigatório do tipo texto e uma sequência de parâmetros com quantidade
variável, podendo ser zero.
O comando printf permite uma saída formatada, em que cada elemento do tipo %d receberá um valor inteiro, \n é utilizado para
pular de linha e o caractere \t representa uma tabulação. No caso, como são três ocorrências de %d na expressão, ela receberá
as três variáveis inteiras logo após a vírgula, preenchendo as lacunas %d com os valores dessas variáveis na ordem oferecida.
Vamos observar a utilização de operadores relacionais e lógicos no próximo exemplo.
Exemplo
 
package exemplo003;
public class Exemplo003 {
public static void main(String[] args) {
int a = 5, b = 32, c = 7;
boolean x;
x = a < b;
System.out.println("PASSO 1: "+x);
x = (b > a) && (c > b);
System.out.println("PASSO 2: "+x);
b /= a -= 1;
c++;
x = (b==c);
System.out.println("PASSO 3: "+x);
}
}
/*
A saída deste programa deverá ser:
PASSO 1: true
PASSO 2: false
PASSO 3: true
*/
No primeiro passo temos x recebendo a comparação a < b, que é verdadeira. No segundo passo, a comparação b > a é
verdadeira, mas como c > b é falsa, o operador lógico aplicado resultará em um valor falso.
Em seguida são feitas algumas operações aritméticas concatenadas, além de um operador de incremento, as quais poderiam
ser expressas como:
 
a = a – 1; // a passa a valer 4
b = b / a; // b é divido por a (4) e fica com 8
c = c + 1; // c passa a valer 8
Após essas operações, os valores de b e c são iguais, e a comparação se torna verdadeira para o terceiro passo.
Comentário
No Java, a divisão entre inteiros retorna inteiro, enquanto para variáveis do tipo ponto �utuante será um valor real, ou seja, se
efetuarmos a operação 5/2 teremos 2, enquanto 5.0/2 dará 2.5.
Controle de �uxo
Até o momento nós criamos apenas programas
sequenciais, ou seja, com instruções que são executadas
sempre na mesma ordem, sem repetições ou desvios, mas
os processos nem sempre podem ser implementados
dessa forma. Não são raras as vezes em que temos de
tomar decisões entre dois �uxos alternativos de ação, ou
quando precisamos repetir uma sequência do �uxo durante
a execução do processo completo.
Precisamos compreender as instruções para controle de
�uxo, as quais se dividem em estruturas de decisão, ou
seleção, e estruturas de repetição.
As estruturas de decisão permitem a execução de
determinadas ações apenas perante condições
especi�cadas.
Fonte: Shuttershock por astel design
A primeira estrutura de decisão que temos é if..else, que permite executar o �uxo apenas perante uma condição. Existe ainda a
possibilidade de criar um segundo �uxo para a condição contrária, mas não é obrigatório.
 
if ( << condição >> ) {
// instruções para o caso verdadeiro
} else {
// instruções para o caso falso
}
Se a condição especi�cada entre parênteses tiver valor verdadeiro, o primeiro bloco de comandos será executado, e se for falso
quem será executado é o segundo bloco. O uso de chaves é necessário apenas quando temos blocos constituídos de mais de
um comando, e o uso de else é opcional.
 
package exemplo004;
import java.util.Scanner;
 
public class Exemplo004 {
public static void main(String[] args) {
Scanner s1 =new Scanner(System.in);
System.out.println("DIGITE UM NÚMERO:");
int x = s1.nextInt();
if(x%2==0)
System.out.println("O NÚMERO É PAR");
else
System.out.println("O NÚMERO É ÍMPAR");
}
}
No exemplo foi utilizado um objeto do tipo Scanner, inicializado com a entrada de dados padrão via teclado (System.in), para
obter um número inteiro digitado pelo usuário, o que pode ser observado no uso da instrução s1.nextInt( ). Executando o
exemplo no NetBeans, essa entrada ocorrerá na mesma área em que observamos as saídas do programa.
Após o usuário entrar com o número pelo teclado, ocorre o teste do if para saber se o resto da divisão por dois resulta em zero,
o que fará imprimir a mensagem "O NÚMERO É PAR" e, se o resto da divisão não for zero, será impresso "O NÚMERO É ÍMPAR"
a partir do else. Como os blocos tinham apenas uma instrução cada, o uso de chaves não foi necessário em nenhum dos dois.
Um operador bastante interessante é o ternário, que permite substituir algumas estruturas de decisão para a de�nição de
valores alternados.
 
if(x%2==0) y = "PAR"; else y = "IMPAR";
// Escrevendo como ternário...
y = (x%2==0) ? "PAR" : "IMPAR";
Em algumas situações precisamos executar ações diferentes para cada valor de um determinado parâmetro, e isso poderia
envolver diversas instruções do tipo se valor igual a. No entanto, para esses casos, podemos utilizar a estrutura switch..case,
que determina desvios de �uxo especí�cos a partir do valor de uma determinada variável.
 
switch ( << variável >> ) {
case valor1:
// instruções para o valor1
break;
case valor2:
// instruções para o valor2
break;
default:
// instruções para valores que não foram previstos
}
O comando switch desviará o �uxo de execução para os comandos case, de acordo com o valor da variável, sendo que o
comando default será executado caso o valor não esteja entre aqueles que foram previstos. Cada seção case deve ser
terminada com o comando break, pois a ausência dele causará a continuidade da execução, invadindo a seção seguinte.
COMENTÁRIO
Um exemplo simples de utilização de switch..case seria a construção de um menu de opções em modo texto para um sistema
qualquer. De acordo com o valor digitado pelo usuário seria executada a ação correspondente do sistema.
Exemplo
 
package exemplo005;
import java.util.GregorianCalendar;
import java.util.Scanner;
public class Exemplo005 {
public static void main(String[] args) {
Scanner s1 =new Scanner(System.in);
System.out.println("DIGITE O DIA ATUAL:");
int d = s1.nextInt();
System.out.println("DIGITE O MÊS ATUAL:");
int m = s1.nextInt();
System.out.println("DIGITE O ANO ATUAL:");
int a = s1.nextInt();
GregorianCalendar g1 = new GregorianCalendar(a,m-1,d);
switch(g1.get(GregorianCalendar.DAY_OF_WEEK)){
case 1:
System.out.println("DOMINGO! FERIADO! :)");
break;
case 2: case 3:
case 4: case 5:
case 6:
System.out.println("DIA ÚTIL! TRABALHANDO. :(");
break;
case 7:
System.out.println("SÁBADO! FERIADO! :)");
break;
default:
System.out.println("ALGO ESTÁ ERRADO....");
}
}
}
Aqui utilizamos, além do Scanner, um objeto do tipo
GregorianCalendar. Ele permitirá tratar elementos de data e
hora, sendo inicializado com ano, mês (0 a 11) e dia.
Após a inicialização, utilizamos
get(GregorianCalendar.DAY_OF_WEEK) para veri�car o dia
da semana, o qual é obtido como um valor inteiro de 1 a 7,
correspondendo aos dias de domingo a sábado.
No exemplo, a estrutura switch utiliza esse valor para
imprimir a frase equivalente a cada dia da semana, sendo a
opção default executada apenas para valores fora da faixade 1 a 7, algo que não ocorrerá devido ao uso de
GregorianCalendar.
Fonte: Shuttershock por astel design
Outra forma de redirecionar o �uxo de execução é pelo uso de estruturas de repetição. Elas servem para repetir a execução de
um comando ou bloco de comandos enquanto determinada condição for verdadeira.
A primeira estrutura de repetição que iremos considerar será while, em que o bloco de comandos é executado enquanto a
condição for verdadeira.
 
while( << condição >> ) {
// Bloco de Comandos
}
Podemos exempli�car a estrutura de repetição while com a implementação de um algoritmo incremental para o cálculo de
juros cumulados, em que os juros de todos os meses anteriores são aplicados em cada parcela, de uma forma cumulativa.
Por exemplo, se tivermos um produto com preço à vista de R$1000,00 em 10 parcelas, com juros de 2% ao mês,
nós teríamos a seguinte distribuição de valores:
Valor de base: R$100,00 
Mês 1: R$100,00 * 1,02 = R$102,00 
Mês 2: R$100,00 * 1,02 * 1,02 = R$104,04 
... 
Mês 10: R$100,00 * 1,0210 = R$121,90
Como as parcelas não podem ter valores diferenciados em boletos, elas devem ser somadas e o total dividido
igualmente entre os 10 meses.
Vamos ao exemplo.
 
package exemplo006;
public class Exemplo006 {
public static void main(String[] args) {
float valor = 1000.0f; // Valor inicial
int num_parcelas = 10; // Numero de parcelas
float juros = 2.0f; // Juros mensais
float parcelaBase = valor / num_parcelas;
float totalParcelas = 0.0f;
int contador = 1;
while(contador <= num_parcelas){
totalParcelas += parcelaBase *
Math.pow(1.0f+juros/100, contador);
contador++;
}
System.out.printf("Você deverá pagar: R$%.2f ao mês.\n",
totalParcelas/num_parcelas);
}
}
/*
Saída esperada deste programa:
Você deverá pagar: R$111,69 ao mês.
*/
Como o cálculo do valor real de cada parcela, antes do rateio, envolve a aplicação dos juros elevados ao número de meses
decorridos, foi necessário utilizar o método Math.pow, que eleva uma base a uma potência qualquer. Essa é apenas uma das
diversas funções matemáticas disponibilizadas pela classe Math.
O bloco se repete, com o contador iniciando em 1 e incrementando até o total de meses, e a cada rodada é somado o valor real
da parcela referente àquele mês no valor total. Não esqueça o incremento do contador, pois caso contrário ocorrerá um loop
in�nito.
Depois de sair do loop, basta pegar o valor total e dividir pelo número de meses, para que todas as parcelas tenham o mesmo
valor, mas levem os juros totais praticados embutidos.
Na estrutura de repetição do..while, o teste é efetuado apenas no �nal do bloco, o que garante ao menos uma execução.
 
do {
// Bloco de Comandos
} while( << condição >> );
Esse tipo de estrutura é interessante quando não conhecemos o valor que será testado na condição antes de uma primeira
execução do loop.
 
package exemplo007;
import java.util.Scanner;
public class Exemplo007 {
public static void main(String[] args) {
Scanner s1 = new Scanner(System.in);
int total = 0, x;
do {
System.out.println("Digite um número qualquer, "+
"ou 0 para terminar.");
total += (x = s1.nextInt());
}while(x!=0);
System.out.println("A soma dos números será: "+total);
}
}
Nesse programa foi utilizado o Scanner para capturar os valores inteiros digitados pelo usuário, mas como a condição de
parada seria um valor zero, e não temos como conhecer o valor antes da digitação, o uso de do..while é bem adequado. Após a
captura do valor em x, ele é somado ao total, e, no �nal, este é apresentado para o usuário.
A última estrutura de repetição que temos é baseada no comando for, que normalmente é aplicado em repetições com início,
incremento e �m bem de�nidos, segundo uma regra linear. Um exemplo simples seria um índice variando de 1 a 10 com
incremento de 1.
Apesar de o cenário padrão indicar esse tipo de utilização para o comando for, nas linguagens derivadas do C, como o Java,
temos uma liberdade muito grande para de�nir variações da estrutura.
 
for( << inicialização >> ; << condição >> ; << incremento >> ) {
// Bloco de Comandos
}
No setor de inicialização, teremos a de�nição de valores iniciais para as variáveis de controle do loop. Esse setor pode �car
vazio, considerando uma inicialização anterior ao loop, ou pode conter várias inicializações separadas por vírgula.
Os setores são separados por ponto e vírgula, sendo a condição de saída de�nida no segundo setor. Aqui precisamos de um
valor booleano, sendo o único setor que não aceita mais de uma instrução, mas que pode �car vazio, indicando uma repetição
eterna. Na verdade, qualquer estrutura de repetição pode ser �nalizada com o uso da instrução break.
Finalmente temos o setor de incremento, no qual deve ocorrer a atualização dos valores nas variáveis de controle. Novamente
podemos ter mais de uma instrução, ou até mesmo nenhuma, e não precisa ser um incremento linear.
O nosso exemplo anterior de juros compostos, com uso de while, seria um bom candidato para o comando for.
 
float totalParcelas = 0.0f;
for(int contador = 1; contador<=num_parcelas; contador++){
totalParcelas += parcelaBase *
Math.pow(1.0f+juros/100, contador);
}
 Vetores no Java
 Clique no botão acima.
Quando precisamos de uma determinada quantidade de elementos de um mesmo tipo, é comum o uso de vetores na
programação estruturada. Eles representam uma quantidade invariante de elementos, dispostos de forma sequencial
na memória, que podem ser acessados a partir de seus índices.
Para o Java quase tudo é representado em termos de objetos, e não seria diferente para os vetores, que são objetos da
classe Array, tendo, além do acesso aos elementos de forma indexada, alguns atributos como length, que fornece a
quantidade de elementos do vetor. Em diversas linguagens temos vetores multidimensionais constituindo matrizes,
mas no Java o que temos são Arrays de Arrays, indicando que não necessariamente teremos uma estrutura
quadrática.
No exemplo seguinte, podemos observar a utilização de um vetor em uma estrutura de repetição while.
Nesse exemplo é criado um vetor inicializado na criação, assumindo 6 posições, ou seja, terá os índices de 0 a 5.
Em seguida procedemos ao somatório desses valores com o uso de um comando while, tendo como condição
posicao<x1.length. Como o length nesse caso é 6, a posição varia de 0 a 5, e a cada rodada, o valor do vetor na
posição equivalente é adicionado à variável soma, mas não podemos esquecer de incrementar a posição, pois caso
contrário teríamos uma repetição in�nita.
O uso de length permite que seja alterada a quantidade de elementos do vetor na inicialização, sem a necessidade
de modi�cações no restante do código.
O uso de length permite que seja alterada a quantidade de elementos do vetor na inicialização, sem a necessidade de
modi�cações no restante do código.
 
public class Exemplo008 {
public static void main(String[] args) {
int[] x1 = {21, 32, 15, 27, 33, 17};
int posicao = 0;
int soma = 0;
while(posicao
// Enquanto for menor que o tamanho do vetor
soma += x1[posicao];
posicao++;
}
System.out.println(soma);
}
}
/*
Saída esperada deste programa: 145
Resultado da soma: 21+32+15+27+33+17
*/
 
x1[0]=21 x1[1]=32
x1[2]=15 x1[3]=27
x1[4]=33 x1[5]=17
Nesse código temos vários exemplos de manipulação de vetores e matrizes, em que o mais simples é o cálculo do
determinante de matriz 3x3, expresso apenas como um cálculo direto. Para os somatórios são utilizados comandos
de repetição for, sendo que varremos todo o vetor, somando os valores elevados à potência desejada.
No programa principal temos os vetores de coordenadas x e y, a partir dos quais será gerada a matriz de coe�cientes e
o vetor de restrições, com o uso dos somatórios especi�cados no modelo de cálculo. Isso forma um sistema linear
que pode ser resolvido pela regra de Cramer, baseada na razão entre determinantes, para a obtenção direta dos
resultados.
 
public class Exemplo009 {
public static double somaPot(double w[],double v[], int potv, boolean mY){
double soma = 0;
for(int i=0; i<v.length; i++)
soma += (mY?w[i]:1) * Math.pow(v[i], potv);
return soma;
}
 
// Determinante 3x3
public static double det3x3(double m[][]){
return m[0][0]*(m[1][1]*m[2][2]-m[2][1]*m[1][2])
-m[0][1]*(m[1][0]*m[2][2]-m[1][2]*m[2][0])
+m[0][2]*(m[1][0]*m[2][1]-m[1][1]*m[2][0]);
}
 
public static double[] cramer3(double matriz[][], double[] restricoes){
double[] resultado = new double[3];
double detM = det3x3(matriz);
for(int i=0; i<3; i++){
double mAux[][] = new double[3][3];
for(int lin=0; lin<3; lin++)
for(int col=0; col<3; col++)
mAux[lin][col] = (col==i) ? restricoes[lin] : matriz[lin][col];
resultado[i] = det3x3(mAux)/detM;
}
return resultado;
}
 
public static void main (String args[]){
double x[] = {5.0,2.5,3.5,4.0,2.5,6.0,7.5};
double y[] = {1.6,6.5,5.0,3.5,6.0,3.5,4.0};
// função de regressão quadrática y = a0 + a1x + a2x**2
// | n S(x) S(x**2) | | a0 | | S(y) |
// | S(x) S(x**2) S(x**3) | X | a1 | = | S(y*x) |
// | S(x**2) S(x**3) S(x**4) | | a2 | | S(y*x**2) |
double matrizSoma[][] = new double[3][3];
double vetorRestr[] = new double[3];
for (int i=0;i<3;i++){
vetorRestr[i] = somaPot(y,x,i,true);
for(int j=0; j<3; j++)
matrizSoma[i][j] = somaPot(null,x,i+j,false);
}
// Matrizes calculadas geram sistemas lineares
// Resolvendo por Cramer...
double a[] = cramer3(matrizSoma, vetorRestr);
System.out.printf("Equacao: %.2f+(%.2fx)+(%.2fx**2)\n", a[0],a[1],a[2]);
}
}
Também devemos observar a de�nição de uma série de métodos no código, o que foi feito para evitar a replicação de
alguns trechos. Todo método em Java tem um nome, tipo de retorno e parâmetros, mas o tipo de retorno pode ser
void, indicando que não retornará valores, e podemos ter métodos sem parâmetros.
Este é um bom exemplo do uso de vetores e estruturas de repetição para a resolução de problemas práticos de cálculo
que não sejam tão triviais.
A �gura seguinte apresenta a plotagem da equação, descoberta com esse procedimento, e dos pontos analisados,
expressos nos vetores. Foi utilizada a linguagem Python para o desenho do grá�co.
Uma observação é a de que os vetores aceitam outra forma de utilização do comando for, sem a necessidade de
indexação. Se tivermos apenas uma variável envolvida, podemos trabalhar nesse modelo de acesso direto para efetuar
um somatório.
Esse trecho de código indica que, para cada elemento pertencente a v, será adicionado o valor desse elemento à
variável soma, retornando o somatório dos valores do vetor ao �nal do método.
 
public static double somaSimples(double v[]){
double soma = 0;
for(double elemento: v)
soma += elemento;
return soma;
}
Atividades
1. Uma das características do Java é a possibilidade de execução em plataformas distintas sem a necessidade de recompilar o
código fonte. Qual componente permite a existência dessa característica?
a) Garbage Collector
b) JVM
c) JDK
d) NetBeans
e) Eclipse
2. O uso de uma IDE traz uma série de benefícios para o programador em termos de produtividade, e existem muitas opções
para Java. Qual dos produtos a seguir não pode ser classi�cado como uma IDE?
a) Elipse
b) JDeveloper
c) Intellij IDEA
d) NetBeans
e) JDK
3. Com o uso do NetBeans podemos visualizar os elementos constituintes de um documento de código-fonte de maneira
hierárquica. Qual painel permite isso?
a) Navegador
b) Serviços
c) Editor de código
d) Toolbar
e) Saída
4. Observando a sintaxe do comando for, e considerando que todas as variáveis utilizadas foram previamente declaradas, qual
das opções seguintes irá necessariamente gerar um erro de compilação?
a) for(a=1,b=20; a < b; a++,b+=2)
b) for( ; a++<10; )
c) for(a=1; a=10; a++)
d) for( ; ; )
e) for(a=200; a>1; a/=2)
5. Implemente um programa em Java para imprimir os 10 primeiros números primos que ocorrem após o número 1. Lembre-se
de que um número primo é aquele divisível apenas por ele mesmo e por 1.
Notas
Título modal 1
Lorem Ipsum é simplesmente uma simulação de texto da indústria tipográ�ca e de impressos. Lorem Ipsum é simplesmente
uma simulação de texto da indústria tipográ�ca e de impressos. Lorem Ipsum é simplesmente uma simulação de texto da
indústria tipográ�ca e de impressos.
Título modal 1
Lorem Ipsum é simplesmente uma simulação de texto da indústria tipográ�ca e de impressos. Lorem Ipsum é simplesmente
uma simulação de texto da indústria tipográ�ca e de impressos. Lorem Ipsum é simplesmente uma simulação de texto da
indústria tipográ�ca e de impressos.
Referências
CORNELL, G.; HORSTMANN, C. Core Java. 8. ed. São Paulo: Pearson, 2010.
DEITEL, P.; DEITEL, H. Java: como programar. 8. ed. São Paulo: Pearson, 2010.
ESTÁCIO. Desenvolvimento de software: Aula 1. Disponível em: https:/cursos/gon117/aula1.html. Acesso em: 20 jun. 2020.
FONSECA, E. Desenvolvimento de software. Rio de Janeiro: Estácio, 2015.
SANTOS, F. Programação I. Rio de Janeiro: Estácio, 2017.
Próxima aula
Princípios da orientação a objetos;
Sintaxe Java para orientação a objetos;
Modelagem comportamental.
Explore mais
Leia os textos:
QuickSort em Java – algoritmo, ilustração e implementação
Algoritmos de backtracking explicados
Embaralhar uma matriz ou uma lista - algoritmo em Java – tutorial
javascript:void(0);
javascript:void(0);
javascript:void(0);
javascript:void(0);