2 Java Sintaxe Basica pdf

Prévia do material em texto

41Java Básico
Sintaxe básica de Java
Sintaxe Básica de Java
42Java Básico
Comentários
// Este é um comentário de uma única linha// Este é um comentário de uma única linha
/* Este comentário pode ocupar várias /* Este comentário pode ocupar várias 
linhas sem problemas */linhas sem problemas */
/** Este é um comentário especial do tipo /** Este é um comentário especial do tipo 
 * “javadoc” que é usado para geração * “javadoc” que é usado para geração 
 * automática de documentação * automática de documentação 
 */ */
// Este é um comentário de uma única linha// Este é um comentário de uma única linha
/* Este comentário pode ocupar várias /* Este comentário pode ocupar várias 
linhas sem problemas */linhas sem problemas */
/** Este é um comentário especial do tipo /** Este é um comentário especial do tipo 
 * “javadoc” que é usado para geração * “javadoc” que é usado para geração 
 * automática de documentação * automática de documentação 
 */ */
/** Este é um comentário especial do tipo /** Este é um comentário especial do tipo 
 * “javadoc” que é usado para geração * “javadoc” que é usado para geração 
 * automática de documentação * automática de documentação 
 */ */
 ----------
 ----------
 ----------
comentários Javacomentários Java
código Javacódigo Java
arquivo Javaarquivo Java
43Java Básico
Identificadores
� Identificam elementos de um programa Java
− métodos, atributos, rótulos, …
� Regras para identificadores
− Devem iniciar por uma letra, um “sublinhado” 
(_) ou o símbolo do dólar ($). Caracteres 
subseqüentes podem ser letras, dígitos, 
sublinhados ou $.
− São “Case sensitive”:
� Maiúsculas são diferenciadas de minúsculas
44Java Básico
Identificadores
� Identificadores válidos
− soma
− temp01
− _numClientes
− $fortuna
− nomeLongoDeVariavel
� Identificadores inválidos
− 102dalmatas
− 123
− #x
45Java Básico
Palavras reservadas
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
Não podem ser usadas como identificador!!!
46Java Básico
Tipos Primitivos
boolean true ou false
char caractere (16 bits Unicode)
byte inteiro (8 bits)
short inteiro (16 bits)
int inteiro (32 bits)
long inteiro (64 bits)
float ponto flutuante (32 bits)
double ponto flutuante (64 bits)
47Java Básico
Hierarquia dos Tipos
Tipos primitivos
Tipo booleano
boolean
Tipos numéricos
Tipos integrais
Tipo caractere Tipos inteiros
Tipos ponto-flutuante
char byte short int long float double
48Java Básico
Declaração de Variáveis
int LIMITE_MAXIMO;
double saldo = 100.5;
int quantidade, idade;
float saldo = 100.5f;
int quantidadeMaxima;
 Padrão para nome de variáveis:
 começam com letras minúsculas;
 em caso de palavras compostas a primeira letra da palavra 
seguinte é maiúscula.
Padrão de codificação. Não é 
restrição da sintaxe de Java
49Java Básico
Operadores
50Java Básico
Tipos de operadores
� Aritméticos
� Concatenação
� Comparação
� Lógicos 
� Atribuição
� Unários 
� Condicional (ternário)
51Java Básico
Operadores aritméticos
 + - * / %
� O operador / é também utilizado para calcular 
divisões inteiras
� O operador % calcula o resto de uma divisão 
inteira 
1/2 => 01/2 => 01/2 => 01/2 => 0
16/5 => 316/5 => 316/5 => 316/5 => 3
16%5 =>116%5 =>116%5 =>116%5 =>1
1%2 => 11%2 => 11%2 => 11%2 => 1
52Java Básico
Operador de concatenação
� + (aplicado a Strings)
String nomeCompleto = nome + sobrenome;String nomeCompleto = nome + sobrenome;String nomeCompleto = nome + sobrenome;String nomeCompleto = nome + sobrenome;
mensagem = “Este é o cliente número ” + x;mensagem = “Este é o cliente número ” + x;mensagem = “Este é o cliente número ” + x;mensagem = “Este é o cliente número ” + x;
System.out.println(“Total: “ + total);System.out.println(“Total: “ + total);System.out.println(“Total: “ + total);System.out.println(“Total: “ + total);
A concatenação também faz uma
 conversão implícita para String
