Вы находитесь на странице: 1из 34

Java Básico

Variáveis, Operadores e
Estruturas de Controle
Prof. Jucimar Souza

Capítulo 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

1
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, Inteiro Curto, Inteiro e Inteiro
Longo
 Ponto Flutuante
 Ponto Flutuante Simples ou Duplo
 Caractere
 Caractere
 Lógico
 Boleano

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 32


+2.147.483.647
long (inteiro longo) -9.223.372.036.854.775.808 a 64
+9.223.372.036.854.775.807

 Por default os valores literais são tratados como inteiros


simples (int).

2
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)

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

3
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++.

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

4
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 const finally interface public throw


assert continue float long return throws
boolean default for native short transient
break do goto new static true
byte double if null strictfp try
case else implements package super void
catch enum import private switch volatile
char extends instanceof protected synchronized while
class false Int this
final

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.

5
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.

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

 Uma ou mais linhas (múltiplas linhas)


/* comentário de
múltiplas linhas */

 De documentação
/** comentário de documentação que
* também pode ter múltiplas linhas
*/

6
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 ao
Classe destinada de armazenamento
retorno, etc, como
de abaixo:
dados relacionados a
* arquivos ou diretórios.
* <p> Pode ser usada para armazenar árvores de diretórios.
* @autor Jucimar Souza
* @veja java.io.File
*/

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.

7
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 );

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 {
static public 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

8
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

2.4 Operadores (cont.)


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

9
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

 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.
boolean resultado = false; byte a, b, c;
i = 0; a = b = c = 0;
y = a*x + b; //equivalência a=(b= (c=0))

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;
}

10
Novo Recurso no J2SE – printf

 O método System.out.printf usado para


imprimir dados.
System.out.printf(“%s\n %s\n “, “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

Exemplo usando o printf


public class BemVindo{

public static void main( String args[]){

System.out.printf("%s\n%s\n","Bem Vindo a
","Programação Java");

}
}

11
Lendo Numeros com no J2SE 5.0

 O uso da class Scanner do pacote java.util


 Faça a declaração
 import java.util.Scanner;
 Declare a variavel 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();

 Exemplo 2.4: Um exemplo, usando a classe Scanner, para somar dois


números.

//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 numeros\n\n");


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 %d\n",soma);
}
}

12
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

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.

13
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;

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.

14
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)

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) Retorna o menor e o maior valor , respectivamente, de
Math.max(valor1, ...,valorN) um conjunto numérico.

15
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 Desvio do Fluxo Fluxo Repetitivo


de Execução de Execução de Execução

2.7 Estruturas de Controle


 Simbologia Básica

Terminal Decisão
Seta de Fluxo de Dados Conector
Processamento Conector
Display Teclado

16
2.7.1 Estrutura de Controle Sequencial

inicio public class <nomeClasse> {


public <nomeMétodo> {

v1, v2, ..., vN //Declaração das variáveis


tipo v1, v2, ..., vN;
resultado = v1 + v2 + ... +vN tipo resultado;

leia(v1, v2, ..., vN);


resultado = v1 + v2 + ... +vN;
resultado
escreva(resultado);
}
fim }

Diagrama de blocos Portugol para C++/Java

2.7.1 Estrutura de Controle Sequencial


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

Diagrama de blocos Programa em Java

17
2.7.1 Estrutura de Controle Sequencial
 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 = vo2 + 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.2 Estruturas de Decisão


 Estrutura de Decisão Simples
inicio
public class <nomeClasse> {
resultado = 0 public <nomeMétodo> {
//Declaração das variáveis
tipo v1, v2, ..., vN;
v1, v2, ..., vN tipo resultado;

F V resultado = 0;
condição leia(v1, v2, ..., vN);

resultado = v1 + v2 + ... + vN se (condição)


resultado = v1 + v2 + ... +vN;

escreva(resultado);
}
}
resultado
Portugol para C++/Java
fim
Diagrama de blocos

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

resultado1
resultado2 Portugol para C++/Java

fim
Diagrama de blocos

2.7.2 Estruturas de Decisão


