Java sintaxe

1
Frederico Costa Guedes Pereira © 2000
Java: Sintaxe
Estrutura de uma aplicação
Tipos, variáveis, operadores e comandos
Métodos e classes
Arranjos, Strings e outras classes
slides:jfsintaxe
Fred (C) 2003 Java: Sintaxe 2
uEm Java:
ðDesenvolver uma aplicação consiste em escrever
classes de objetos
ðAs classes podem representar objetos reais do domínio
da aplicação ou estruturas abstratas
ðUma aplicação em execução consiste num conjunto de
objetos, criados a partir das classes, trocando
mensagens entre si
ðSaber como fatorar a solução do problema em classes
requer experiência e prática
uUma classe em Java é uma coleção identificada de
variáveis (estado) e métodos (comportamento)
que operam sobre essas variáveis.
ðUnidade fundamental de programação em Java!
uUma aplicação Java pode possuir dezenas,
centenas ou até milhares de classes
uA classe é a menor unidade de código Java à não é
possível escrever um programa Java sem construir
uma classe!
ðO compilador não reconhece fragmentos de código
menores que uma classe
ðA classe também é a unidade básica de execução de Java
uA aplicação inicia a execução a partir de um método
especial chamado main existente numa das classes
(classe de aplicação)
u Estrutura de uma classe Java:
class NomeDaClasse {
declarações de variáveis membro;
declarações de métodos() {
declarações de variáveis locais;
comandos;
}
}
uClasse que define um cliente num sistema de loja:
public class Cliente {
private String nome;
private String endereco;
private char sexo;
public Cliente(String nome,
String endereco) {
this.nome = nome;
this.endereco = endereco;
}
public void mudeNome(String novoNome) {
this.nome = novoNome;
}
Variáveis membro
estado
comportamento
Métodos
Operadores

2
uContinuação da classe Cliente...
public String informeNome(){
return nome;
}
public String imprima() {
String c = "Cliente ";
c += "n - Nome: " + nome;
c += "n - Endereco: " + endereco;
c += "n - Sexo: " + sexo;
System.out.println(c); }
}
Métodos
Variável local a um método
uA classe ClienteCliente é salva no arquivo Cliente.java
uA classe é compilada para produzir o arquivo de
bytecodes chamado Cliente.class
ðC: javac Cliente.java (à Cliente.class)
uEm geral, cada arquivo .java contém a definição de
uma classe pública
uComo podemos usar a classe Cliente (isto é, onde
podemos criar objetos desta classe)?
public class AplicacaoCliente {
public static void main (String[] args){
Cliente a, b;
a = new Cliente("Bart", "Springfield");
b = new Cliente("Cartman", "South Park");
System.out.println("Nome do cliente a ="+
a.informeNome());
b.imprima();
}
}
uClasse de aplicação: variáveis locais ao métodomain
uA classe AplicacaoClienteAplicacaoCliente é salva no arquivo
AplicacaoCliente.java
uA classe é compilada para produzir o arquivo de
bytecodes chamado AplicacaoCliente.class
ðC: javac AplicacaoCliente.java
uA classe é executada com o interpretador Java:
ðC: java AplicacaoCliente
Nome da classe, sem a extensão .class!
uExemplo de execução em linha de comando:
Y:projetos> javac AplicacaoCliente.java
Y:projetos> java AplicacaoCliente
Nome do cliente a =Bart
Cliente
- Nome: Cartman
- Endereço: South Park
-Sexo: •
Y:projetos> _
uExemplo de execução no BlueJ:
Terminal

3
uClasses de aplicação:
ðSão aquelas por onde a execução do sistema inicia
ðPossuem um método main com a seguinte assinatura:
public static void main(String[] args)
ðO interpretador Java só aceita executar classes que
possuam o método main definido conforme acima
uQualquer classe pode possuir um método main e
ser classe de aplicação (embora não seja usual)
ðEm geral, o main destas classes serve para testes
uElementos da linguagem, em ordem crescente de
complexidade:
ðCaracteres
ðTipos de dados, valores literais, identificadores
ðOperadores e expressões
ðComandos
ðMétodos
ðClasses
ðPacotes
COMPLEXIDADE
Caracteres
uUso do padrão Unicode: conjunto de caracteres de
16 bits
ð65536 caracteres distintos!
uCaracteres Unicode são gravados em arquivos
usando um formato chamado UTF-8
uInserção de caracteres Unicode no código fonte:
uxxxx
ðu3c00 = π
Comentários
uTrês tipos de comentários:
ð// comentário de linha
ð/*
comentário de bloco
*/
ð/**
Classe <b>Cliente</b>
Comentário de bloco para o <i>javadoc</i>
@author Frederico Costa
*/
Identificadores
uIdentificadores nomeiam variáveis (membro, locais,
parâmetros, etc), métodos e classes
uApenas os caracteres especiais "_" e "$" são
permitidos, além de letras e números unicode
uDevem iniciar por uma letra ou pelos símbolos _ ou
$ (evite-os, pois o compilador os utiliza)
ðMAIÚSCULAS ≠ minúsculas
Identificadores (estilo a ser adotado)
uClasses:
ðPrimeira letra de cada palavra maiúscula
Ex: MinhaClasse, Pilha
uMembros de uma classe e variáveis locais:
ðPrimeira letra minúscula
Ex: idade, marcaModelo, getCor(), getSalarioFinal(), i,
cont, somaTotal
uConstantes de classe (static final):
ðTodas as letras maiúsculas
Ex: PI, MAX_ALUNOS, MEDIA