53Java Básico
Operadores de Comparação
� Operadores de comparação
− >
− <
− >=
− <=
− ==
− !=
54Java Básico
Operadores lógicos
� Operadores booleanos
− short-circuit
� && (E lógico)
� || (OU lógico)
55Java Básico
Operadores lógicos
� Operadores booleanos
− bitwise
� & (E lógico ou bit-a-bit)
� | (OU lógico ou bit-a-bit)
� ^ (OU-EXCLUSIVO bit-a-bit)
56Java Básico
Atribuição
� Atribuição
− =
− +=,-=,*=,/=
x = 0;x = 0;x = 0;x = 0;
a = b = c = -1;a = b = c = -1;a = b = c = -1;a = b = c = -1;
x += 1;x += 1;x += 1;x += 1; x = x + 1;x = x + 1;x = x + 1;x = x + 1;
y -= k;y -= k;y -= k;y -= k; y = y - k;y = y - k;y = y - k;y = y - k;
y -= X + 5;y -= X + 5;y -= X + 5;y -= X + 5; y = y – (x + 5);y = y – (x + 5);y = y – (x + 5);y = y – (x + 5);
57Java Básico
Unários
� ++, --
-,!
y = x++ y = x--
y = ++x y = --x
Usar esses operadores
com cuidado!
y = -xy = -x y = !xy = !x
58Java Básico
Condicional
� Conhecido também como operador ternário
− ?:
a = x ? b : c
x é uma expressão booleanax é uma expressão booleanax é uma expressão booleanax é uma expressão booleana
b e c são expressões que b e c são expressões que 
poderão ser atribuídas à poderão ser atribuídas à 
variável avariável a
b e c são expressões que b e c são expressões que 
poderão ser atribuídas à poderão ser atribuídas à 
variável avariável a
59Java Básico
Uso dos Operadores
� Ordem de avaliação dos operadores
� Associatividade
60Java Básico
Ordem de avaliação dos 
operadores
� Ordem de precedência (maior para menor):
 expr++, expr--
 ++expr, --expr, +expr, -expr
 (tipo) expr
 *, /, %
 +, -
 <, > >=,<=
 ==, !=
 &&
 ||
 =, +=, -=, *=, /=
61Java Básico
Associatividade
� Quando os operadores possuem a mesma precedência, 
avalia-se primeiro o operador mais a esquerda
 Exemplo: a + b + c equivale a (a + b) + c
� (exceção) Todos os operadores binários de Java são 
associativos a esquerda, exceto a atribuição
 Exemplo: a = b = c equivale a a = (b = c)
� Precedência e associatividade podem ser redefinidas 
através de parênteses
 Exemplo: a*(b+c), a + (b + c)
62Java Básico
Conversão de Tipos
63Java Básico
Conversões entre tipos, e Casts, 
acontecem freqüentemente quando 
programamos em Java
doubledouble d1 = 10.0d; d1 = 10.0d;
System.out.println("Soma: " + (d1 + 10));System.out.println("Soma: " + (d1 + 10));
......
bytebyte b = ( b = (bytebyte) 32.0d;) 32.0d;
......
doubledouble d1 = 10.0d; d1 = 10.0d;
System.out.println("Soma: " + (d1 + 10));System.out.println("Soma: " + (d1 + 10));
......
bytebyte b = ( b = (bytebyte) 32.0d;) 32.0d;
......
Introdução
64Java Básico
Entre tipos primitivos
 Atribuição
 Passagem de parâmetros
 Promoções aritméticas
