Sintaxe II

Programação
Na Web
Linguagem Java
Parte II
Sintaxe
António Gonçalves
break com o nome do bloco
Nome
do bloco
Termina
o bloco
JAVA - Aspectos básicos
class
class Matrix
Matrix {{
private
private int[][]
int[][] mat;
mat;
...
...
public
public boolean
boolean search(
search( int
int val
val )) {{
boolean
boolean found
found == false;
false;
find:
find:
for(
for( int
int y=0
y=0 ;; yy << mat.length
mat.length ;; ++y
++y ))
for(
int
x=0
;
x
<
mat[y].length
for( int x=0 ; x < mat[y].length ;; ++x
++x ))
if
if (( mat[x][y]
mat[x][y] ==
== val
val )) {{
found
found == true;
true;
System.out.println("x="+x
System.out.println("x="+x +"
+" y="+y);
y="+y);
break
break find;
find;
}}
return
return found;
found;
}}
}}
http://ltodi.est.ips.pt/leonardo/ci/MaterialApoio.htm
Referências & tempo de vida dos
objectos
•
Button a;
é apenas uma referência para objectos da classe Button, ou
derivadas de Button, que começa com null;
• Um objecto em java é sempre instanciado dinamicamente.
a = new Button(“Ok”);
• Podem existir várias referências para o mesmo objecto
Object o = a;
• O objecto é destruído automaticamente pelo Garbage
Collector quando já não existirem mais referências para ele.
JAVA - Aspectos básicos
http://ltodi.est.ips.pt/leonardo/ci/MaterialApoio.htm
Criar e destruir objectos
public
public void
void xpto()
xpto() {{
Button
a,
b;
Button a, b;
aa == new
new java.awt.Button(“Yes”);
java.awt.Button(“Yes”);
aa == new
new java.awt.Button(“No”);
java.awt.Button(“No”);
//
// referência
referência com
com null
null
//
// 1.
1. Botão
Botão “Yes”
“Yes” criado
criado
//
// 2.
2. “No”
“No” criado
criado
//
// mas
mas oo “Yes”
“Yes” foi
foi destruído
destruído
bb == a;
//
a;
// 3.
3. ‘b’
‘b’ referencia
referencia oo “No”
“No”
aa == new
new java.awt.Button(“Cancel”);
java.awt.Button(“Cancel”); //
// 4.
4. “Cancel”
“Cancel” criado
criado
}}
//
// ‘a’
‘a’ ee ‘b’
‘b’ terminaram
terminaram
//
// “No”
“No” ee “Cancel”
“Cancel” destruídos
destruídos
a
1.
a
Yes
2.
a
Yes
b
b
null
null
No
3.
a
Yes
b
No
4.
Yes
b
No
Cancel
JAVA - Aspectos básicos
http://ltodi.est.ips.pt/leonardo/ci/MaterialApoio.htm
Cópia e comparação
• Os tipos primitivos são sempre manipulados por valor.
• Os objectos são sempre manipulados por referência.
• Os tipos primitivos têm cópia e comparação directas através
dos operadores ´=´ e ´==´.
• Os objectos são copiados e comparados através de
métodos específicos.
Button a = new Button(“Okay”);
Button b = a;
// Copia a referência.
b.setLabel(“Ok”);
// Altera a label dos dois.
if ( a == b )
// comparação de referências.
System.out.println( “Iguais” );
b = a.clone();
// copia o objecto.
b.setLabel(“Cancel”); // Altera apenas o copiado.
if ( a.equals(b) )
// comparação de objectos.
System.out.println( “Iguais” );
JAVA - Aspectos básicos
http://ltodi.est.ips.pt/leonardo/ci/MaterialApoio.htm
Declaração de classes
• A forma geral da declaração de classe é:
<classe> →
[<modificador>] class <name>[extends <superName>]
[implements <interfaceName> {, <interfaceName>} {
{ <atributo> | <método> }*
}
• O modificadores podem ser:
– public Visível fora do package
– abstract
Não pode haver objectos desta classe.
– final
Não permite ser estendida
JAVA - Aspectos básicos
http://ltodi.est.ips.pt/leonardo/ci/MaterialApoio.htm
Declaração de atributos
• A forma mais simples de declarar um atributo é
indicando o seu tipo e nome, mas a forma geral é:
<atributo> →
[<visibilidade>] [static] [final] [transient]
[volatile] <tipo> <nome> [ = <expressão> ] ;
–
–
–
–
–
–
<visibilidade>
= <expressão>
static
final
transient
volatile
indica o controlo de acesso a este atributo
expressão de inicialização
é partilhado por todos os objectos da classe
atributo constante
não faz parte do seu estado
pode ser alterado assincronamente
JAVA - Aspectos básicos
http://ltodi.est.ips.pt/leonardo/ci/MaterialApoio.htm
Declaração de métodos
• A forma mais simples de declarar um método é indicando o
retorno, nome, parâmetros e código, mas o caso geral é:
<método> →
[<visibilidade>] [static] [abstract]
[final] [native] [synchronized]
<tipo-retorno> <nome> ( [parametros] ) [throws
<excepções>] { ; | { <código> } }
–
–
–
–
–
static
abstract
final
native
synchronized
JAVA - Aspectos básicos
só pode aceder a atributos estáticos
não tem código associado (classe abstracta)
não pode ser redefinido nas sub-classes
o código está em C, C++, etc.
com exclusão mútua ao objecto ou classe
http://ltodi.est.ips.pt/leonardo/ci/MaterialApoio.htm
Visibilidade dos membros
• Apesar de já estar definida a visibilidade da classe, os seus
membros (atributos e métodos) definem também a sua
visibilidade.
• Obviamente que, os métodos da própria classe têm sempre
acesso aos seus membros.
Visibilidade
private
Própria
Classe
Classe do
mesmo
Package
Classe
derivada
√
√
√
protected
√
√
√
public
√
√
√
JAVA - Aspectos básicos
Qualquer
classe
√
http://ltodi.est.ips.pt/leonardo/ci/MaterialApoio.htm
Interfaces
public interface Runnable { // abstract implícito
void run();
// public e abstract implícito
}
public interface Colors {
int RED=1, GREEN=2, BLUE=3; // public static final
}
• Uma interface é uma classe apenas com atributos
constantes e métodos abstractos (sem código).
• Uma classe pode implementar zero ou muitas interfaces,
mas deve implementar todos os métodos das interfaces que
implementa, ou então deve ser abstracta.
• Apesar do JAVA não ter herança múltipla como o C++, este
mecanismo permite polimorfismo múltiplo.
JAVA - Aspectos básicos
http://ltodi.est.ips.pt/leonardo/ci/MaterialApoio.htm
Construtores
• Os construtores são invocados na instanciação dos objectos.
• Sintacticamente podem ser encarados como métodos sem
retorno com o nome da própria classe.
class X {
X(…){…} … }
• Podem existir vários construtores numa classe, desde que
tenham número e/ou tipo de parâmetros diferentes.
• No corpo do construtor (como primeira instrução) podemos
chamar um dos construtores da super-classe super(...). Se tal
não acontecer o construtor sem parâmetros é chamado
implicitamente.
JAVA - Aspectos básicos
http://ltodi.est.ips.pt/leonardo/ci/MaterialApoio.htm
finalize() e inicializadores
estáticos
• O método finalize é invocado automaticamente quando o
objecto for destruído pelo colector de lixo.
protected void finalize() throws Throwable {…}
• Podem existir blocos de código que são executados
quando a classe for carregada no sistema. Normalmente
estes blocos inicializam atributos estáticos complexos.
class StaticExample {
static int i;
static int j = 4;
static { i = j + 2; }
...
}
JAVA - Aspectos básicos
http://ltodi.est.ips.pt/leonardo/ci/MaterialApoio.htm
Tempo de vida dos objectos
• Uma variável de uma determinada Classe apenas
é uma referência, inicialmente com null, para
objectos dessa Classe.
• Um objecto é criado (instanciado) quando for
evocado o operador new e chamado o seu
construtor
– O resultado do new tem que ser armazenado numa referência,
ou o objecto nunca poderá ser utilizado
• Um objecto pode ser destruído quando não
existir mais nenhuma referência a ele.
– O Garbage collection só destruirá o objecto quando
for necessária a memória ocupada por ele.
JAVA - Aspectos básicos
http://ltodi.est.ips.pt/leonardo/ci/MaterialApoio.htm
Métodos especiais
• O método finalize é invocado automaticamente quando o
objecto for destruído pelo colector de lixo.
protected void finalize() throws Throwable {…}
• Podem existir blocos de código que são executados
quando a classe for carregada no sistema. Normalmente
estes blocos inicializam atributos estáticos complexos.
class StaticExample {
static int i;
static int j = 4;
static { i = j + 2; }
...
}
JAVA - Aspectos básicos
http://ltodi.est.ips.pt/leonardo/ci/MaterialApoio.htm
Arrays
•
O Array não é um tipo fundamental da linguagem.
int[] a; ou int a[]; é uma referência para um array de
inteiros.
•
Um array é instanciado: a = new int[50];
mas ‘a’ refere um array com qualquer dimensão.
•
Depois de instanciado podemos saber a sua
dimensão consultando o atributo length.
•
Ao indexar aos elementos com a[i], caso se
exceda a dimensão é gerada uma excepção.
•
Um array pode ser instanciado atribuindo valores
para cada um dos elementos: int[] a = { 10, 20, 30 };
•
que é equivalente a: int[] a = new int[3];
a[0] = 10; a[1] = 20; a[2] = 30;
JAVA - Aspectos básicos
int[] a = new int[10];
a[0] = 1;
for( int i=1 ;
i < a.length ;
++ i )
a[i] = a[i-1] + i;
. . .
a = new int[50];
. . .
http://ltodi.est.ips.pt/leonardo/ci/MaterialApoio.htm
Strings
• Uma String não é um array de caracteres. É uma classe
vulgar que internamente usa uma array de caracteres.
• Esta classe tem muitos métodos. Os mais usados são:
int length()
- o número de caracteres.
char charAt(int)
- o carácter na posição indicada.
int compareTo(String)
- comparação lexicográfica.
int [last]indexOf(char)
- o índice da 1a [última] ocorrência.
int [last]indexOf(char,int)- o índice da próxima [anterior].
String valueOf(tipoPrimitivo)- tipo Primitivo para String.
• O conteúdo de um objecto String não pode ser alterado,
para tal existe a classe StringBuffer.
JAVA - Aspectos básicos
http://ltodi.est.ips.pt/leonardo/ci/MaterialApoio.htm
Mais sobre Strings
• A linguagem JAVA tem algumas características
especificas para facilitar o uso de objectos desta classe:
String s = “CCISEL”; é equivalente a:
char[] ccisel = {‘C’,‘C’,‘I’,‘S’,‘E’,‘L’};
String s = new String(ccisel);
• Existe conversão implícita de qualquer classe ou tipo
primitivo para String, para tal é evocado toString() da
classe ou valueOf() para o tipo primitivo.
•
O operador ‘+’ entre duas Strings faz a concatenação.
“PentiumII ”+333 é convertido em “PentiumII ” + “333”
que dará “PentiumII 333”.
JAVA - Aspectos básicos
http://ltodi.est.ips.pt/leonardo/ci/MaterialApoio.htm
Método main()
• Um programa pode conter várias classes
– Cada classe pública dá origem a um ficheiro *.class
– Uma delas terá que ter o método main()
• Tem que ser estático (método da classe) e público
• Retorna void e tem um array de Strings como parâmetro
public class Echo {
public static void main( String[] argv ) {
for( int i=0 ; i < argv.length ; ++i )
System.out.print( argv[i] + ' ' );
System.out.println();
System.exit(0);
}
}
JAVA - Aspectos básicos
C:>java Echo a xpto 2
a xpto 2
C:>_
http://ltodi.est.ips.pt/leonardo/ci/MaterialApoio.htm
classe System
• A classe System faz interface com o sistema
onde o programa está a ser executado.
• Todos os atributos e métodos são estáticos.
• Não se pode instanciar objectos desta classe.
in
out
gc()
runFinalization()
getProperty(String)
exit(int)
- standard input stream (bytes)
- standard output stream (bytes)
- invocar explicitamente o colector de lixo
- invocar finalize dos objectos por destruir
- consultar uma “variável de ambiente”
- termina a execução do programa
JAVA - Aspectos básicos
http://ltodi.est.ips.pt/leonardo/ci/MaterialApoio.htm
Console Input & Output
import java.io.*;
public class DemoIo {
public static void main( String[] args ) throws Exception {
BufferedReader in = new BufferedReader(
new InputStreamReader( System.in ));
String[] lines = new String[ Integer.parseInt(args[0])+1 ];
int i;
for( i= 0 ; i < lines.length ; ++i ) {
lines[i] = in.readLine();
if ( lines[i] != null && lines[i].length() == 0 )
break;
}
for( --i ; i >= 0 ; --i )
System.out.println(lines[i]);
}
}
JAVA - Aspectos básicos
http://ltodi.est.ips.pt/leonardo/ci/MaterialApoio.htm
Classe Object
• Todas as classes derivam directa ou
indirectamente da classe Object, que define a
funcionalidade que qualquer objecto deve ter:
Object clone()
- Cria um novo objecto exactamente igual.
void finalize()
- Invocado na destruição do objecto.
int hashCode()
- Índice deste objecto na tabela de hash.
String toString()
- Transforma o objecto numa String.
Class getClass()
- Devolve a classe do objecto.
boolean equals(Object)- Testa se dois objectos são iguais.
• Esta classe é a raiz da árvore hierarquia de todas
as classes, desta forma podemos escrever
código em JAVA que use qualquer objecto
usando referencias para esta classe.
JAVA - Aspectos básicos
http://ltodi.est.ips.pt/leonardo/ci/MaterialApoio.htm
Excepções
• Em Java, a ocorrência de erros(excepções) durante
a execução de um programa não necessariamente
significa que o programa termina.
• A linguagem possui um mecanismo para indicar
trechos críticos num programa e recuperar
eventuais exceções ocorridas nestes trechos, sem
parar a execução do programa.
JAVA - Aspectos básicos
http://ltodi.est.ips.pt/leonardo/ci/MaterialApoio.htm
Sintaxe para tratamento de
excepções
try{
... // Trecho crítico do programa
}
catch(Excepção e){
... // Tratamento da excepção
}
finally{ // Eliminação de precedência
...
}
JAVA - Aspectos básicos
http://ltodi.est.ips.pt/leonardo/ci/MaterialApoio.htm
Exemplo de trecho crítico
class conta{
public static void main(String args[]){
int den=0;
int num=30;
int res=num/den; // Trecho crítico
}
}
A execução do .class correspondente a esta classe provocaria a
seguinte mensagem de erro:
...> java.lang.ArithmeticException: / by zero
at ... conta ...
JAVA - Aspectos básicos
http://ltodi.est.ips.pt/leonardo/ci/MaterialApoio.htm
Tratamento do trecho crítico
class conta{
public static void main(String args[]){
int den=0;
int num=30;
try{ // Indicador do trecho crítico
int res=num/den;
}
catch(ArithmeticException e) { // Recuperação da excepção
System.out.println(“Dividiu por zero!”);
den=1;
}
... // Continuação do programa
}
}
JAVA - Aspectos básicos
http://ltodi.est.ips.pt/leonardo/ci/MaterialApoio.htm
Trechos críticos com vários
tratamentos de excepções
class conta{
public static void main(String args[]){
int den,num;
int c[]={1};
...
try{ // Indicador do trecho crítico
int res=num/den;
c[999]=res;
}
catch(ArithmeticException e) { // Recuperação da excepção aritmética
System.out.println(“Dividiu por zero!”);
den=1;
}
catch(ArrayIndexOutOfBoundsException e){ // Recuperação da excepção
System.out.println(“Estourou o índice”); //
de índice do vector
}
... // Continuação do programa
}
}
JAVA - Aspectos básicos
http://ltodi.est.ips.pt/leonardo/ci/MaterialApoio.htm
Tratamento com finally
• Todo comando try exige, pelo menos, uma
cláusula catch ou finally.
• Finally é executado antes que o método
retorne do erro, garantindo o tratamento
antes de qualquer catch.
• Assim, finally tem precedência máxima
sobre todos os outros tratamentos.
JAVA - Aspectos básicos
http://ltodi.est.ips.pt/leonardo/ci/MaterialApoio.htm
Exemplo com finally
class conta{
public static void main(String args[]){
int den,num;
int c[]={1};
...
try{ // Indicador do trecho crítico
int res=num/den;
c[999]=res;
}
catch(ArithmeticException e) { // Recuperação da excepção aritmética
System.out.println(“Dividiu por zero!”);
}
catch(ArrayIndexOutOfBoundsException e){ // Recuperação da excepção
System.out.println(“Estourou o índice”); //
de índice do vector
}
finally{
den=1;
}
}
}
JAVA - Aspectos básicos
http://ltodi.est.ips.pt/leonardo/ci/MaterialApoio.htm
Lançamento de excepções
Independente de outras excepções que
possam ocorrer na execução, uma classe
pode forçar o lançamento de excepções ou
relançar uma determinada excepção, para
que possa ser tratada em diferentes níveis.
Isto é feito através da palavra throw.
throw new <construtor da classe de exceção >(parâmetros );
throw <exceção>;
JAVA - Aspectos básicos
http://ltodi.est.ips.pt/leonardo/ci/MaterialApoio.htm
Exemplo com throw
class exemplo{
static void proced_exemplo(){
try{
// Tenta lançar instância de uma excepção aritmética
throw new ArithmeticException(“Divide por zero”);
}
catch(ArithmeticException e){
System.out.println(“Erro no método “+e);
throw e; // Relança a excepção para ser tratada em outro escopo
}
}
public static void main(String args[]){
try{
exemplo.proc_exemplo();
}
catch(ArithmeticException e){
System.out.println(“Retratamento da excepção”);
}
}
}
JAVA - Aspectos básicos
http://ltodi.est.ips.pt/leonardo/ci/MaterialApoio.htm
Métodos que podem devolver
excepções
Pode-se indicar os tipos de excepção que um
método pode devolver utilizando-se a palavra
reservada throws.
método(parâmetros)
throws Excepção1,...,ExcepçãoN{
...
}
Isto força os trechos de programa, que
utilizarem este método, a tratarem as
excepções com catch ou finally.
JAVA - Aspectos básicos
http://ltodi.est.ips.pt/leonardo/ci/MaterialApoio.htm
Exemplo com throws
class erros{
static void contas()
throws ArithmeticException,ArrayIndexOutOfBoundsException{
...
if (den==0){
throw new ArithmeticException(“Denominador inválido”);
}
res=num/den;
if (indice>0){
throw new ArrayIndexOutOfBoundsException(“Indice >0”);
}
c[indice]=res;
}
public static void main(String args[]){
try{
erros.contas();
}
catch(ArithmeticException e){...}
catch(ArrayIndexOutOfBoundsException e){...}
}
}
JAVA - Aspectos básicos
http://ltodi.est.ips.pt/leonardo/ci/MaterialApoio.htm
Criação de classes de excepções
Novas classes de exceções podem ser
construídas extendo-se a classe Exception.
Para isto, basta fazer:
class <NovaClasse>
extends Exception{
atributos
...
construtores
...
public String toString(){
// O que imprimir quando a classe precisar ser impressa
...
}
Outros métodos...
}
JAVA - Aspectos básicos
http://ltodi.est.ips.pt/leonardo/ci/MaterialApoio.htm
Exemplo de criação de nova
classe de excepção
classProprioErro
extends Exception{
private int aux;
ProprioErro(int a){ //Construtor
aux=a;
}
public String toString(){ // Retorna nome da classe e estado interno
return(“ProprioErro[“+aux+”]”);
}
}
JAVA - Aspectos básicos
http://ltodi.est.ips.pt/leonardo/ci/MaterialApoio.htm
Utilização da nova classe
class calculo{
static void calcula(int a)
throws Proprioerro{
if(a>10)
throw new ProprioErro(a); // Lança instância da nova classe
...
}
public static void main(String args[]){
try{
calculo.calcula(1);
// Não gera excepção
calculo.calcula(300);
// Gera excepção
}
catch(ProprioErro e){ // Tratamento da nova excepção
System.out.println(“Capturada “+e);
}
}
}
JAVA - Aspectos básicos
http://ltodi.est.ips.pt/leonardo/ci/MaterialApoio.htm