4
Palavras reservadas
abstract
boolean
break
byte
case
catch
char
class
const
continue
default
do
double
else
extends
false
final
finally
float
for
goto
assert
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
Tipos de Dados em Java
uJava possui duas categorias de tipos de dados:
uTipos primitivos: possuem representações
definidas em termos de bytes
ðAs variáveis destes tipos guardam valores dentro da
faixa definida pelo tipo
uTipos referenciáveis: contêm uma referência para
os dados na memória, cujas representações são
definidas pela classe do objeto
ðAs variáveis destes tipos contém um ponteiro p/ objeto
Tipos primitivos
Tipo Default Tamanho Domínio
boolean false 1bit NA
char u0000 16bits u0000 a uFFFF
byte 0 8bits -128 a 127
short 0 16bits -32768 a 32767
int 0 32bits -2147483648a
2147483647
long 0 64bits -9223372036854775808 a
9223372036854775807
float 0.0f 32bits ±1.4E-45 a
±3.4028235E+38
double 0.0 64bits ± 4.9E-324 a
±1.797693134862E+308
Tipos primitivos
uTipo boolean
ðDois valores: true e false
uTipo char
ðValores delimitados por apóstrofos: char c = 'c'
ðUso de literais unicode: char c = u0041
ðCaracteres especiais:
b (backspace) t (tabulação)
n (nova linha) r (return)
' (apóstrofos) " (aspas)
Tipos primitivos
uTipos inteiros (byte, short, int, long)
ðLiterais na base decimal:
• 0, 1, 123, -23456
ðLiterais nas bases hexadecimal e octal:
• 0xcafe //51966 em hexa
• 0377 //255 em octal
ðInteiros(32 bits) x inteiros longos (64bits)
• 1234
• 1234L //long
• 0xF34L //long em hexa
Tipos primitivos
uTipos de ponto flutuante (float e double)
ðLiterais:
• 0.0, 1.0, .01, -3.5
ðNotação científica:
• 1.2345E02 //1.2345 x 102
• 1e-6 //1 x 10-6
ðLiterais ponto-flutuante são sempre double!
• 12.34 //double
• 12.34f //float
• 6.02e23F //float

5
Conversão de tipos
uJava permite conversões entre inteiros (byte,
short, int, long), caractere (char) e pontos
flutuantes (float e double)
uO tipo boolean é o único primitivo que não é
convertido em nenhum outro
uTipos de conversão
ðConversões ampliadoras (widening conversions)
ðConversões redutoras (narrowing conversions)
Conversões ampliadoras
uUm valor de um tipo é convertido para um tipo
maior, isto é, um representado por mais bits
uSão realizadas automaticamente
uExemplos:
int i = 20;
float f = i; //20 convertido para float
int i = ´A´; //65 convertido para int
Math.sqrt(4); //4 convertido para double
Conversões redutoras
uUm valor é convertido para um tipo com menos bits
uNão são realizadas automaticamente
uO programador deve confirmar a redução com um
cast, do contrário o código não é compilado
uExemplos:
int i = 13;
byte b = i; //Erro de compilação!
b = (byte) i; //Ok!
i = (int) 32.601; //i recebe 32
cast
Tipos de referência
uAs variáveis são referências para objetos em
memória
uUma classe define um tipo referenciado
uOs arranjos também são tipos referenciados
Referência
(variável)
Objeto em memória
Tipos referenciados serão
abordados mais adiante
Operadores
uOperadores aritméticos
ðResultam num valor numérico (inteiro ou ponto flutuante)
u Operadores de incremento e decremento
ðResultam num valor numérico (inteiro ou ponto flutuante)
uOperadores relacionais: comparam expressões
ðResultam num valor booleano (true ou false)
uOPeradores lógicos: compõem expressões lógicas
ðProduzem um valor booleano
Operadores
uOperadores de atribuição
ðExecutam uma operação seguida de uma atribuição
u Operador condicional
ðCondiciona seu valor de retorno a uma expressão lógica
uOperador instaceof: verifica se um objeto é
instância de uma classe
ðResulta num valor boolean
uOperador new: instancia uma classe
ðProduz um objeto da classe

