Programação Na Web. Linguagem Java Parte II. break com o nome do bloco. Sintaxe. Nome do bloco. Termina o bloco. António Gonçalves ...

(1)

António Gonçalves

Programação

Na Web

Linguagem Java

Parte II

Sintaxe

break com o nome do bloco

Nome do bloco

Termina o bloco

class Matrix {

private int[][] mat; ...

public boolean search( int val ) { boolean found = false;

find:

for( int y=0 ; y < mat.length ; ++y ) for( int x=0 ; x < mat[y].length ; ++x )

if ( mat[x][y] == val ) { found = true; System.out.println("x="+x +" y="+y); break find; } return found; } } class Matrix {

private int[][] mat; ...

public boolean search( int val ) { boolean found = false;

find:

for( int y=0 ; y < mat.length ; ++y ) for( int x=0 ; x < mat[y].length ; ++x )

if ( mat[x][y] == val ) { found = true; System.out.println("x="+x +" y="+y); break find; } return found; } }

(2)

JAVA - Aspectos básicos 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.

Criar e destruir objectos

null a b Yes

1.

null a b Yes

2.

No a b Yes

3.

No a b Yes No

4.

public void xpto() {

Button a, b; // referência com null

a = new java.awt.Button(“Yes”); // 1. Botão “Yes” criado a = new java.awt.Button(“No”); // 2. “No” criado

// mas o “Yes” foi destruído

b = a; // 3. ‘b’ referencia o “No”

a = new java.awt.Button(“Cancel”); // 4. “Cancel” criado

} // ‘a’ e ‘b’ terminaram

// “No” e “Cancel” destruídos

public void xpto() {

Button a, b; // referência com null a = new java.awt.Button(“Yes”); // 1. Botão “Yes” criado a = new java.awt.Button(“No”); // 2. “No” criado

// mas o “Yes” foi destruído b = a; // 3. ‘b’ referencia o “No” a = new java.awt.Button(“Cancel”); // 4. “Cancel” criado

} // ‘a’ e ‘b’ terminaram

(3)

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

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

(4)

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> indica o controlo de acesso a este atributo – = <expressão> expressão de inicialização

– static é partilhado por todos os objectos da classe – final atributo constante

– transient não faz parte do seu estado – volatile pode ser alterado assincronamente

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 só pode aceder a atributos estáticos

– abstract não tem código associado (classe abstracta)

– final não pode ser redefinido nas sub-classes

– native o código está em C, C++, etc.

(5)

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 Própria Classe Classe do mesmo Package

Classe

derivada Qualquer classe

private √

√ √

protected √ √ √

public √ √ √ √

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.

(6)

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.

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

(7)

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.

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

(8)

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;

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]; . . .

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

.

(9)

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

C:>java Echo a xpto 2 a xpto 2

C:>_

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

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

(10)

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 - standard input stream (bytes)

out - standard output stream (bytes)

gc() - invocar explicitamente o colector de lixo

runFinalization() - invocar finalize dos objectos por destruir getProperty(String) - consultar uma “variável de ambiente”

exit(int) - termina a execução do programa

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

(11)

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.

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.

(12)

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

}

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

(13)

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 }

}

Trechos críticos com vários

tratamentos de excepções

class conta{

public static void main(String args[]){ int den,num;

int c[]={1}; ...

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 }

(14)

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.

Exemplo com finally

class conta{

public static void main(String args[]){ int den,num;

int c[]={1}; ...

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

(15)

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

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

(16)

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.

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){...} } }

(17)

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

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+”]”);

} }

(18)

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

} }