Entre objetos
 Atribuição
 Passagem de parâmetros
Conversões ocorrem
65Java Básico
Conversões entre tipos 
primitivos
� Widening conversion
− Conversão para um tipo de maior capacidade
� Narrowing conversion
− Conversão para um tipo de menor capacidade
− Pode haver perda de informação 
� Essas conversões podem ser
− Implícitas
− Explícitas
66Java Básico
É sempre possível quando a 
conversão ocorre de um tipo "menor" 
para um tipo "maior" (wideningconversion)
byte
char
short
int long doublefloat
As setas indicam a direção 
das conversões possíveis
Atribuição e passagem de 
parâmetros
67Java Básico
Acontece quando valores de tipos 
diferentes são operandos de uma 
expressão aritmética
Operadores binários:
 O tipo do operando de menor tamanho 
(bits) é promovido para o tipo do operando 
de maior tamanho
 Os tipos short, char e byte são sempre 
convertidos para o tipo int em operações 
envolvendo apenas esses tipos
Promoção aritmética
68Java Básico
Operadores unários:
 Os tipos short, char e byte são sempre 
convertidos para o tipo int (exceto 
quando usados ++ e --)
 Demais tipos são convertidos de acordo 
com o maior tipo sendo utilizado na 
mesma expressão
short s = 9;short s = 9;
int i = 10;int i = 10;
float f = 11.1f;float f = 11.1f;
double d = 12.2d;double d = 12.2d;
if (-s * i >= f / d) {if (-s * i >= f / d) {
......
}}
......
short s = 9;short s = 9;
int i = 10;int i = 10;
float f = 11.1f;float f = 11.1f;
double d = 12.2d;double d = 12.2d;
if (-s * i >= f / d) {if (-s * i >= f / d) {
......
}}
......
Promoção aritmética
69Java Básico
Exemplo de promoção 
aritmética
byte b = 1;
int i = 1;
float f = 5.2f;
double d = 7.5;
int
float
double
double
double
((b + i) * f) / (d + i)
70Java Básico
intint a = 1234; a = 1234;
longlong b = a; b = a;
shortshort d = 10; d = 10;
intint c = ( c = (intint) b;) b;
shortshort c = ( c = (shortshort) a; ) a; 
O operador “cast”
� Usado para conversões
� Sintaxe
 (<tipo>) <expressão>