6
Operadores aritméticos
uSímbolos:
ðAdição: +
ðSubtração: -
ðMultiplicação: *
ðDivisão: /
ðResto da divisão inteira: %
uExemplos:
c = 7 % 3; //c receberá 1
x = 5 + 10 / 2; //x receberá 10
Operadores incremento/decremento
uSímbolos:
ðIncremento: ++
ðDecremento: --
ðO comportamento deste operador depende da posição
relativa ao operando
uExemplos:
y=1; x=0; z=0;
x = y++; //xßß 1 e yßß2
z = ++x; //zßß 2 e xßß2
c = 10;
c++; //cßß 11
Operadores relacionais
uSímbolos:
ðMaior que, maior ou igual a: >, >=
ðMenor que, menor ou igual a: <, <=
ðIgual a: ==
ðDiferente de: !=
uExemplos:
if ( c == 10 ) ...
return x != null;
Operadores lógicos ou booleanos
uSímbolos:
ðAND: && (curto circuito) ou &
ðOR: || (curto circuito) ou |
ðNOT: !
ðXOR: ^
uExemplos:
(c != 0) && (a > (x/c)) //ok
(c != 0) & (a > (x/c)) //erro se c==0
!(a > b)
Operadores de atribuição
uSímbolos:
ðAritméticos+atribuição: +=, -=, *-, /= e %=
ðEquivalem a uma soma entre o operando da direita e o
operando da esquerda seguida por uma atribuição
ðForma geral: var op= valor ↔ var = var op valor
uExemplos:
c += 5; //c = c + 5
a -= b; //a = a – b
f %= (c+a); //f = f % (c+a)
e += 1; // e++ ou e = e + 1
Operador condicional
uSímbolo:
ðOperador ternário: ?:
ðEquivale a um comando de decisão que resulta num
valor
ðSintaxe: expr_booleana ? expressaoV : expressãoF
uExemplos:
j = (a>b)?a:b;
a = (a != null) ? a : "<vazio>";
v = r>0 ? 10 : 10.5; //erro!
a = (x<y)&&(z<y) ? y : ((x<z) ? z : x);

7
Operador instanceof
uSintaxe:
ð(objeto ou array) instanceof nome_da_classe
ðRetorna true se o objeto for instância da classe
uExemplos:
"string" instanceof String //true
"" instanceof Object //true (H)
null instanceof Object //false
Operador new
uSintaxe:
ðnew construtor_da_classe
ðCria um objeto da classe especificada no construtor
uExemplos:
c = new Cliente("Bart", "Springfield");
linguagem = new String("Java");
venda.adicioneProduto(new Produto());
faixa = new int[] {1,2,3,4,5};
Operadores
u(P)recedência e (A)ssociatividade
E
E
E
E
D
D
E
A
< <= > >= instanceof9
<< >> <<<10
+ - + (concatenação de strings)11
* / %12
new ( tipo )13
+ - !14
. [ ] ( params ) ++ --15
OperadorP
Operadores
p == p p != p r == r r != r (p=primitivo, r=referência)E8
D
D
E
E
E
E
E
A
= *= /= %= += -= <<= >>= >>>= &= ^= |=1
?:2
||3
&&4
| (bitwise) | (lógico)5
^ (bitwise) ^ (lógico)6
& (bitwise) & (lógico)7
OperadorP
uElementos da linguagem, em ordem crescente de
complexidade:
ðCaracteres
ðTipos de dados, valores literais, identificadores
ðOperadores e expressões
ðComandos
ðMétodos
ðClasses
ðPacotes
COMPLEXIDADE
Comandos
uEstruturas de decisão:
ðif-else e switch-case
uEstruturas de repetição:
ðfor, while e do-while
uTratamento de exceções:
ðthrow e try-catch-finally
uDesvio de fluxo:
ðbreak, continue e return

8
Comando simples x bloco de comandos
uUm comando em Java pode ser um comando
simples ou um bloco de comandos
uUm comando simples pode ser: uma expressão,
um dos comandos anteriores ou uma ativação de
método;
uUm bloco de comandos é um conjunto de um ou
mais comandos simples delimitados por "{" e "}" e
separados entre si por ";".
Comando if-else
uSintaxe: if ( expr_booleana )
comando simples ou bloco;
else
uExemplo:
if (a>b)
maior = a;
else
maior = b;
if (n != 0){
c += n;
n = 0;
} else
c++;
Comando switch-case
uSintaxe: switch ( var_inteira ) {
[case val: comando ou bloco; break;]1-n
[default: comando ou bloco; break;]0-1
}
uExemplo:
switch (mes) {
case 1: nome = "Janeiro"; break;
case 2: nome = "Fevereiro"; break;
case 3: nome = "Março"; break;
case 4: nome = "Abril"; break;
default: nome = "Mês inválido"; break;
}
(char | byte | short | int)
Comando for
uSintaxe: for ( inic; teste; inc )
uOnde:
ðinic: inicialização da variável contadora. A variável
também pode ser declarada aqui.
ðteste: expressão booleana que determina a parada ou
continuação do laço
ðinc: incremento da variável contadora
ðInteressante à todas as três cláusulas são opcionais!
Comando for
uExemplos:
int i;
for (i=0 ; i<10 ; i++)
x += 5;
//outra forma
for (int i=0 ; i<10 ; i++)
x += a[i];
//laço infinito
for( ;; ) {
if (x != null) break;
else { ... }
}
i só pode ser usada no
corpo do laço for
Comando for
uExemplos:
//mais de uma variável declaradas
for (int i=0, j=10 ; i<10 ; i++, j--)
soma += i*j;
//não precisa ser uma contagem
for (Node n = cabeca ; n!=null ; n=n.next())
System.out.println(n);
//laço vazio (e possível erro de compilação)
for (int i=0 ; i<10 ; i++);
soma += i;
;

