Java: Sintaxejavafree.uol.com.br/files_user/files/D/2E/14/javaSintaxe.pdf · 3 Fred (C) 2003 Java: Sintaxe 13 Estrutura de uma aplicação uClasses de aplicação: ðSão aquelas

1

Frederico Costa Guedes Pereira © 2000

Java: SintaxeEstrutura de uma aplicação

Tipos, variáveis, operadores e comandosMétodos e classes

Arranjos, Strings e outras classes

slides: jfsintaxe

Fred (C) 2003 Java: Sintaxe 2

Estrutura de uma aplicação

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

estadocomportamento

Mét

odos

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.javauA 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úblicauComo 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étodo main



uA classe AplicacaoClienteAplicacaoCliente é salva no arquivo AplicacaoCliente.javauA 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.javaY:\projetos> java AplicacaoClienteNome do cliente a =BartCliente- 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

CO

MP

LE

XID

AD

E


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-8uInserçã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 classesuApenas os caracteres especiais "_" e "$" são

permitidos, além de letras e números unicodeuDevem 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, PilhauMembros 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 reservadasabstractboolean

breakbytecasecatchcharclass

constcontinuedefault

dodouble

elseextendsfalsefinalfinallyfloat

forgotoassert

ifimplementsimportinstanceofint

interfacelongnativenewnull

packageprivateprotected

publicreturnshortstaticstrictfpsuperswitch

synchronizedthisthrowthrowstransient

truetryvoidvolatilewhile


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ínioboolean false 1bit NAchar \u0000 16bits \u0000 a \uFFFFbyte 0 8bits -128 a 127short 0 16bits -32768 a 32767int 0 32bits -2147483648 a

2147483647long 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 primitivosuTipos 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 outrouTipos 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 bitsuSão realizadas automaticamenteuExemplos:

int i = 20;float f = i; //20 convertido para float

int i = ´A´; //65 convertido para intMath.sqrt(4); //4 convertido para double


Conversões redutoras

uUm valor é convertido para um tipo com menos bitsuNão são realizadas automaticamenteuO programador deve confirmar a redução com um

cast, do contrário o código não é compiladouExemplos:

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óriauUma classe define um tipo referenciadouOs arranjos também são tipos referenciados

Referência(variável)

Objeto em memóriaTipos 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á 1x = 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ßß2z = ++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 + 5a -= b; //a = a – bf %= (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

CO

MP

LE

XID

AD

E


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;

elsecomando simples ou bloco;

uExemplo:if (a>b) maior = a;

elsemaior = b;

if (n != 0){ c += n;n = 0;

} elsec++;


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 )comando simples ou bloco;

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 formafor (int i=0 ; i<10 ; i++)

x += a[i];

//laço infinitofor( ;; ) {

if (x != null) break;else { ... }

}

i só pode ser usada no corpo do laço for


Comando for

uExemplos://mais de uma variável declaradasfor (int i=0, j=10 ; i<10 ; i++, j--)

soma += i*j;

//não precisa ser uma contagemfor (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 for true, 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 afor (int c=0; c<10 ;c++)System.out.println(c);

i só pode ser usada no corpo do laço for


Comando do-while

uSintaxe: docomando 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 exemploint c=0;do {

System.out.println(c);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 JavauA cláusula try define o trecho de código protegidouA 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 executadauO 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 casecontinue 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 ; oureturn 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áveisuA 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

}Fred (C) 2003 Java: Sintaxe 66

Métodos

uNome do método: mesmas regras dos identificadores de variáveisuTipo 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 simplesuClasses 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 pacoteuDeve ser colocada depois da diretiva packageuPode ser usada mais de uma vezuDisponí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 tudoimport java.lang.*; //dispensável

public class Cliente {...

}

13


Definição de pacotes

uA diretiva package define o pacote ao qual a classe pertenceuDeve ser a primeira palavra reservada Java a

aparecer em um arquivouSintaxe: package nome_do_pacote;uPacotes devem ser rotulados com o nome de

domínio invertido, para garantir unicidade globaluExemplo: package br.nti.ufpb.contacad;



uCada arquivo fonte deve estar num diretório que reflita o nome do pacotepackage v3;public class Cliente {

...}

v3