conversão implícita
conversão explícita
}}
}}
71Java Básico
Casts podem ser realizados entre quaisquer 
tipos primitivos, exceto boolean
Cast entre tipos primitivos
Casts envolvendo o tipo boolean
não são permitidos! 
Casts envolvendo o tipo boolean
não são permitidos! 
double d = 10.0d;double d = 10.0d;
int i = (int) d;int i = (int) d;
double d = 10.0d;double d = 10.0d;
int i = (int) d;int i = (int) d;
72Java Básico
Estruturas de Controle
73Java Básico
Estruturas de Controle
� if
� if-else
� if-else-if
� switch-case
� while
� do-while
� for
74Java Básico
if
� Declaração condicional mais simples em 
Java
if (expressão booleana){
 comando
}
if (nomeUsuario == null){ 
nomeUsuario = “indefinido”;
}
if (nomeUsuario == null){ 
nomeUsuario = “indefinido”;
}
if (vendas >= meta){ 
 desempenho = “Satisfatório”;
 bonus = 100;
}
if (vendas >= meta){ 
 desempenho = “Satisfatório”;
 bonus = 100;
}
75Java Básico
if-else
if (expressão booleana){
 comando1
}else{
 comando2
}
if (media < 5){
 resultado = “Reprovado”;
}else {
 resultado = “Aprovado”;
}
if (media < 5){
 resultado = “Reprovado”;
}else {
 resultado = “Aprovado”;
}
if (vendas >= meta){ 
 desempenho = “Satisfatório”;
 bonus = 100+ 0.01*(vendas-meta);
}else {
 desempenho = “Não Satisfatório”;
 bonus = 0;
}
if (vendas >= meta){ 
 desempenho = “Satisfatório”;
 bonus = 100+ 0.01*(vendas-meta);
}else {
 desempenho = “Não Satisfatório”;
 bonus = 0;
}
76Java Básico
if-else-if
ifif ( (expressão booleanaexpressão booleana){){
 
 bloco de comandosbloco de comandos
}}elseelse ifif (expressão booleana){ (expressão booleana){
 
 bloco de comandosbloco de comandos
}}else {else {
 
 bloco de comandosbloco de comandos
}}
if (vendas >= 2*meta){ 
 desempenho = “Excelente”;
 bonus = 1000;
} else if (vendas >= 1.5*meta){
 desempenho = “Boa”;
 bonus = 500;
} else if (vendas >= meta){
 desempenho = “Satisfatório”;
 bonus = 100;
} else {
 System.out.println(“Você está em apuros”);
}
if (vendas >= 2*meta){ 
 desempenho = “Excelente”;
 bonus = 1000;
} else if (vendas >= 1.5*meta){
 desempenho = “Boa”;
 bonus = 500;
} else if (vendas >= meta){
 desempenho = “Satisfatório”;
 bonus = 100;
} else {
 System.out.println(“Você está em apuros”);
}
77Java Básico
switchswitch(<(<expressão inteira>expressão inteira>) {) {
casecase 1: 1:
 
 // Bloco de código 1// Bloco de código 1
 
 break;break;
casecase 2: 2:
 
 // Bloco de código 2// Bloco de código 2
 
 breakbreak;;
casecase 3: 3:
 
 // Bloco de código 3// Bloco de código 3
 
 break;break;
defaultdefault::
 
 // Bloco de código // Bloco de código 
}}
Tipo da expressão deve ser
byte, char, short ou int
switch-case
Executado somente
quando todos os outros
cases falham
78Java Básico
switch-case
boolean analisarResposta(boolean analisarResposta(charchar resposta) resposta) 
{{
 
 switchswitch((respostaresposta) {) {
 
 casecase ‘s’: ‘s’:
 
 casecase ‘S’: return true; ‘S’: return true;
 
 casecase ‘n’: ‘n’:
 
 casecase ‘N’: return false; ‘N’: return false;
 
 defaultdefault: : 
 
 System.out.println(System.out.println(
 “ “Resposta inválida!”);Resposta inválida!”);
 
 returnreturn false; false;
 
 }}
}}
return também
pode ser 
usado para sair
do case
79Java Básico
whilewhile (true) (true) 
System.out.println(“Casa Forte”);System.out.println(“Casa Forte”);
whilewhile (true) (true) 
System.out.println(“Casa Forte”);System.out.println(“Casa Forte”);
while
whilewhile ( (expressão booleanaexpressão booleana){){
 
 comandocomando
}}
pode ser executado
 0 vezes!
x = 10;x = 10;
whilewhile ( (x < 10x < 10))
 
 x = x + 1;x = x + 1;
x = 10;x = 10;
whilewhile ( (x < 10x < 10))
 
 x = x + 1;x = x + 1;