9
Comando while
uSintaxe: while ( expressão )
comando ou bloco;
uOnde:
ðexpressão: expressão que retorne um booleano
• Se o valor fortrue, o corpo do laço é executado
• Se for false, o laço é encerrado
ðPode ser análogo a um for, desde que se acrescente
uma operação de inicialização antes do comando
Comando while
uExemplos:
int c=0;
while (c < 10) {
System.out.println(c);
c++;
}
//equivale a
for (int c=0; c<10 ;c++)
i só pode ser usada no
corpo do laço for
Comando do-while
uSintaxe: do
comando ou bloco;
while (expressão);
uOnde:
ðexpressão: expressão que retorne um booleano
ðO laço do-while é executado pelo menos uma vez
ðSó pára se a expressão for false (cuidado para não
confundi-lo como repeat-until do Pascal)
Comando do-while
uExemplos:
//equivalente ao laço while do exemplo
int c=0;
do {
c++;
} while (c < 10);
Comando throw
uSintaxe: throw exceção;
uObservações:
ðLançar uma exceção que indique um erro ou condição
que impossibilite o prosseguimento da execução
ðO método que possui este comando deve indicar na
sua assinatura que pode lançar tal exceção, isto é feito
com a cláusula throws
ðUma exceção é um objeto cuja classe herda de
Throwable
Comando throw
uExemplo:
/** Método que adiciona um produto à venda
atualmente aberta de um caixa */
public void adicioneProduto(Produto item)
throws VendaNaoAbertaException {
//há venda aberta no caixa?
if (vendaAtual == null)
throw new VendaNaoAbertaException(this);
vendaAtual.insereItem(item);
}

10
Comando try-catch-finally
uSintaxe: try {
[comando;]1-n
} catch (Exceção e1) {
[comando;]1-n
} catch (OutraExceção e2) {
[comando;]1-n
} finally {
[comando;]1-n
}
zero ou mais
um ou zero
uMecanismo de tratamento de exceções de Java
uA cláusula try define o trecho de código protegido
uA cláusula catch (0 ou mais) trata um determinado
tipo de exceção que possa ocorrer no try
ðOs comandos só serão executados se a exceção ocorrer
ðApenas um catch, dentre todos, é executado
uA cláusula finally é opcional e é sempre executada
uO uso de chaves faz parte do comando e não é
opcional
uExemplo:
public static void main(String[] args) {
Caixa c = new Caixa();
Produto p;
try {
p = = new Produto("Celular", 600);
c.adicioneProduto(p);
} catch (VendaNaoAbertaException e) {
//trata erro aqui...
}
}
Comando break
uSintaxe: break;
uObjetivo:
ðFaz a execução saltar para o final de um dos
comandos: while, do-while, for ou switch-
case
ðNo comando switch-case seu uso é necessário
para evitar que a execução de uma cláusula case
continue na seguinte
Comando break
uExemplo:
...
for (int i=0; i<dados.length ;i++) {
if (dados[i] == procurado) {
posicao = i;
break;
}
} //a execução continua daqui
...
Comando continue
uSintaxe: continue;
uObjetivo:
ðInterrompe a iteração atual do laço e inicia a próxima
ðSó pode ser usado dentro de laços while, do-
while e for
• while: volta para o início do laço e testa a condição de
parada para decidir se entra no laço ou não
• do-while: vai para o final do laço, onde a condição de
parada é testada para decidir se entra no laço ou não
• for: volta para o início, executa o incremento e depois o
teste