Cliente.java

package v3;public class Produto {

...}

v3.Produtov3\Produto.java

Produto. java



uOs bytecodes também exigem a mesma hierarquia:

v3

Compilador Javapackage v3;public class Cliente {

...}


...}

Cliente.class

Produto.class



uO diretório base do pacote pode estar em qualquer ponto do sistema de arquivos.uExemplo:


...}

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:\loja\fontes deve estar no classpath

ðc:\loja\fontes\v3 não deve!

uDefinindo um classpath:ðSET CLASSPATH=c:\loja\fontes;c:\loja\classes

• 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:\loja\fontesCliente.java C:\> _

C:\> java –classpath c:\loja\classesCliente C:\> _


Estrutura de um código fonte Java

uArquivo: menor unidade compilável de JavauEstrutura:ð 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 classesuTodo 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 daclasse...

}

package figuras;

class Retangulo {

corpo daclasse...

}

package figuras;

class Poligono {

corpo daclasse...

}

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çãointeiros = 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 tamanhouSã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 é umareferência para umobjeto 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); // –9s.compareToIgnoreCase("java é a melhor"); // 0s.equalsIgnoreCase("jAvA É a meLhoR"); // trues.length(); // 15"Isto é um string".length(); // 16s.substring(7); // "a melhor"s.substring(0,4); // "Java"

17


Strings

uInterface da classe Stringð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

String s = new String("Java é a melhor");s.indexOf("a "); // 3s.indexOf("a ", 4); // 7s.indexOf('e'); // 10s.indexOf('é', 2); // 5s.lastIndexOf("a "); // 7s.lastIndexOf("a ", 6); // 3"Nabucodonosor".lastIndexOf('o'); // 11"Nabucodonosor".lastIndexOf('o', 7); // 7


Strings

uInterface da classe Stringð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

String s = new String("Java é a melhor");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"); // falses.startsWith("Java", 2); // falses.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


String – Exemplo mais completo

uEsquematicamente:

nomeCompleto

separador

nome() ?

extensão() ?

caminho() ?nome!

18


String – Exemplo mais completopublic class NomeArquivo {

private String nomeCompleto;private char separador;

// construtor da classepublic NomeArquivo(String nome, char sep) {

nomeCompleto = nome;separador = sep;

}// método para retornar a extensão do arquivopublic String extensao () {

int ponto = nomeCompleto.lastIndexOf(‘.’);return nomeCompleto.substring(ponto + 1);

}


String – Exemplo mais completo//Retorna o nome do arquivopublic String nome() {

int ponto = nomeCompleto.lastIndexOf(‘.’);int sep = nomeCompleto.lastIndexOf(separador);return nomeCompleto.substring(sep + 1, ponto);

}// Retorna o caminho (path) do arquivopublic String caminho() {

int sep = nomeCompleto.lastIndexOf(separador);return nomeCompleto.substring(0, sep);

}} // fim da classe NomeArquivo


String – Exemplo mais completopublic class AplicacaoNomes {

public static void main(String[] args) {

NomeArquivo arq;

arq = new NomeArquivo("c:\\temp\\teste.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

inout

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 PrintStreamimplementam estes métodos.


Entrada e saída

System.in ßß read() System.out ßß println("...")

inout

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

uExemploimport java.util.Calendar;

public class UsandoCalendar {public static void main(String[] args) {

Calendar cal = Calendar.getInstance(); //data atualcal.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ênciaObject[] 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ênciaObject[] coisas = new Object[3];coisas[0] = new NomeArquivo("teste.doc", '\\');coisas[1] = new String("java");coisas[2] = new Integer(3); //Ok!

3 3

Literal primitivoANTES DEPOIS

Objeto de Integer

21



uConversões tipos primitivos à StringDe àà 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 primitivosDe 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)

GERAMUMA

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;

ðPrincipais métodos• 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

ðPrincipais métodos• 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

ðPrincipais métodos• 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 {

public static void main(String[] args) {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


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

Documents

Java: Sintaxejavafree.uol.com.br/files_user/files/D/2E/14/javaSintaxe.pdf · 3 Fred (C) 2003 Java: Sintaxe 13 Estrutura de uma aplicação uClasses de aplicação: ðSão aquelas