loop infinito
int contador = 0;int contador = 0;
whilewhile (contador < 10) { (contador < 10) {
 
 System.out.println(contador);System.out.println(contador);
 
 contador++;contador++;
}}
int contador = 0;int contador = 0;
whilewhile (contador < 10) { (contador < 10) {
 
 System.out.println(contador);System.out.println(contador);
 
 contador++;contador++;
}}
Teste é feito no início
80Java Básico
do-while
do{
 comando
}while(expressão booleana);
int contador = 0;int contador = 0;
dodo { {
 
 System.out.println(contador);System.out.println(contador);
 
 contador++;contador++;
}}
whilewhile (contador < 10); (contador < 10);
int contador = 0;int contador = 0;
dodo { {
 
 System.out.println(contador);System.out.println(contador);
 
 contador++;contador++;
}}
whilewhile (contador < 10); (contador < 10);
Teste é feito no final
comandos são 
executados pelo 
menos uma vez
String resposta;String resposta;
dodo { {
 
 resposta = “Resposta Incorreta!”;resposta = “Resposta Incorreta!”;
}}
whilewhile (ehInvalida(resposta)); (ehInvalida(resposta));
String resposta;String resposta;
dodo { {
 
 resposta = “Resposta Incorreta!”;resposta = “Resposta Incorreta!”;
}}
whilewhile (ehInvalida(resposta)); (ehInvalida(resposta));
81Java Básico
for
forfor ( (inicializaçãoinicialização; ; condiçãocondição; ; 
incrementoincremento){){
 
 comandocomando
}}forfor ( (int contador = 0int contador = 0; ; contador < 10contador < 10; ; contador++contador++){){
 
 System.out.println(contador);System.out.println(contador);
}}
forfor ( (int contador = 0int contador = 0; ; contador < 10contador < 10; ; contador++contador++){){
 
 System.out.println(contador);System.out.println(contador);
}}
void void tabuada() {tabuada() {
 
 intint x,y; x,y;
 
 forfor (x=1, y=1; x<=10; x++, y++) { (x=1, y=1; x<=10; x++, y++) {
 
 System.out.print(x + “ X ” + y + “ = “);System.out.print(x + “ X ”+ y + “ = “);
 
 System.out.println(x*y);System.out.println(x*y);
 
 }}
}}
void void tabuada() {tabuada() {
 
 intint x,y; x,y;
 
 forfor (x=1, y=1; x<=10; x++, y++) { (x=1, y=1; x<=10; x++, y++) {
 
 System.out.print(x + “ X ” + y + “ = “);System.out.print(x + “ X ” + y + “ = “);
 
 System.out.println(x*y);System.out.println(x*y);
 
 }}
}}
82Java Básico
break
� Usado para terminar a execução de um bloco for, while, do ou 
switch 
intint procurar(String nome) { procurar(String nome) {
 
 intint indice = -1; indice = -1;
 
 forfor ( (intint i = 0; i < 50; i++) { i = 0; i < 50; i++) {
 
 ifif (i < MAXIMO ) { (i < MAXIMO ) {
 
 indice = i;indice = i;
 
 breakbreak;;
 
 }}
 
 }}
 
 returnreturn indice; indice;
}}
intint procurar(String nome) { procurar(String nome) {
 
 intint indice = -1; indice = -1;
 
 forfor ( (intint i = 0; i < 50; i++) { i = 0; i < 50; i++) {
 
 ifif (i < MAXIMO ) { (i < MAXIMO ) {
 
 indice = i;indice = i;
 
 breakbreak;;
 
 }}
 
 }}
 
 returnreturn indice; indice;
}}
83Java Básico
continue
� Termina a execução da iteração atual do loop e 
volta ao começo do loop.
forfor ( (intint k = 0; k < 10; k++) { k = 0; k < 10; k++) {
 
 ifif (k == 5) { (k == 5) {
 
 continuecontinue;;
 
 }}
 
 System.out.println(“k = ” + k);System.out.println(“k = ” + k);
}}
forfor ( (intint k = 0; k < 10; k++) { k = 0; k < 10; k++) {
 
 ifif (k == 5) { (k == 5) {
 
 continuecontinue;;
 
 }}
 
 System.out.println(“k = ” + k);System.out.println(“k = ” + k);
}}
84Java Básico
return
� Termina a execução de um método e retorna a 
chamada ao invocador
� É obrigatório quando o tipo de retorno do método não 
é void
� O resultado da avaliação de expressão deve poder 
ser atribuído ao tipo de retorno do método
int somar (int x, int y) {
 return x + y;
} 
void atualizarDados() {
 ...
 if (dadosAtualizados) 
 return;
 ...
} 
o tipo de retorno deve ser compatível 
com o tipo de retorno do método
métodos sem retorno
também podem usar return