11
Comando continue
uExemplo:
...
for (int i=0; i<dados.length ;i++) {
if (dados[i] == VAZIO)
continue;
processe(dados[i]);
}
...
Comando return
uSintaxe: return; ou
return expressão;
uObjetivo:
ðPára a execução do método corrente
ðMétodos com tipo de retorno void pedem a primeira
sintaxe do return
ðMétodos que retornam dados pedem a segunda
Comando return
uExemplos:
String informeNome() {
return this.nome;
}
public void insereProduto(Produto item) {
if (item == null)
return;
itens.add(item);
}
Métodos
uColeção de comandos Java encapsulados por um
nome:
ðEm linguagens imperativas: funções, subrotinas e
procedimentos
uMétodos podem possuir zero ou mais parâmetros e
podem conter declarações locais de variáveis
uA invocação de um método é uma expressão Java
ðExceção: métodos com retorno void não são
expressões
Métodos
uAssinatura de um método:
ðNome do método
ðTipo e nome de cada parâmetro
ðTipo do valor retornado
ðLista de exceções
ðModificadores
uSintaticamente:
modif tipo nome (params)[throws exceções]{
corpo_do_método
}
Métodos
uNome do método: mesmas regras dos
identificadores de variáveis
uTipo de retorno: um tipo primitivo, um tipo
referenciável, um array ou void.
uParâmetros são separados por vírgulas e, quando
não existirem, o nome do método vem seguido por
'()'
uA cláusula throws informa as exceções (erros)
que o método pode lançar.

12
Métodos
uExemplos de assinaturas de métodos:
ðpublic static void main(String[] args) {...}
ðpublic final int indexOf(Object e, int s) {...}
ðdouble distanciaDaOrigem() {...}
ðstatic double raiz(double e)
throws IllegalArgumentException {...}
ðprotected abstract String readText(File f)
throws FileNotFoundException,
UnsupportedEncondingException{...}
Pacotes
uColeção de classes e interfaces relacionadas com
um espaço de proteção e de nomes comuns.
ðIdentificar classes com características comuns.
ðFacilidade para encontrar classes desejadas.
ðNomes de classes num pacote não entram em conflito
com nomes de classes de outros pacotes.
ðFacilitar o acesso entre classes no mesmo pacote.
Pacotes
uPacotes em Java possuem nomes compostos
separados por "." (ponto)
ðNomes de pacotes da plataforma começam por java,
javax ou sun
uExemplos de pacotes:
ðjava.lang: pacote com várias classes fundamentais da
linguagem Java, tais como, String, Math, etc.
ðjava.util: pacote com classes utilitárias e estruturas de
dados
Importação de pacotes e classes
uDentro de um pacote pacote1 , uma classe A
pode se referir a uma outra classe B apenas por
seu nome simples
uClasses de outro pacote pacote2 devem
adicionar o nome do pacote pacote1 para
utilizarem as classes A e B
ðExemplo: pacote1.A a = new pacote1.A();
ðExemplo: java.io.File f;
f = new java.io.File("abc.txt");
uA diretiva import dispensa o uso do nome
qualificado de uma classe de outro pacote
uDeve ser colocada depois da diretiva package
uPode ser usada mais de uma vez
uDisponível em duas formas:
ðImportação de uma classe de um pacote
ðImportação de todas as classes de um pacote
O pacote java.lang é sempre importado automaticamente!
uExemplos:
import java.util.ArrayList;
import java.util.Iterator;
import java.io.*; //importa tudo
import java.lang.*; //dispensável
...
}

13
Definição de pacotes
uA diretiva package define o pacote ao qual a
classe pertence
uDeve ser a primeira palavra reservada Java a
aparecer em um arquivo
uSintaxe: package nome_do_pacote;
uPacotes devem ser rotulados com o nome de
domínio invertido, para garantir unicidade global
uExemplo: package br.nti.ufpb.contacad;
uCada arquivo fonte deve estar num diretório que
reflita o nome do pacote
package v3;
...
}
v3
Cliente.java
package v3;
public class Produto {
...
}
v3.Produto
v3Produto.java
Produto.java
uOs bytecodes também exigem a mesma hierarquia:
v3
Compilador Javapackage v3;
public class Cliente
{
...
}
package v3;
public class Produto
{
...
}
Cliente.class
Produto.class
uO diretório base do pacote pode estar em qualquer
ponto do sistema de arquivos.
uExemplo:
package v3;
public class Produto {
...
}
loja
Produto.java
v3
C:
pacote
uSugestão para organização do código:
v3v3
fontes classes
loja
Cliente.class
Produto.class
Cliente.java
Produto.java
C:
uO compilador e o interpretador devem estar
informados onde encontrar os arquivos fontes e de
classes.
uDefinindo um CLASSPATH:
ðConjunto de diretórios que contêm pacotes onde o
compilador e o interpretador devem procurar por
arquivos fontes e bytecodes

