Java

1. Programação Orientada a
Objetos
Variáveis, Operadores e Estruturas
de Controle
Prof. Dr. Jucimar Souza
jucimar.souza@ifam.edu.br

2. Variáveis, Operadores e Estruturas de
Controle
• Objetivos da Aula
• Conhecer os Tipos de Dados
• Aprender as Regras de Declaração de Variáveis
• Abstrair as Recomendações Gerais de Nomenclatura
• Verificar os Operadores e sua procedência
• Estudar e Implementar programas envolvendo
Estruturas de Controle

3. 2.1 Tipos de Dados Primitivos
A linguagem Java possui 8 tipos básicos de dados e
que são agrupados em 4 categorias, a saber:
◼ Inteiros
◼ Byte(byte), Inteiro Curto(short), Inteiro
(int) e Inteiro Longo(long)
◼ Ponto Flutuante
◼ Ponto Flutuante Simples (float) ou Duplo
(double)
◼ Caractere
◼ Caractere (char)
◼ Lógico
◼ Boleano (boolean)

4. 2.1.1 Tipos de Dados Inteiros
◼ Existem 4 diferentes tipos de dados inteiros, a
saber:
Tipo Faixa de Valores bits
byte -128 a +127 8
short (inteiro curto ) -32.768 a +32.767 16
int (inteiro) -2.147.483.648 a
+2.147.483.647
32
long (inteiro longo) -9.223.372.036.854.775.808 a
+9.223.372.036.854.775.807
64
 Por default os valores literais são tratados como inteiros
simples (int).

5. 2.1.2 Tipos de Dados em Ponto Flutuante
◼ Existem duas representações para pontos flutuantes
que se diferenciam pela precisão oferecida:
◼ float: reais com precisão simples (32 bits)
◼ double: oferece dupla precisão (64 bits)
◼ Os valores em ponto flutuante do Java estão em
conformidade com o padrão IEEE 754, tendo:
◼ O ponto como separador de casas decimais
◼ O expoente podendo ser escrito usando o caracter ‘e’ ou
‘E’. Exemplo: 2.35E6 (= 2.35x106 = 2350000) ou
2.3578e-2 (= 2.3578 x 10-2 = 0.023578)
IEEE: Institute for Electrical and Electronic Engineers (www.ieee.org.br)

6. 2.1.3 Tipos de Dados Caractere
◼ O tipo char permite a representação de caracteres individuais.
◼ Representação interna no padrão UNICODE, cada caractere ocupa 16 bits (2
bytes) sem sinal, o que permite representar até 32.768 char.
◼ O valor literal de caracteres deve estar delimitado por aspas simples.
◼ Alguns caracteres especiais:
Representação Significado
n Nova linha
r Retorno de carro
b Retrocesso (backspace)
t Tabulação
f Nova página
’ Apóstrofe
” Aspas
Barra Invertida
u223d Caractere UNICODE 233d
fca Hexadecimal

7. 2.1.4 Tipos de Dados Lógico
◼ O tipo lógico boolean é capaz de assumir valores false (falso)
ou true (verdadeiro) que equivalem aos estados off (desligado)
e on (ligado) ou no (não) e yes (sim).
◼ Não existem equivalência entre os valores do tipo lógico e
valores inteiros tal como existem em C/C++.

8. 2.2 Declaração de Variáveis
◼ Uma variável em uma linguagem é similar a uma variável em
Matemática.
◼ Matemática  Nome + Domínio + Valor
◼ Linguagem  Nome + Tipo + Valor (ou conteúdo)
◼ O nome de uma variável em Java pode ser uma seqüência de
um ou mais caracteres alfabéticos e numéricos, iniciados por
uma letra ou ainda pelos caracteres ‘_’ (undescore) ou ‘$’
(cifrão).
◼ Os nomes não podem conter outros símbolos gráficos,
operadores ou espaços em branco, podendo ser
arbitrariamente longos embora apenas os primeiros 32
caracteres serão utilizados para distinguir nomes de diferentes
variáveis.
◼ Letras maiúsculas são consideradas diferentes das minúsculas.
◼ Exemplos válidos de nomes de variáveis:
a resultado x2o $minimo
_especial RESULT Maximo DataNasc

9. 2.2 Declaração de Variáveis
◼ Exemplos inválidos:
1x Resul geral salario-minimo int
◼ As palavras reservadas da linguagem Java, que portanto
não podem ser utilizadas como nome de variáveis ou outros
elementos, são:
abstract
assert
boolean
break
byte
case
catch
char
class
const
continue
default
do
double
else
enum
extends
false
final
finally
float
for
goto
if
implements
import
instanceof
int
interface
long
native
new
null
package
private
protected
public
return
short
static
strictfp
super
switch
synchronized
this
throw
throws
transient
true
try
void
volatile
while