Exemplo 2.5
inicio public class SenhaCofreDecSimples {
public static void main (String args[]) {
mensagem = “Acesso Negado!”
//Declaração das variáveis
String mensagem, senha;
“Programa para Autorizar mensagem = "Acesso Negado!";
o acesso a um cofre.”
“Digite a senha:” System.out.println("Programa para Autorizar
o acesso a um cofre");
System.out.print("Digite a senha:");
senha senha = entrada.next();
if (senha.equals(“java2"))
F V mensagem = "Acesso Autorizado";
senha==“java2”

System.out.println(mensagem);
mensagem = “Acesso
Autorizado!”
} //fim do método principal
}//fim da classe

mensagem
Programa em Java
fim

19
2.7.2 Estruturas de Decisão
 Estrutura de Decisão Composta
inicio
public class <nomeClasse> {
public <nomeMétodo> {
v1, v2, ..., vN
//Declaração das variáveis
F V tipo v1, v2, ..., vN;
condição tipo resultado;

resultado = 1*v1 + 2*v2 + resultado = v1 + v2 + leia(v1, v2, ..., vN);


...+ N*vN ... + vN
se(condição)
resultado = v1 + v2 + ... +vN;
senão
resultado = 1*v1 + 2*v2 +...+ N*vN;
resultado
escreva(resultado);
}
fim }

Diagrama de blocos
Portugol para C++/Java

2.7.2 Estruturas de Decisão


Exemplo 2.6
inicio import java.util.Scanner;
public class SenhaCofreDecComp {
public static void main (String args[ ]) {
Programa para Autorizar //Declaração das variáveis
o acesso a um cofre. String mensagem, senha;
Digite a senha: Scanner entrada = new Scanner(System.in);
System.out.println("Programa para Autorizar
senha o acesso a um cofre");
System.out.print("Digite a senha:");
senha = entrada.next();
F V if (senha.equals(“java2"))
senha=“java2”
mensagem = "Acesso Autorizado";
mensagem = “Acesso
else
mensagem = “Acesso
Negado!” Autorizado!” mensagem = "Acesso Negado";

System.out.println(mensagem);

} //fim do método principal


mensagem
}//fim da classe

fim
Diagrama de blocos Programa em Java

20
2.7.2 Estruturas de Decisão
 Estrutura de Decisão Encadeada

F V
condição1

F V Instruções quando a
condição2
condição1 for verdadeira

Instruções quando a Instruções quando a


condição1 e a condição2 condição1 for falsa e a se(condição1){
forem falsas condição2 for verdadeira 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{
Diagrama de blocos Instruções quando a condição1 e
a condição2 forem F;
}
}

Portugol para C++/Java

2.7.2 Estruturas de Decisão


 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.
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) = %.2f\n", fx);
} //fim do método principla
}//fim da classe

21
2.7.2 Estruturas de Decisão
escolha(opcao){
caso v1: instrução1;
 Seleção de Múltipla Escolha caso v2: instrução2;
o o o
caso v4: 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");

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.2f\n",result);
} //fim do método principal
} //

22
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.
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%

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+C) 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).

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.

23
2.7.3 Estruturas de Repetição
 Repetição com teste no início

public class <nomeClasse> {


public <nomeMétodo> {
F
condição
o o o
V
enquanto (condição) {
Instruções executadas
Instruções a serem executadas;
enquanto a condição
enquanto a condição for verdadeira;
for verdadeira
}
o o o

}
}
Diagrama de blocos
Portugol para C++/Java

2.7.3 Estruturas de Repetição


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

24
2.7.3 Estruturas de Repetição
 Repetição com teste no início
/* 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 (Looping:
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

2.7.3 Estruturas de Repetição


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

Diagrama de blocos
Programa em Java

25
2.7.3 Estruturas de Repetição
 Repetição com teste no final
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? [S]Sim
[Outro tecla]Nao.......: ");
resp = entrada.next().charAt(0);
}while((resp=='s')||(resp=='S'));
} //fim do método principal
}//fim da classe

2.7.3 Estruturas de Repetição


 Repetição com variável de controle

import java.util.Scanner;
inicio public class PotenciaFor {
public static void main(String args[]) {
int base, exp, pot, cont;
Scanner entrada = new Scanner(System.in);
base, exp
System.out.println("Programa: Potência
de um numero(com While)");
cont=1; cont<=exp;cont++ System.out.print("Base: ");
base = entrada.nextInt();
System.out.print("Expoente: ");
exp = entrada.nextInt();
pot = pot*base pot=1;
for(cont=1; cont<=exp;cont++){
pot = pot*base;
pot }

System.out.print("Potencia: "+pot);
}
fim }

Diagrama de blocos Programa em Java

26
2.7.3 Estruturas de Repetição
 Repetição com variável de controle
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? [S]Sim
[Outro Tecla]Nao.....:");
resp = entrada.next().charAt(0);
}while((resp=='s')||(resp=='S'));
} //fim do metodo
} //fim da classe

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

27
1 // BreakTest.java
2 // Usando a instrução break em uma estrutura for
3
4 // Java packages
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 + " ";
23
24 } //fim da estrutura for
25
26 saidaDados += "\n Parou o laço com conta = " + conta;
27 System.out.println(saidaDados);
28
29 System.exit( 0 ); // termina a aplicação
30
31 }
32
33 }

1 // ContinueTest.java
2 // Usando a instrução break em uma estrutura for
3
4 // Java packages
5 import javax.swing.JOptionPane;
6
7 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 JOptionPane.showMessageDialog( null, saidaDados );
28
29 System.exit( 0 ); // termina a aplicação
30
31 }
32
33 }

28
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.

Como lidar com erros

29
Alguns erros de compilação comuns

Exemplos de erros de compilação

30
Exemplos de Erros de Compilação (2)

Exemplos de Erros de Compilação (3)

31
Erros (II)

Erros de Execução Comuns e suas possíveis causas

32
Exemplos de Erros de Tempo de Execução

Exemplos de Erros de Tempo de Execução

33
Como achar erros de tempo de execução

34