14
uApenas diretórios que contêm diretórios base de
pacotes devem ser listados.
uExemplo:
ðc:lojafontes deve estar no classpath
ðc:lojafontesv3 não deve!
uDefinindo um classpath:
ðSET CLASSPATH=c:lojafontes;c:lojaclasses
• Inserido no arquivo AUTOEXEC.BAT
ðDiretiva -classpath do compilador/interpretador
uExemplos:
ðCompilando o código em linha de comando:
ðExecutando uma classe:
C:> javac –classpath c:lojafontes
Cliente.java
C:> _
C:> java –classpath c:lojaclasses
Cliente
C:> _
Estrutura de um código fonte Java
uArquivo: menor unidade compilável de Java
uEstrutura:
ð Uma diretiva package (opcional)
ð Zero ou mais diretivas import
ð Uma ou mais definições de classe
uTodo comando Java deve estar contido dentro dos
métodos das classes
uTodo método deve aparecer dentro de alguma
classe.
uTodo arquivo Java deve conter no máximo uma
classe com acesso public.
uO nome do arquivo deve ser o mesmo de sua
classe public com a extensão .java.
uÉ boa prática de programação declarar apenas
uma classe por arquivo, mesmo quando estas
pertencerem a um mesmo pacote.
CLASSE
MÉTODOARQUIVO PACOTE
COMANDO
uSintaticamente:
[package NomeDoPacote]
{[import * ou Classe]}
public class NomeDaClasse
[extends Superclasse]{
Corpo da classe
}
class OutraClasse
[extends Superclasse]{
Corpo da classe
}

15
uClasses de um mesmo pacote:
package figuras;
class Circulo {
corpo da
classe...
}
package figuras;
class Retangulo {
corpo da
classe...
}
package figuras;
class Poligono {
corpo da
classe...
}
Circulo.java Retangulo.java Poligono.java
Arranjos e Strings
Arranjos
uArranjos são objetos em Java!
uArranjos devem ser declarados e depois
instanciados.
uExemplo:
int[] inteiros; //declaração
inteiros = new int[20]; //instanciação
Ou:
int[] inteiros = new int[20]; //2 em 1
Arranjos
uSintaxe geral:
tipo[ ] referência = new tipo[tamanho]
uO tipo base de um arranjo pode ser primitivo ou de
referência (objetos)
uUma vez criados, não podem mudar de tamanho
uSão indexados a partir do índice 0 (zero)
uPossuem uma propriedade pública length que
contém o tamanho do arranjo
Arranjos
uTipo primitivo:
int[] arrayDeInteiros = new int[10];
int arrayDeInteiros[] = new int[10];
uTipo referência:
String[][] nomes = new String[2][3];
Produto[] vendas = new Produto[3];
Object coisas[] = new Object[10];
uA declaração acima só cria os arranjos, os objetos
devem ser criados depois!
Arranjos
vendas
= null
Cada caixinha é uma
referência para um
objeto Produto a ser
criado!

16
Arranjos
uArranjos literais:
ðNa declaração de uma referência:
int[] inteiros = {1, 2, 3, 4, 5};
ðNa passagem de um valor literal:
String r = abrirDialogo("Deseja sair?",
new String[] {"Sim", "Não"});
uA inicialização é feita em tempo de execução!
Arranjos
uPovoando um arranjo de referências:
Produto[] vendas = new Produto[3];
vendas[0] = new Produto("Celular", 600);
vendas[1] = new Produto("DVD", 700);
vendas[2] = new Produto("Mesa", 100);
System.out.println(vendas.length);
uCada posição do arranjo é uma referência para um
objeto da classe Produto
Arranjos
vendas
"Celular"
600.0
"DVD"
700.0
"Mesa"
100.0
Strings
uStrings também são objetos em Java.
uDevem ser declarados e instanciados.
uExemplos:
String linguagem; //declara...
linguagem = new String(“Java”); //...instancia
linguagem = “Java”; //mais prático!
uConcatenação: “Java ” + “é a melhor”
“2+2=” + 4
“Produto = ” + p //p é um Produto
Strings
uInterface da classe String
ðchar charAt(int pos)
ðint compareTo(String s)
ðint compareToIgnoreCase(String s)
ðboolean endsWith(String s)
ðboolean equals(String s)
ðboolean equalsIgnoreCase(String s)
ðint length()
ðString substring(int ini)
ðString substring(int ini, int fim)
Strings
String s = new String("Java é a melhor");
s.charAt(3); // 'a'
s.compareTo("Java é"); // 9
"Java é".compareTo(s); // –9
s.compareToIgnoreCase("java é a melhor"); // 0
s.equalsIgnoreCase("jAvA É a meLhoR"); // true
s.length(); // 15
"Isto é um string".length(); // 16
s.substring(7); // "a melhor"
s.substring(0,4); // "Java"