10. 2.2 Declaração de Variáveis
 Declaração de uma variável
 Tipo nome_var1 [,nome_var2 [,nome_var3 [… ,nome_varN]]] ;
 Declaração Individual
int i;
float total, preco;
byte mascara;
double valorMedio;
 Declaração em Conjunto
char nota1, nota2;
 Declaração com valor inicial para uma variável
int quantidade = 0;
float angulo = 1.35;
boolean ok = false;
char letra = ‘a’;
 As variáveis podem ser declaradas em qualquer ponto do programa e
estão em conformidade com as regras de escopo de variáveis.

11. 2.2.1 Regras para Nome de Variáveis
 Em Java, recomenda-se que a declaração de variáveis utilize nome
iniciados com letras minúsculas. Caso o nome seja composto de mais
de uma palavra, as demais devem ser iniciadas com letras maiúsculas
tal como nos exemplos:
contador total sinal
posicaoAbsoluta mediaMinimaBimestre mediaFinalTurma
 A utilização de caracteres numéricos no nome é livre enquanto o uso
do traço de sublinhar (underscore ‘_’) não é recomendado.

12. 2.3 Comentários
 São trechos de texto, usualmente explicativos, inseridos dentro do
programa de forma que não sejam considerados como parte do
código.
 Tipos de comnetários:
 De uma linha (//)
.
// comentário de uma linha
x = x*i; // comentário após duas barras
/* comentário de
múltiplas linhas */
/** comentário de documentação que
* também pode ter múltiplas linhas
*/
 De documentação
 Uma ou mais linhas (múltiplas linhas)

13. 2.3 Comentários (cont.)
 Geralmente o comentário de documentação é posicionado
imediatamente antes do elemento a ser documentado e tem seu
conteúdo extraído automaticamente pelo utilitário javadoc.
 Esta ferramenta gera páginas em formato HTML contendo os
comentários organizados da mesma forma que a documentação
fornecida juntamente com o JDK.
 Pode-se adicionam tags html aos comentários de documentação,
incluindo imagens, tabelas, textos explicativos, links e outros
recursos.
 Tipos de informações administradas pelo javadoc que através de
marcadores pré-definidos iniciados com “@” permitem a criação
automática de ligações hipertexto entre a documentação e a
formatação padronizada de outros elementos, tais como o nome do
autor, parâmetros, tipos de retorno, etc, como abaixo:
/** Classe destinada ao armazenamento de dados relacionados a
* arquivos ou diretórios.
* <p> Pode ser usada para armazenar árvores de diretórios.
* @autor Jucimar Souza
* @see java.io.File
*/

14. 2.4 Operadores
A linguagem Java oferece um conjunto bastante amplo de
operadores destinados a realização de operações aritméticas, lógicas,
relacionais e de atribuição.
 Operadores Aritméticos
Operador Significado Exemplo
+ Adição a + b
- Subtração a - b
* Multiplicação a*b
/ Divisão a/b
% Resto da divisão inteira a%b
- Sinal negativo (- unário) -a
+ Sinal positivo (+ unário) +a
++ Incremento unário ++a ou a++
-- Decremento unário --a ou a--
Estes operadores aritméticos podem ser combinados para formar expressões onde
deve ser observada a precedência (ordem convencional) de avaliação dos
operadores.

15. 2.4 Operadores
◼ Multiplicação e Divisão: * e /
◼ int um = 3 / 2; // divisão de inteiros gera um inteiro
◼ float umEmeio = (float) 3 / 2; // ocorre promoção aritmética para float
◼ double xyz = umEmeio * um; // ocorre promoção aritmética para float
◼ Módulo: %
◼ int resto = 7 % 2; // resto = 1
◼ Adição e Subtração: + e -
◼ long l = 1000 + 4000;
◼ double d = 1.0 – 0.01;
◼ Concatenação:
◼ long var = 12345;
◼ String str = “O valor de var é “ + var;
◼ Na concatenação de Strings, as variáveis ou literais são promovidos a
String antes:
◼ String str = “O valor de var é “ + Long.toString( var );

16. 2.4 Operadores (cont.)
Exemplo 2.1: Um exemplo de uma aplicação que declara algumas
variávies, atribui valores iniciais e efetua algumas operações imprimindo os
resultados obtidos.
//Aritmetica.java
public class Aritmetica {
public static void main (String args[]) {
//Declaração e inicialização das variáveis
int a = 5, b = 2;
//Várias situações envolvendo os operadores aritméticos
System.out.println("a = " + a);
System.out.println("b = " + b);
System.out.println("-b = " + (-b));
System.out.println("a + b = " + (a + b));
System.out.println("a - b = " + (a - b));
System.out.println("a * b = " + (a*b));
System.out.println("a / b = " + (a/b));
System.out.println("(float) a / b = " + ( (float) a/b));
System.out.println("a % b = " + (a%b));
System.out.println("a++ = " + (a++));
System.out.println("a = " + a);
System.out.println("--b = " + (--b));
System.out.println("b = " + b);
} //fim do método main
} //fim da classe Aritmetica

17. 2.4 Operadores (cont.)
 Operadores Relacionais
 São operadores que permitem comparar valores literais, variáveis ou
o resultado de expressões retornando um resultado do tipo lógico, isto
é, um resultado falso ou verdadeiro. Os operadores relacionais
disponíveis são:
Operador Significado Exemplo
== Igual a = = b
!= Diferente a != b
> Maior que a > b
>= Maior ou igual a a >= b
< Menor que a < b
<= Menor ou igual a a <= b

18. 2.4 Operadores (cont.)
Operad
or
Significado Exemplo
== Igual a = = b
!= Diferente a != b
> Maior que a > b
>= Maior ou igual a a >= b
< Menor que a < b
<= Menor ou igual a a <= b
//Relacional.java
public class Relacional{
static public void main (String args[]) {
int a = 15, b = 10;
System.out.println("a = " + a);
System.out.println("b = " + b);
System.out.println("a = b => " + (a == b));
System.out.println("a != b => " + (a != b));
System.out.println("a > b => " + (a > b));
System.out.println("a >= b => " + (a >= b));
System.out.println("a < b => " + (a < b));
System.out.println("a <= b => " + (a <= b));
} //fim do método main
} //fim da classe Relacional
 Exemplo 2.2: Um exemplo simples envolvendo operadores relacionais.

19. 2.4 Operadores (cont.)
 Operadores Lógicos
 São operadores que permitem conectar logicamente o resultado
de diferentes expressões aritméticas ou relacionais construindo
assim uma expressão resultante composta de várias partes.
Operador Significado Exemplo
&& E lógico (and) a && b
|| Ou lógico (or) a || b
! Negação (not) !a
boolean resultado = false;
i = 0;
y = a*x + b;
byte a, b, c;
a = b = c = 0;
//equivalência a=(b= (c=0))
 Operadores de Atribuição
 A atribuição é a operação que permite definir o valor de uma
variável através de uma constante ou através do resultado de uma
expressão envolvendo operações diversas.

20. 2.4 Operadores (cont.)
Operador Condicional : ?
◼ É também conhecido como operador ternário, pois trabalha com 3
operandos. Ele avalia o primeiro operando. Caso a avaliação retorne
true, ele executa o segundo operando. Senão, ele executa o terceiro
operando. O segundo e terceiro operandos DEVEM ser do mesmo tipo
(senão, use cast).
◼ O código do operador ternário abaixo:
◼ int x = 10;
◼ int y = (x > 10) ? x : x+1;
◼ é semelhante ao código abaixo:
int x = 10;
int y;
if ( x > 10 ) {
y = x;
} else {
y = x + 1;
}

21. Novo Recurso no J2SE – printf
◼ O método System.out.printf usado para
imprimir dados.
System.out.printf(“%sn %sn “, “Bem Vindo”,” ao
Programação Java”);
◼ A chamada de método especifica 3
argumentos. Se o método exigir multiplos
argumentos, os argumentos serão separados
por virgula

22. Exemplo usando o printf
public class BemVindo{
public static void main( String args[]){
System.out.printf("%sn%sn","Bem Vindo a
","Programação Java");
}
}

23. Lendo Numeros com Scanner
◼ O uso da class Scanner do pacote java.util
◼ Faça a declaração
◼ import java.util.Scanner;
◼ Declare a objeto para trabalhar com a entrada
de dados
◼ Scanner entrada = new Scanner( System.in );
◼ Daclare as variaveis para armazenar os dados
◼ int numero1, numero2;
◼ Efetue a entrada de dados utilizando o método
adequado ao tipo de variavel p/ receber o
numero:
◼ numero1 = entrada.nextInt();

24. //Soma2Numeros.java
import java.util.Scanner;
public class Soma2Numeros {
public static void main(String args[]) {
Scanner entrada = new Scanner( System.in );
int a,b,soma;
System.out.println("Programa para somar dois numerosnn");
System.out.println("Digite os valores");
System.out.print("a=");
a = entrada.nextInt();
System.out.print("b=");
b = entrada.nextInt();
soma = a + b;
System.out.printf("A soma e %dn",soma);
}
}
 Exemplo 2.4: Um exemplo, usando a classe Console.java, para somar dois
números.

25. 2.5 - Casting e Promoção
◼ Alguns valores são incompatíveis se você tentar fazer uma
atribuição direta. Enquanto um número real costuma ser
representado em uma variável do tipo double, tentar atribuir ele a
uma variável int não funciona pois é um código que diz: “i deve
valer d”, mas não se sabe se d realmente é um número inteiro ou
não.
double d = 3.1415;
int i = d; // não compila
O mesmo ocorre no seguinte trecho:
int i = 3.14;
O mais interessante, é que nem mesmo o seguinte código compila:
double d = 5; // ok, o double pode conter um número inteiro
int i = d; // não compila

26. 2.5 - Casting e Promoção(cont)
◼ Já no caso a seguir é o contrário:
int i = 5;
double d2 = i;
◼ O código acima compila sem problemas, já que um double pode
guardar um número com ou sem ponto flutuante. Todos os inteiros
representados por uma variável do tipo int podem ser guardados
em uma variável double, então não existem problemas no código
acima.
◼ Ás vezes, precisamos que um número quebrado seja arredondado
e armazenado num número inteiro. Para fazer isso sem que haja o
erro de compilação, é preciso ordenar que o número quebrado seja
moldado (casted) como um número inteiro. Esse processo recebe
o nome de casting.

27. 2.5 - Casting e Promoção(cont)
double d3 = 3.14;
int i = (int) d3;
◼ O casting foi feito para moldar a variável d3 como um int. O valor dela agora
é 3.
◼ O mesmo ocorre entre valores int e long.
long x = 10000;
int i = x; // nao compila, pois pode estar perdendo informação
◼ E, se quisermos realmente fazer isso, fazemos o casting:
long x = 10000;
int i = (int) x;

28. 2.5.1 - Casos não tão comuns de casting e
atribuição
◼ Alguns castings aparecem também:
float x = 0.0;
◼ O código acima não compila pois todos os literais com ponto flutuante são
considerados double pelo Java. E float não pode receber um double sem perda
de informação, para fazer isso funcionar podemos escrever o seguinte:
float x = 0.0f;
◼ A letra f indica que aquele literal deve ser tratado como float. Outro caso, que é
mais comum:
double d = 5;
float f = 3;
float x = (float) d + f;
◼ Você precisa do casting porque o Java faz as contas e vai armazenando sempre
no maior tipo que apareceu durante as operações, no caso o double. E no
mínimo, o Java armazena em um int.
◼ Até casting com variáveis do tipo char podem ocorrer. O único tipo primitivo
que não pode ser atribuído a nenhum outro tipo é o boolean.

29. 2.5.2 - Castings possíveis
◼ Abaixo estão relacionados todos os casts possíveis na linguagem Java,
mostrando quando você quer converter de um valor para outro. A indicação
Impl. quer dizer que aquele cast é implícito e automático, ou seja, você não
precisa indicar o cast explicitamente. (lembrando que o tipo boolean não pode
ser convertido para nenhum outro tipo)

30. 2.6 Funções Matemáticas
 Funções matemáticas que podem ser utilizadas para simplificar
cálculos e expressões:
Função Significado
Math.abs(valor) Retorna o valor absoluto de um número
Math.sqrt(valor) Retorna o valor da raiz quadrada de um número
Math.cos(valor) Retorna o co-seno de um ângulo.
Math.sin(valor) Retorna o seno de um ângulo.
Math.tan(valor) Retorna a tangente de um ângulo.
Math.acos(valor) Retorna o arco seno de um numero.
Math.atan(valor) Retorna o arco tangente de um numero.
Math.round(valor) Arredonda o valor de um núm. para seu inteiro mais
próximo.
Math.floor(valor) Arredonda o valor de um número para baixo.
Math.ceil(valor) Arredonda o valor de um número para cima.
Math.log(valor) Retorna o logaritmo natural de um número.
Math.pow(base, potência) Potenciação.
Math.PI Constante numérica que retorna o valor de PI.
Math.E Constante numérica que se refere ao valor da base
para logaritmos naturais.
Math.min(valor1, ...,valorN)
Math.max(valor1, ...,valorN)
Retorna o menor e o maior valor , respectivamente, de
um conjunto numérico.

31. 2.7 Estruturas de Controle
 As estruturas de controle são divididas em:
 Estruturas Sequenciais
 Estruturas de Decisão
 Estruturas de Repetição
Fluxo Seqüencial
de Execução
Desvio do Fluxo
de Execução
Fluxo Repetitivo
de Execução

32. 2.7 Estruturas de Controle
 Simbologia Básica
Terminal
Seta de Fluxo de Dados
Processamento
Display
Decisão
Conector
Conector
Teclado

33. 2.7.1 Estrutura de Controle Sequencial
“Programa para calcular
a Força (2ª Lei de Newton)”
“Informe a:”
“massa:”
“aceleração:”
inicio
massa, a
forca = massa*a
fim
forca
import java.util.Scanner;
public classe forcaLeiNewton {
public static void main (String args[]) {
//Declaração das variáveis
double massa, a, forca;
Scanner entrada = new Scanner( System.in );
System.out.println("Programa para calcular a
Força - 2ª Lei de Newton");
System.out.println(“Informe a:");
System.out.print(“massa: ");
massa = entrada.nextDouble();
System.out.print(“a: ");
a = entrada.nextDouble();
forca = massa*a;
System.out.println(“A forca é: ” + forca);
} //fim do método principal
}//fim da classe
Exemplo 2.4
Diagrama de blocos Programa em Java

34.  Exercícios
Faça programas em Java para resolver problemas que envolvam:
1. O Movimento Uniforme (MU): S = So + v*t.
2. O Movimento Uniformemente Variado (MUV):
Equação Horária da Velocidade: v = vo + a*t.
Equação horária do espaço: S = So + vo*t + (a*t2)/2.
Equação de Torricelli: v2 = vo
2 + 2*a*(S – So).
3. Progressão Aritmética:
Termo geral: an = a1 + (n – 1)*r, para n N*
Soma dos n termos: Sn = ((a1 + an)*n)/2
4. Progressão Geométrica:
Termo geral: an = a1*qn - 1, para n N* e n2.
5. Calcular a área de um: quadrado, retângulo, triângulo ou círculo.
2.7.1 Estrutura de Controle Sequencial

35. 2.7.2 Estruturas de Decisão
public class <nomeClasse> {
public <nomeMétodo> {
//Declaração das variáveis
tipo v1, v2, ..., vN;
tipo resultado;
resultado = 0;
leia(v1, v2, ..., vN);
se (condição)
resultado = v1 + v2 + ... +vN;
escreva(resultado);
}
}
Diagrama de blocos
Portugol para C++/Java
inicio
fim
v1, v2, ..., vN
resultado
condição
resultado = v1 + v2 + ... + vN
V
F
resultado = 0
 Estrutura de Decisão Simples

36. 2.7.2 Estruturas de Decisão
public class <nomeClasse> {
public <nomeMétodo> {
//Declaração das variáveis
tipo v1, v2, ..., vN;
tipo resultado1, resultado2;
resultado1 = 0;
resultado2 = 0;
leia(v1, v2, ..., vN);
se (condição){
resultado1 = v1 + v2 + ... + vN;
resultado2 = 1*v1 + 2*v2 +...+N*vN;
}
escreva(resultado1);
escreva(resultado2);
}
}
Diagrama de blocos
Portugol para C++/Java
inicio
fim
v1, v2, ..., vN
resultado1
resultado2
condição
resultado1 = v1 + v2 + ... + vN
resultado2 = 1*v1 + 2*v2 +...+ N*vN
V
F
resultado1 = 0
resultado2 = 0

37. 2.7.2 Estruturas de Decisão
inicio
fim
senha
mensagem
senha==“123”
mensagem = “Acesso
Autorizado!”
V
F
“Programa para Autorizar
o acesso a um cofre.”
“Digite a senha:”
mensagem = “Acesso Negado!”
Exemplo 2.5
public class SenhaCofreDecSimples {
public static void main (String args[]) {
//Declaração das variáveis
String mensagem;
int senha;
mensagem = "Acesso Negado!";
System.out.println("Programa para Autorizar
o acesso a um cofre");
System.out.print("Digite a senha:");
senha = entrada.nextInt();
if (senha==123)
mensagem = "Acesso Autorizado";
System.out.println(mensagem);
} //fim do método principal
}//fim da classe
Programa em Java

38. 2.7.2 Estruturas de Decisão
public class <nomeClasse> {
public <nomeMétodo> {
//Declaração das variáveis
tipo v1, v2, ..., vN;
tipo resultado;
leia(v1, v2, ..., vN);
se(condição)
resultado = v1 + v2 + ... +vN;
senão
resultado = 1*v1 + 2*v2 +...+ N*vN;
escreva(resultado);
}
}
Diagrama de blocos
Portugol para C++/Java
 Estrutura de Decisão Composta
inicio
fim
v1, v2, ..., vN
resultado
condição
resultado = v1 + v2 +
... + vN
V
F
resultado = 1*v1 + 2*v2 +
...+ N*vN

39. 2.7.2 Estruturas de Decisão
Diagrama de blocos
Exemplo 2.6
inicio
fim
senha
mensagem
senha=123
mensagem = “Acesso
Autorizado!”
V
F
Programa para Autorizar
o acesso a um cofre.
Digite a senha:
mensagem = “Acesso
Negado!”
import java.util.Scanner;
public class SenhaCofreDecComp {
public static void main (String args[ ]) {
//Declaração das variáveis
String mensagem;
int senha;
Scanner entrada = new Scanner(System.in);
System.out.println("Programa para Autorizar
o acesso a um cofre");
System.out.print("Digite a senha:");
senha = entrada.nextInt();
if (senha.==123)
mensagem = "Acesso Autorizado";
else
mensagem = "Acesso Negado";
System.out.println(mensagem);
} //fim do método principal
}//fim da classe
Programa em Java

40. 2.7.2 Estruturas de Decisão
se(condição1){
Instruções quando a condição1 for V;
}
senão{
se(condição2){
Instruções quando a condição1 for F;
E a condição2 for V;
}
senão{
Instruções quando a condição1 e
a condição2 forem F;
}
}
Diagrama de blocos
Portugol para C++/Java
 Estrutura de Decisão Encadeada
condição1
Instruções quando a
condição1 for verdadeira
V
F
condição2
Instruções quando a
condição1 for falsa e a
condição2 for verdadeira
V
F
Instruções quando a
condição1 e a condição2
forem falsas

41. 2.7.2 Estruturas de Decisão
import java.util.Scanner;
public class SistemaCondEnc {
public static void main (String args[]) {
Scanner entrada = new Scanner(System.in);
//Declaração das variáveis
double x, fx;
System.out.println("Programa: Sistema com 3 equacoes");
System.out.print("Informe o valor de x: ");
x = entrada.nextDouble();
//Estrutura de Decisao Encadeada
if(x>=3)
fx=Math.pow(x,2)+x-5;
else
if(x>=-1)
fx=x+1;
else
fx=1;
System.out.printf("F(x) = %.2fn", fx);
} //fim do método principla
}//fim da classe
 Estrutura de Decisão Encadeada
Exemplo 2.7: y = x2 + x- 5, se x  3; y = x + 1, se –1  x < 3; e y = 1, se x < -1.

42. 2.7.2 Estruturas de Decisão
 Seleção de Múltipla Escolha
escolha(opcao){
caso v1: instrução1;
caso v2: instrução2;
o o o
caso vN: instrução1;
}
/* Programa: as 4 operações matemáticas */
import java.util.Scanner;
public class CalcSelMulEscolha {
public static void main(String args[]) {
Scanner entrada = new Scanner(System.in);
double a, b, result=0;
int op; //operacao
System.out.println("Calculadora");
System.out.println("1 - Soma");
System.out.println("2 - Subtração");
System.out.println("3 - Multiplicação");
System.out.println("4 - Divisão");

43. System.out.print("Escolha uma opção: ");
op = entrada.nextInt();
System.out.print(" 1o. valor: ");
a = entrada.nextDouble();
System.out.print(" 2o. valor: ");
b = entrada.nextDouble();
System.out.print("Resultado: ");
switch(op){
case 1: result = a + b;
break;
case 2: result = a - b;
break;
case 3: result = a*b;
break;
case 4: result = a/b;
break;
default: System.out.print("Escolha de opção inválida");
} //fim do switch
System.out.printf("%6.2fn",result);
} //fim do método principal
} //

44. Exercícios
 Faça programas em Java para resolver problemas que envolvam:
1) Controle de entrada de um funcionário a um sistema, apenas quando ele digitar o login e a senha
corretamente. Sabe-se que inicialmente a autorização é negada.
2) Leia um valor de x e forneça o resultado de f(x). Sabendo que f(x) = x2 + 2x, se x  1, e f(x) = -3x +
1, se x < 1.
3) Calcular a média de uma disciplina, informando se o aluno estar reprovado ou aprovado. ( Media =
(Prova1 + Prova2 + 3*Projeto)/5, Aprovado  7,0).
4) Calcule o termo geral de uma PA ou PG.
PA: an = a1 + (n – 1)*r, para n N*
PG: an = a1*qn - 1, para n N* e n2.
6) Calcule o Imposto de Renda a ser descontado no salário de um trabalhador. As faixas salariais em
função dos descontos são mostradas na tabela abaixo.
7) Dados três valores para os lados (A, B e C) de um triângulo verificar e informar se estes valores
formam um triângulo (A<B+C e B<A+C e C<B+A) ou não. Em caso verdadeiro, informe se é um
triângulo eqüilátero (A=B e B=C), isósceles (A=B ou B=C ou A=C) ou escaleno (todos os lados
diferentes).
Faixa Salarial(R$) Desconto
Até 1.050,00 Isento
> 1.050,00 e  2.500,00 15%
> 2.500,00 e  7.500,00 25%
> 7.500,00 35%

45. 2.7.3 Estruturas de Repetição
 Classificação-se em Repetição com:
 Teste no início;
 Teste no final;
 Variável de controle.

46. 2.7.3 Estruturas de Repetição
 Repetição com teste no início
condição
Instruções executadas
enquanto a condição
for verdadeira
V
F
public class <nomeClasse> {
public <nomeMétodo> {
o o o
enquanto (condição) {
Instruções a serem executadas;
enquanto a condição for verdadeira;
}
o o o
}
}
Diagrama de blocos
Portugol para C++/Java

47. 2.7.3 Estruturas de Repetição
 Repetição com teste no início
/* Programa para escrever uma PA */
import java.util.Scanner;
public class PotenciaWhile {
public static void main(String args[]) {
int base, exp, pot;
Scanner entrada = new
Scanner(System.in);
System.out.println("Programa: Potência
de um numero(com While)");
System.out.print(“Base: ");
base = entrada.nextInt();
System.out.print(“Expoente: ");
exp = entrada.nextInt();
pot = 1;
while(exp>0){
pot = pot*base;
exp--; //exp = exp –1;
}
System.out.print(“Potencia: “+pot);
}
}
Diagrama de blocos
exp > 0
pot = pot*base
exp = exp -1
V
F
fim
pot
inicio
base, exp
pot = 1
Programa em Java
Exemplo

48. 2.7.3 Estruturas de Repetição
/* Programa para escrever uma PA */
public class EscrevePA_While {
public static void main(String args[]) {
Scanner entrada = new Scanner(System.in);
int a1, an, //primeiro e último termo
r, //razao n; //numero de termos
System.out.println("Programa:escrever uma PA (teste no inicio)");
System.out.println("Digite os valores");
System.out.print("Primeiro termo: ");
a1 = entrada.nextInt();
System.out.print("Razao: ");
r = entrada.nextInt();
System.out.print("Numero de termos: ");
n = entrada.nextInt();
System.out.print("PA: ");
while(n>0){
an = a1 + (n-1)*r;
System.out.print(" " +an);
n--;
}
} //fim do método principal
} //fim da classe
 Repetição com teste no início

49. 2.7.3 Estruturas de Repetição
 Repetição com teste no final
/* Programa: Potência de um numero*/
public class PotenciaWhile {
public static void main(String args[]) {
int base, exp, pot;
Scanner entrada = new Scanner(System.in);
System.out.println("Programa: Potência
de um numero(com Do While)");
System.out.print(“Base: ");
base = entrada.nextInt();
System.out.print(“Expoente: ");
exp = entrada.nextInt();
pot = 1;
do{
pot = pot*base;
exp--; //exp = exp - 1;
}while(exp>0);
System.out.print(“Potencia: “+pot);
}
}
Diagrama de blocos
exp > 0
pot = pot*base
exp = exp -1
V
F
fim
pot
inicio
base, exp
pot = 1
Programa em Java
Exemplo

50. 2.7.3 Estruturas de Repetição
import java.util.Scanner;
public class ForcaLeiNewtonDoWhile {
public static void main (String args[]) {
double massa, a, forca;
char resp; //resposta do usuário
Scanner entrada = new Scanner(System.in);
do{
System.out.println("Programa: Lei de Newton");
System.out.print("massa: ");
massa = entrada.nextDouble();
System.out.print("aceleracao: ");
a = entrada.nextDouble();
forca = massa*a;
System.out.printf("Forca: %6.2f“, forca);
System.out.print("nDeseja continuar calculando? [1]Sim
[Outro Valor]Nao.......: ");
resp = entrada.nextInt();
}while(resp==1);
} //fim do método principal
}//fim da classe
 Repetição com teste no final

51. 2.7.3 Estruturas de Repetição
 Repetição com variável de controle
Diagrama de blocos
pot = pot*base
fim
pot
inicio
base, exp
cont=1; cont<=exp;cont++
import java.util.Scanner;
public class PotenciaFor {
public static void main(String args[]) {
int base, exp, pot, cont;
Scanner entrada = new Scanner(System.in);
System.out.println("Programa: Potência
de um numero(com While)");
System.out.print("Base: ");
base = entrada.nextInt();
System.out.print("Expoente: ");
exp = entrada.nextInt();
pot=1;
for(cont=1; cont<=exp;cont++){
pot = pot*base;
}
System.out.print("Potencia: "+pot);
}
}
Programa em Java

52. 2.7.3 Estruturas de Repetição
import java.util.Scanner;
public class EscrevePaForDo {
public static void main(String args[]) {
int a1, an,r, cont, n;
Scanner entrada = new Scanner(System.in);
char resp; //resposta do usuario
System.out.println("Programa para escrever uma PA (com For");
do{
System.out.print("Primeiro termo: "); a1 = entrada.nextInt();
System.out.print("Razao: "); r = entrada.nextInt();
System.out.print("Numero de termos: "); n = entrada.nextInt();
System.out.print("PA: ");
an=0;
for(cont=1;cont<=n;cont++){
an = a1 + (cont-1)*r;
System.out.print(" " +an);
}
System.out.print(“nDeseja continuar calculando? [1]Sim
[Outro valor]Nao.....:");
resp = entrada.nextInt();
}while(resp==1);
} //fim do metodo
} //fim da classe
 Repetição com variável de controle

53. 2.7.4 - Uso do break e continue
◼ break/continue
◼ Altera o fluxo do controle do laço
◼ break
◼ Causa a imediata saída de uma estrutura
de controle
◼ Pode ser usado nas instruções while, for,
do/while ou switch
◼ continue
◼ Pula as instruções restantes no corpo do
laço
◼ Prossegue com a próxima iteração do laço
◼ Pode ser usado nas instruções while, for or
do/while

54. 1 // BreakTest.java
2 // Usando a instrução break em uma estrutura for
5 import javax.swing.JOptionPane;
6
7 public class BreakTest {
8
9 // método main começa a execução da aplicação Java
10 public static void main( String args[] )
11 {
12 String saidaDados = "";
13 int conta;
14
15 // loop 10 vezes
16 for ( conta = 1; conta <= 10; conta++ ) {
17
18 // se conta é 5, termina o loop
19 if ( conta == 5 )
20 break; // para o loop somente se conta == 5
21
22 saidaDados += conta + " ";
24 } //fim da estrutura for
25
26 saidaDados += "n Parou o laço com conta = " + conta;
27 System.out.println(saidaDados);
28
29
31 }
32
33 }

55. 1 // ContinueTest.java
2 // Usando a instrução break em uma estrutura for
3
4 public class ContinueTest {
8
9 // método main começa a execução da aplicação Java
10 public static void main( String args[] )
11 {
12 String saidaDados = "";
13 int conta;
14
15 // loop 10 vezes
16 for ( conta = 1; conta <= 10; conta++ ) {
17
18 // se conta é 5 salta o loop e faz a intereção
19 if ( conta == 5 )
20 continue; // para o loop somente se conta == 5
21
22 saidaDados += conta + " ";
23
24 } //fim da estrutura for
25
26 saidaDados += "n pulou o numero 5 em função do continue " + conta;
27 System.out.println(saidaDados);
28
29
30
31 }
32
33 }

56. 2.7.5 Estruturas de Repetição
 Exercícios: Desenvolva um programa para:
1) Calcular N! (fatorial de N), sendo que o valor inteiro de
N deve ser fornecido pelo usuário.
2) Gerar a série de Fibonacci que é formada pela seguinte
sequência: 1, 1, 2, 3, 5, 8, 13, 21, ... A quantidade de
número da série o usuário informará.
3) Gerar a série 1 + 1/2 + 1/3 + 1/4 + ... + 1/N, onde N é um
número fornecido pelo usuário.
4) Informar os N primeiros termos de uma PG. O primeiro
termo, a razão e número de termos será fornecido pelo
usuário.
5) Calcular a área de figuras bidimensionais: quadrado,
retângulo, triângulo e círculo.
Obs.: Os programas devem oferecer aos usuários a oportunidade de
continuar realizando os cálculos.