17
Strings
ðint indexOf(String s)
ðint indexOf(String s, int ini)
ðint indexOf(int ch)
ðint indexOf(int ch, int ini)
ðint lastIndexOf(String s)
ðint lastIndexOf(String s, int ini)
ðint lastIndexOf(int ch)
ðint lastIndexOf(int ch, int ini)
Strings
s.indexOf("a "); // 3
s.indexOf("a ", 4); // 7
s.indexOf('e'); // 10
s.indexOf('é', 2); // 5
s.lastIndexOf("a "); // 7
s.lastIndexOf("a ", 6); // 3
"Nabucodonosor".lastIndexOf('o'); // 11
"Nabucodonosor".lastIndexOf('o', 7); // 7
Strings
ðString toLowerCase()
ðString toUpperCase()
ðString trim()
ðString replace(char c1, char c2)
ðboolean startsWith(String s)
ðboolean startsWith(String s, int desloc)
ðchar[ ] toCharArray()
ðboolean regionMatches(int d1, String s, int d2, int tam)
Strings
s.toLowerCase(); // "java é a melhor"
s.toUpperCase(); // "JAVA É A MELHOR"
" Joao Pessoa ".trim(); // "Joao Pessoa"
s.replace('a','o'); // "Jovo é o melhor"
s.startsWith("java"); // false
s.startsWith("Java", 2); // false
s.toCharArray(); // {'J'','a','v',..}
s.regionMatches(9,"melhor",0,6); // true
String – Exemplo mais completo
uConstruir uma classe que facilite a manipulação de
nomes de arquivos no Windows/DOS ou Unix
ðA classe deve guardar um nome completo de arquivo e
permitir o acesso a cada uma de suas partes:
• nome
• caminho
• extensão do arquivo
uEsquematicamente:
nomeCompleto
separador
nome() ?
extensão() ?
caminho() ?
nome!

18
public class NomeArquivo {
private String nomeCompleto;
private char separador;
// construtor da classe
public NomeArquivo(String nome, char sep) {
nomeCompleto = nome;
separador = sep;
}
// método para retornar a extensão do arquivo
public String extensao () {
int ponto = nomeCompleto.lastIndexOf(‘.’);
return nomeCompleto.substring(ponto + 1);
}
//Retorna o nome do arquivo
public String nome() {
int ponto = nomeCompleto.lastIndexOf(‘.’);
int sep = nomeCompleto.lastIndexOf(separador);
return nomeCompleto.substring(sep + 1, ponto);
}
// Retorna o caminho (path) do arquivo
public String caminho() {
int sep = nomeCompleto.lastIndexOf(separador);
return nomeCompleto.substring(0, sep);
}
} // fim da classe NomeArquivo
public class AplicacaoNomes {
NomeArquivo arq;
arq = new NomeArquivo("c:tempteste.doc", '');
System.out.println("Extensao: " + arq.extensao());
System.out.println("Caminho:" + arq.caminho());
System.out.println("Nome:" + arq.nome());
}
} // fim da classe AplicacaoNomes
Operações de entrada e saída
Entrada e saída
uEncontram-se na classe System (java.lang)
ðSystem.in e System.out
uin é uma variável de classe do tipo InputStream
ðEla referencia um objeto InputStream que representa
a entrada padrão do sistema
uout é uma variável de classe do tipo PrintStream
ðEla referencia um objeto PrintStream que representa
a saída padrão do sistema
Entrada e saída
in
out
System
um objeto PrintStreamum objeto InputStream

19
Entrada e saída
uLendo da entrada padrão:
ðSystem.in.read()
uEscrevendo na saída padrão:
ðSystem.out.println(...)
uAmbos são métodos enviados para os objetos
referenciados por in e out. As classes
InputStream e PrintStream
implementam estes métodos.
Entrada e saída
System.in ßß read() System.out ßß println("...")
in
out
System
Entrada e saída
uComo Java não foi projetada para produzir
aplicações com interfaces baseadas em texto, a
entrada (principalmente) e saída de dados é
muito pouco prática (para não dizer inexistente!)
uUtilizaremos uma classe não padrão chamada
EasyIn para facilitar a entrada de dados das
primeiras aplicações
Entrada e saída
uInterface da classe EasyIn
ðboolean readBoolean()
ðbyte readByte()
ðshort readShort()
ðint readInt()
ðboolean readLong()
ðfloat readFloat()
ðdouble readDouble()
ðchar readChar()
ðString readString()
Exemplo
uExemplo de uso de EasyIn:
public static void main(String args[]){
NomeArquivo meuArquivo;
EasyIn in = new EasyIn ();
PrintStream out = System .out;
String nome;
char sep;
out.print ("Forneca um nome de arquivo completo:");
nome = in.readString();
out.print ("Forneca o separador utilizado:" );
sep = in. readChar ();
nomeArquivo = new NomeArquivo(nome, sep);
}
Classes da API de Java
ujava.lang.StringBuffer
ðStrings que podem ser alterados dinamicamente
(mais eficientes que String)
uAlguns métodos
ðStringBuffer append(tipo dado)
ðStringBuffer insert(int por, tipo dado)
ðString toString()
ðvoid setCharAt(int pos, char c)

20
ujava.util.Calendar
ðGuarda e manipula datas e horas
uAlguns métodos
ðCalendar getInstance()
ðboolean after(Object data)
ðboolean before(Object data)
ðint add(int campo, int qtde)
ðvoid get(int campo)
ðvoid set(int campo, int valor)
ujava.util.Calendar
ðGuarda e manipula datas e horas
uConstantes (para usar em campo)
ðCalendar.DAY_OF_MONTH
ðCalendar.DAY_OF_WEEK
ðCalendar.HOUR
ðCalendar.MINUTE
ðCalendar.MONTH
ðetc. (veja API da classe Calendar)
Calendar
uExemplo
import java.util.Calendar;
public class UsandoCalendar {
Calendar cal = Calendar.getInstance(); //data atual
cal.add (Calendar.DAY_OF_WEEK, 2);
System.out. println("Dia da semana: " +
cal.get(Calendar .DAY_OF_WEEK));
System.out. println("Dia do mes : " +
cal.get(Calendar .DAY_OF_MONTH));
System.out. println("Hora: " +
cal.get(Calendar .HOUR));
}
}
Classes encapsuladoras
uClasses encapsuladoras
ðByte, Integer, Long, Float, Double e Boolean
ðPacote java.lang
uPrincipais utilidades:
ðEncapsular um valor primitivo na forma de um objeto
ðUtilização de tipos primitivos em escopos exclusivos de
tipos de referência
ðConversões: String ó tipos primitivos
Classes empacotadoras
uUtilização de tipos primitivos em escopos
exclusivos de tipos de referência
Object[] coisas = new Object[3];
coisas[0] = new NomeArquivo("teste.doc", '');
coisas[1] = new String("java");
coisas[2] = 3;
NÃO PODE!!! 3 é um literal do tipo primitivo int
ð Os elementos do arranjo só podem ser objetos da
classe Object ou de quaisquer subclasses desta.
uUtilização de tipos primitivos em escopos
exclusivos de tipos de referência
Object[] coisas = new Object[3];
coisas[0] = new NomeArquivo("teste.doc", '');
coisas[1] = new String("java");
coisas[2] = new Integer(3); //Ok!
3 3
Literal primitivo
ANTES DEPOIS
Objeto de Integer

21
uConversões tipos primitivos à String
De àà Para String
boolean String. valueOf(boolean)
int String. valueOf(int), Integer .toString(int)
long String. valueOf(long), Long.toString(long)
float String. valueOf(float), Float.toString(float)
double String. valueOf(double ),Double.toString (double)
uConversões String à tipos primitivos
De String para:
boolean new Boolean (String s).booleanValue ()
int Integer .parseInt(String s, int base)
long Long.parseLong(String s, int base)
float Float.parseFloat(String s)
double Double.parseDouble(String s)
GERAM
UMA
EXCEÇÃO
uClasse Integer
ðConstantes
• static final int MIN_VALUE, MAX_VALUE
ðPrincipais métodos
• Integer(String s) throws NumberFormatException
• static int parseInt(String s) idem
• static String toBinaryString(int i)
• int intValue()
• long longValue()
• float floatValue()
uClasse Boolean
ðConstantes
• static final Boolean FALSE;
• static final Boolean TRUE;
• Boolean (boolean b)
• Boolean (String s)
• boolean booleanValue()
• static Boolean valueOf(String s)
uClasse Float
ðConstantes
• static final float MIN_VALUE, MAX_VALUE
• static final float NEGATIVE_INFINITY
• Float (String s) throws NumberFormatException
• Float (float f)
• static float parseFloat(String s) throws NumberFormatException
• static Float valueOf(String s) throws NumberFormatException
• float floatValue()
• static String toString(float f)
uClasse Double
ðConstantes
• static final double MIN_VALUE, MAX_VALUE
• static final double NEGATIVE_INFINITY
• Double (String s) throws NumberFormatException
• Double (double f)
• static double parseDouble(String s) throws NumberFormatException
• static Double valueOf(String s) throws NumberFormatException
• double doubleValue()
• static String toString(double f)
uExemplos:
class Conversao {
String numero;
int inteiro;
numero = new EasyIn().readString();
try {
inteiro = Integer.parseInt(numero, 10);
} catch (NumberFormatException nfe) {
inteiro = 0;
}
for(int i=0; i<inteiro; i++) { //processa }
}
}

22
Bibliografia
u Arnold, Ken e Gosling, James. Programando em
Java. Makron Books. 1997.
u Campione, Mary e Walrath, Kathy. The Java Tutorial -
Object Oriented Programming for the Internet. Addyson
Wesley. 1996.
u Deitel, H. M. e Deitel, P. J. Java - How To Program.
Prentice Hall. 1997.
u Flanagan, David. Java in a Nutshell. O’Reilly. 1999.
u Ramon, Fábio. Java – Guia de Consulta Rápida.
Novatec 1999.

Java sintaxe

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (20)

Ähnlich wie Java sintaxe

Ähnlich wie Java sintaxe (20)

Java sintaxe