JAVA Bibliografia

LEIC-FEUP 2001/2002
Algoritmos e Estruturas de Dados 1
JAVA
Sumário
Elementos da linguagem
Classes e membros
Métodos e passagem de parâmetros
Tipos primitivos e tipos de referência
Strings e Arrays
Objectos e referências
Herança
Subclasses
Interfaces
Excepções
Entrada/Saída
Organização de programas
Packages
Documentação
JAVA
Bibliografia
Bruce Eckel
Thinking in Java, 2a. Edição, 2000.
versão electrónica em http://www.mindview.net/Books/TIJ/
pressupõe algum conhecimento de programação
H. M. Deitel, P. J. Deitel
Java How to Program, 2a. Edição.
Prentice-Hall International, 2000.
livro de programação com ênfase na linguagem Java.
M. A. Weiss
Data Structures & Problem Solving Using Java, 2a. Edição.
Addison-Wesley, 2001
Pequena introdução à linguagem, uso em estruturas de dados.
F. Mário Martins
Programação Orientada aos Objectos em JAVA2
FCA, 2000
JAVA
Cristina Ribeiro
1
LEIC-FEUP 2001/2002
Algoritmos e Estruturas de Dados 1
Arquitectura Java
Programa.java
Programa.class
Compilador
(javac ou J++)
Interpretador
(java)
(jview ou browser Web)
computador
executa Assembly
executa by te-code
JAVA
Classes
class Animal{
String name;
public Animal( ){
name = new String("ANIMAL ");
}
String isAlive( ){ return ("yes"); }
}
class Machine{
String name;
public Machine( ){
name = new String("MACHINE ");
}
String isAlive( ){ return ("no"); }
}
JAVA
Cristina Ribeiro
2
LEIC-FEUP 2001/2002
Algoritmos e Estruturas de Dados 1
Regras de nomeação
Variáveis locais e parâmetros: nomes curtos em minúsculas
Classes e Interfaces: nomes ou frases nominais, maiúsculas e
minúsculas, 1ª letra maiúscula
Membros (excepto final) nomes ou frases nominais, maiúsculas e
minúsculas, 1ª letra minúscula
Class SportsCar
{ int currentSpeed;
int maxSpeed; ...
Constantes em interfaces e variáveis final : tudo maiúsculas,
separadas por “_”
Métodos: verbos ou frases verbais, maiúsculas e minúsculas, 1ª letra
minúscula
JAVA
Tipos primitivos
os tipos primitivos não originam objectos, por razões de eficiência
criam-se variáveis automáticas na pilha, que contêm os valores
propriamente ditos em vez de referências
Tipo Primitivo Dim.
Mínimo
Máximo
boolean
char
byte
short
int
long
float
double
-Unicode 0
-128
-215
-231
-263
-3.4E+38
-1.8E+308
-Unicode 216 - 1
+127
+215 - 1
+231 - 1
+263 - 1
+3.4E+38
+1.8E+308
1-bit
16-bit
8-bit
16-bit
32-bit
64-bit
32-bit
64-bit
Tipo Derivado
Boolean
Character
Byte
Short
Integer
Long
Float
Double
JAVA
Cristina Ribeiro
3
LEIC-FEUP 2001/2002
Algoritmos e Estruturas de Dados 1
Inicialização
Para os tipos primitivos é garantida
… mas só quando são membros de uma classe
Tipo
boolean
char
byte
short
int
long
float
double
Inicialização
false
‘\u0000’ (null)
(byte)0
(short)0
0
0L
0.0f
0.0d
JAVA
Variáveis de classe
Qualificador static em atributo
public class Cube {
int side;
public Color cColor;
Cube( int s ){
side = s;
}
}
class picture
Cube
Cube
Cube
...
}
{
cube1 = new Cube ( 5 );
cube2 = new Cube ( 10 );
cube3 = new Cube ( 5 );
public class Cube {
static int side;
public Color cColor;
Cube(){ }
}
class picture {
Cube cube1 = new Cube ( );
Cube cube2 = new Cube ( );
Cube cube3 = new Cube ( );
Cube.side = 10;
...
}
JAVA
Cristina Ribeiro
4
LEIC-FEUP 2001/2002
Algoritmos e Estruturas de Dados 1
Métodos de classe
Qualificador static
em método
public class Squares
{
private static double squareRoots[ ] =
new double[ 100 ];
static
{
for( int i = 0; i < squareRoots.length; i++)
squareRoots[ i ] = Math.sqrt( ( double ) i);
}
método da classe
pode usar-se sem que existam
objectos da classe
notação:
<Classe>.<métodoEstático>
(exemplo: main)
// Rest of class
public static void main( String [ ] args )
{
System.out.println( "View first five entries");
se existirem objectos dessa
classe, também funciona:
<Objecto>. <métodoEstático>
for( int i = 0; i < 5 &&
i < squareRoots.length; i++ )
System.out.println( squareRoots[ i ] );
não tem this: não se podem
chamar métodos de instância
dentro de métodos de classe
}
}
Inicialização estática:
- com inicializador: static <bloco>
- com método estático: requer chamada
JAVA
Criação de objectos
Criação de uma referência para uma String:
String s;
cria só a referência, não o objecto
a referência está para o objecto como o comando para o televisor (deslocar a referência
/comando não implica transportar o objecto/televisor)
uma mensagem para s neste ponto origina erro (não há televisor)
pode-se inicializar uma cadeia de caracteres com
String s = "asdf";
mas isso é o caso especial das cadeias; em geral usa-se o operador new
Todos os objectos têm de ser criados
s = new String("asdf");
tudo de uma vez:
String s = new String("asdf");
à esquerda define-se a referência; à direita cria-se um objecto String inicializado
JAVA
Cristina Ribeiro
5
LEIC-FEUP 2001/2002
Algoritmos e Estruturas de Dados 1
Objectos e referências
Variáveis dos tipos primitivos guardam valores
Variáveis dos outros tipos guardam referências para objectos
2 tipos de operações sobre uma referência
Examinar e manipular o valor desta
⌧só se aceitam operadores = (atribuição), == e != (comparação)
Manipular o objecto referido
⌧conversão de tipos
⌧acesso a atributos ou chamada de métodos
⌧Operador instanceof para verificar tipo do objecto
Atribuição
esquerdo = direito
tem o mesmo significado em tipos primitivos e em referência: valor guardado em
direito é copiado para esquerdo
se forem referências: esquerdo passa a referir o mesmo objecto que direito
JAVA
Métodos e passagem de parâmetros
int comprimento(String s){
return s.length();
c
}
comprimento( )
v
v = comprimento(c)
este método recebe como argumento uma cadeia s
⌧mais concretamente é passada uma referência para uma cadeia
devolve (return) o resultado de enviar a mensagem length() a s
⌧o respectivo método está na classe String
⌧return termina a execução do método, onde quer que apareça
o resultado do método comprimento é do tipo int
os métodos só vivem dentro de classes
⌧comprimento, para ser compilado, tem de estar numa classe
JAVA
Cristina Ribeiro
6
LEIC-FEUP 2001/2002
Algoritmos e Estruturas de Dados 1
String
Imutáveis: depois de construídas não são modificadas
Concatenação: + constrói String se um dos argumentos o for
== e != testam identidade de objectos, não igualdade
equals é método sistemático para testar igualdade
Alguns Métodos
esquerdo.compareTo(direito) compara de acordo com ordem lexicográfica
cadeia.length()
cadeia.charAt(pos) indexa a partir de 0
cadeia.substring(ini, fim)
tostring converte tipo primitivo em String (é implícito em +)
Integer.parseInt constrói inteiro representado em String
JAVA
Array
Colecção de entidades do mesmo tipo
declaração int [] array1
ou int array1 []
Construção
array1 = new int [100]
com incialização: int [] array2 = {3, 4, 5, 6}
necessário criar elementos:
Button [] arrayOfButtons;
arrayOfButtons = new Button [5];
for( int i=0; i< arrayOfButtons.length; i++)
arrayOfButtons[i] = new Button();
construção é dinâmica
multi-dimensional: int [][] x = new int [2][3];
JAVA
Cristina Ribeiro
7
LEIC-FEUP 2001/2002
Algoritmos e Estruturas de Dados 1
Referências e atribuição
class Number {
int i;
}
class Letter {
char c;
}
public class Assignment {
public static void main(String[] args) {
Number n1 = new Number();
Number n2 = new Number();
n1.i = 9;
n2.i = 47;
System.out.println("1: n1.i: " + n1.i +
", n2.i: " + n2.i);
n1 = n2;
System.out.println("2: n1.i: " + n1.i +
", n2.i: " + n2.i);
n1.i = 27;
System.out.println("3: n1.i: " + n1.i +
", n2.i: " + n2.i);
}
}
public class PassObject {
static void f(Letter y) {
y.c = 'z';
}
static void main(String[] args) {
Letter x = new Letter();
x.c = 'a';
System.out.println("1: x.c: " +
x.c);
f(x);
System.out.println("2: x.c: " +
x.c);
}
}
•Atribuição muda referências
•Objecto passado como parâmetro: a referência é usada
JAVA
Igualdade
public class Equivalence {
public static void main(String[] args) {
Integer n1 = new Integer(47);
Integer n2 = new Integer(47);
System.out.println(n1 == n2);
System.out.println(n1 != n2);
}}
public class EqualsMethod {
public static void main(String[] args) {
Integer n1 = new Integer(47);
Integer n2 = new Integer(47);
System.out.println(n1.equals(n2));
}}
Igualdade com ==
só para tipos primitivos
Para os outros
== compara as referências
Para os objectos de uma nova classe,
equals exibe o comportamento por
omissão: compara as referências!
class Value {
int i; }
public class EqualsMethod2 {
public static void main(String[] args) {
Value v1 = new Value();
Value v2 = new Value();
v1.i = v2.i = 100;
System.out.println(v1.equals(v2));
}}
JAVA
Cristina Ribeiro
8
LEIC-FEUP 2001/2002
Algoritmos e Estruturas de Dados 1
Sobrecarga
class Arvore {
int altura;
static int quant=0;
Arvore() {
prt("Semeando uma semente");
altura = 0; quant++;
}
Arvore(int i) {
prt("Plantando uma arvore com "
+ i + " metros de altura");
altura = i; quant++;
}
void info() {
prt("A arvore tem " + altura +
" metros de altura");
}
void info(String s) {
prt(s + ": a arvore tem " + altura
+ " metros");
}
static void prt(String s) {
System.out.println(s); }}
import java.util.*;
public class Sobrecarga {
static Random alea = new Random();
static int aleatorio(int mod) {
return Math.abs(alea.nextInt()) % mod;
}
public static void main(String args[]) {
int i = 0;
while(i != 9) {
Arvore t = new Arvore(i = aleatorio(10));
t.info();
t.info("Legenda");
} // construtor sobrecarregado:
new Arvore();
Arvore.prt ("Instâncias: "+ Arvore.quant);
}
}
JAVA
Membros das classes
Arvore
membros de instância
membros de classe
altura
info()
info(-)
quant: 2
prt()
Arvore()
Arvore(-)
altura:7
altura: 4
Sobrecarga
membros de classe alea
aleatorio()
prt()
“new”
info()
info(-)
JAVA
Cristina Ribeiro
9
LEIC-FEUP 2001/2002
Algoritmos e Estruturas de Dados 1
Sobrecarga de métodos
sobrecarga - permite lidar com
variações de conceitos
essencialmente idênticos
comportamentos diferentes
conforme o número e tipo de
argumentos do método respectivo
Construtores: métodos especiais
que não devolvem nada (nem
void) e têm nome fixo; podem ser
sobrecarregados
Operadores: não podem ser
sobrecarregados
excepção: + e += em String
Exemplo das árvores:
o método info pode ter ou não
uma etiqueta como argumento
pode-se criar uma árvore sem
altura (semeá-la) ou com altura
(plantar uma já crescida)
o gerador de números aleatórios
fica numa variável de classe,
para poder ser actuado por um
método de classe
a atribuição, para além de
funcionar como instrução,
também é uma expressão
JAVA
Métodos Básicos
Acesso e modificação
deve ser feito via métodos, e não tornando públicos os atributos
⌧para cada atributo acessível: métodos verAtrib e porAtrib
⌧pode assegurar-se estado consistente dos dados
Saída
tostring - método de classe que devolve String própria para imprimir
⌧Método toString na classe Object devolve uma string com o nome da classe do objecto,
seguida de `@', seguida da representação hexadecimal do seu código de hash
equals - testar se 2 referências são para o mesmo valor
public boolean equals( Object obj) retorna true na classe UmaClasse se
⌧obj é instância de UmaClasse
⌧convertendo obj para UmaClasse, todos os atributos primitivos são iguais (==) e
todas as referências são iguais (equals) aos do objecto corrente
main - qualquer classe pode ter (usar em teste)
JAVA
Cristina Ribeiro
10
LEIC-FEUP 2001/2002
Algoritmos e Estruturas de Dados 1
Auto-referência (this)
um método tem sempre um
parâmetro implícito que é
o objecto (ou classe) a que
se vai aplicar
x.inc() pode ser visto como
inc(x) (notação mais corrente)
se se omitir o objecto assumese que se trata do objecto
corrente
public class Contador {
private int i = 0;
Contador inc() {
i++;
return this; }
void print() {
System.out.println("i = " + i); }
public static void main(String args[]){
para referir explicitamente o
objecto corrente usa-se this
Contador x = new Contador();
uma escolha criteriosa do
resultado das funções pode
permitir um estilo de escrita
que use composição de funções
x.inc().inc().inc().print();
Contador y = new Contador();
y.inc().print(); }
}//Contador
JAVA
Referências this e super
para designar um membro m (atributo ou método) de um
objecto o, a notação é o.m
na definição dos métodos de uma classe, o objecto corrente está normalmente
implícito (referem-se os membros sem prefixo)
se existir uma variável x num método da classe com o mesmo nome de um atributo,
este fica escondido; para lhe chegar usa-se this.x
this refere-se ao objecto corrente
se existir um método local f() com o mesmo nome de um numa superclasse, este
fica escondido; para lhe chegar usa-se super.f()
super refere-se ao objecto corrente, mas indicando o início da pesquisa de métodos
só na superclasse imediata (as variáveis visíveis em f() são as do objecto corrente)
super pode ser usado para fazer revogação parcial de um método: fornecer nova
definição que chama método da superclasse
JAVA
Cristina Ribeiro
11
LEIC-FEUP 2001/2002
Algoritmos e Estruturas de Dados 1
Construtores
evitar objectos com variáveis por
inicializar
class Tijolo{
Tijolo() { // é este o construtor
System.out.println("A criar um
tijolo");
Construtor - é um método com o
mesmo nome da classe invocado na
criação de cada instância, e que
procede à sua inicialização
a responsabilidade é do
implementador da classe e não dos
programadores que a usam
}}
public class Construcao {
public static void main(String args[])
{
for(int i = 0; i < 10; i++)
possível passar argumentos a
completar a inicialização
new Tijolo();
}}
JAVA
Construtores e this
public class Flor {
Flor() {
private int i = 0;
this("Cravo", 47);
private String s = new String(null);
System.out.println(
Flor(int x){
"Construtor p/ omissão (sem args)" );
i = x;
}
System.out.println(
void print() {
"Construtor com int: i= " + i );}
System.out.println(
"i = " + i + " s = " + s);
Flor(String ss) {
System.out.println(
"Construtor com String:s= " +ss );
s = ss;}
}
public static void main(String args[]){
Flor x = new Flor();
x.print();
} }
Flor(String s, int x) {
this(x);
/* resultado:
this.s = s; // Outro uso do "this"
Construtor com int: i=47
System.out.println("Dois args");
Dois args
Construtor por omissão (sem args)
}
i=47 s=Cravo */
JAVA
Cristina Ribeiro
12
LEIC-FEUP 2001/2002
Algoritmos e Estruturas de Dados 1
Criação e eliminação
o construtor por omissão
não tem argumentos
só é sintetizado se não se definir
nenhum construtor
um construtor pode usar
outro chamando-o com a
sintaxe this(args)
tem de ser a primeira instrução
só se pode chamar outro construtor
uma vez
não se pode usar esta sintaxe num
método que não seja um construtor
uso do this, como referência ao
objecto corrente, dentro de um
construtor; por exemplo para
desambiguar um nome de atributo
igual a um argumento (this.s=s)
não existe destruição de
objectos
quando deixam de ser precisos
(não há mais referências para
eles) são eliminados pelo
colector de lixo (garbage
colector), que é um processo
automático do sistema de
execução Java (ver exemplo dos
tijolos)
se não se define o
construtor
construtor por omissão inicializa
⌧tipos primitivos a 0
⌧referências a null
JAVA
Classes e subclasses
Objecto da subclasse é “do mesmo tipo” que objecto da classe
Como se estende a classe na subclasse
Novos métodos
Novas definições para os métodos
JAVA
Cristina Ribeiro
13
LEIC-FEUP 2001/2002
Algoritmos e Estruturas de Dados 1
Classe Derivada
Acrescenta atributos
Pode acrescentar métodos
Métodos da classe de base não redefinidos: herdados
Métodos da classe de base redefinidos na parte pública
revogados
Métodos públicos da classe de base
não podem ser redefinidos como privados
Membros protected da classe base
visíveis nas classes derivadas
Membros final
⌧método final: não pode ser revogado
⌧classe final: é folha na hierarquia
JAVA
Herança
class Cleanser {
private String s=new String("Cleanser");
public void append(String a) {
public class Detergent extends Cleanser {
// Change a method:
public void scrub() {
s += a; }
append(" Detergent.scrub()");
public void dilute() {
//Call base-class version
append(" dilute()"); }
public void apply() {
append(" apply()"); }
super.scrub();}
// Add methods to the interface:
public void foam() {
public void scrub() {
append(" foam()"); }
append(" scrub()"); }
public void print() {
public static void main(String[] args){
Detergent x = new Detergent();
System.out.println(s); }
x.dilute(); x.apply();
public static void main(String[] args)
{
Cleanser x = new Cleanser();
x.scrub(); x.foam(); x.print();
System.out.println("Test base class:");
x.dilute(); x.apply(); x.scrub();
x.print();}
Cleanser.main(args);}
}
}
JAVA
Cristina Ribeiro
14
LEIC-FEUP 2001/2002
Algoritmos e Estruturas de Dados 1
Construção com herança
a hierarquia pode ter mais do
que dois níveis
// Cartoon.java
class Arte {
Arte() {
o sistema chama todos os
construtores que afectam o
objecto, começando pelo mais
geral
Println(”Construtor Arte");
} }
class Desenho extends Arte {
Desenho() {
resultado
Println(”Construtor Desenho");
Construtor Arte
} }
Construtor Desenho
public class Cartoon extends Desenho {
Construtor Cartoon
Cartoon() {
Println(”Construtor Cartoon"); }
herança suporta
desenvolvimento incremental e
prototipagem rápida
public static void main(String args[])
{
Cartoon x = new Cartoon(); } }
JAVA
Herança e construção
class Game {
Game(int i) {
System.out.println("Game constructor");
}
}
class BoardGame extends Game {
BoardGame(int i) {
super(i);
System.out.println("BoardGame constructor"); }
}
public class Chess extends BoardGame {
Chess() {
super(11);
System.out.println("Chess constructor");
}
public static void main(String[] args) {
Chess x = new Chess(); }
}
JAVA
Cristina Ribeiro
15
LEIC-FEUP 2001/2002
Algoritmos e Estruturas de Dados 1
Herança
Hierarquia é induzida pela relação IS-A
Animal
IndexOutOfBoundsException
RuntimeException
IS-A
NullPointerException
Exception
Cão
EOFException
IOEx ception
FileNotFoundException
IS-A é transitiva
NullPointerException é Exception, embora não seja esta a sua classe de base
Operador instanceof atravessa hierarquia
X is-a Y e Y is-a Z : se obj é do tipo X (e não é null) obj instanceof Z é true
JAVA
Herança e Inicialização
class Insect {
public class Beetle extends Insect {
int i = 9;
int k = prt("Beetle.k initialized");
int j;
Beetle() {
Insect() {
prt("k = " + k);
prt("i = " + i + ", j = " + j);
j = 39;
}
prt("j = " + j);
}
static int x2 =
static int x1 =
prt("static Insect.x1 initialized");
static int prt(String s) {
prt("static Beetle.x2 initialized");
public static void main(String[] args)
{
prt("Beetle constructor");
System.out.println(s);
Beetle b = new Beetle();
return 47;
}
}
}
}
JAVA
Cristina Ribeiro
16
LEIC-FEUP 2001/2002
Algoritmos e Estruturas de Dados 1
Herança Múltipla
Problema: como definir objectos que se enquadram em mais do
que uma hierarquia?
Public interface Noisy {
String noise( );
}
Public interface Moves {
String move( );
}
Interface
• abstracta: não pode ser implementada independentemente de uma classe
• métodos são public abstract
• atributos são public static final
JAVA
Interfaces
Colecção de nomes de métodos que fornecem “esquemas” para a
criação de novas classes
Exemplos
Runnable no package java.lang
DataInput no package java.io
São abstractas: métodos são definidos, implementação fica para
as subclasses
public interface Vehicle {
void goForward( );
void goBackward( ):
}
public class Car implements Vehicle {
...
void goForward( ) {
...
}
void goBackward( ) {
...}}
JAVA
Cristina Ribeiro
17
LEIC-FEUP 2001/2002
Algoritmos e Estruturas de Dados 1
Interface e Implementação
public class Cat extends Animal
implements Noisy, Moves{
String name;
public Cat( ) {
name = new String( "Cat " );
}
public String noise( ){
return ("MEOW ");
}
public String move( ){
return ("feet ");
}
}
public class Car extends Machine
implements Noisy, Moves{
String name;
public Car( ) {
name = new String("Car ");
}
public String noise( ){
return ("VROOM ");
}
public String move( ) {
return ("wheels ");
}
}
class Ear {
String heard;
void hear (Noisy n){
heard = n.noise( );
}
}
JAVA
Herança Múltipla
class Hero extends ActionCharacter
import java.util.*;
implements CanFight, CanSwim, CanFly {
public void swim() {}
interface CanFight {
void fight();
public void fly() {}
}
}
public class Adventure {
interface CanSwim {
void swim();
}
static void t(CanFight x) { x.fight(); }
static void u(CanSwim x) { x.swim(); }
static void v(CanFly x) { x.fly(); }
static void w(ActionCharacter x) {x.fight(); }
interface CanFly {
void fly();
}
public static void main(String[] args) {
Hero h = new Hero();
t(h); // Treat it as a CanFight
u(h); // Treat it as a CanSwim
class ActionCharacter {
public void fight() {}
}
v(h); // Treat it as a CanFly
w(h); // Treat it as an ActionCharacter
}}
JAVA
Cristina Ribeiro
18
LEIC-FEUP 2001/2002
Algoritmos e Estruturas de Dados 1
Uma Interface da API
Alguns métodos:
java.io
Interface DataInput
All Known Subinterfaces:
ObjectInput
All Known Implementing Classes:
RandomAccessFile,
DataInputStream
boolean
byte
char
double
float
void
int
String
int
int
readBoolean()
readByte()
readChar()
readDouble()
readFloat()
readFully(byte[] b)
readInt()
readLine()
readUnsignedByte()
skipBytes(int n)
JAVA
Excepção
Em Java: Classes Error e Exception, subclasses de Throwable
Excepção:
⌧Objecto que guarda informação transmitida fora da sequência normal de retorno
⌧Propagada para trás na sequência de chamadas até método que a trate
⌧Formato:
try <bloco>
catch ( <UmaClasseException> e)
finally <bloco>
<bloco>
⌧Comportamento:
se try executa sem excepção : passa a bloco de finally
se try encontra excepção que não tem catch correspondente: passa a bloco finally e
propaga
se try encontra excepção que tem catch correspondente: executa blocos de catch e de
finally
Erro:
⌧Situação anormal que não requer “catch” numa aplicação regular
JAVA
Cristina Ribeiro
19
LEIC-FEUP 2001/2002
Algoritmos e Estruturas de Dados 1
Excepções
Checked exceptions: tem de ser feito o catch ou declarado throws
public static void processa( String cadeia) throws IOException
{ ...}
public static void main(String [] args)
{
for( int i = 0; i < args.length; i++)
{
try
{ processa( args[i] ); }
catch( IOException e )
{ System.err.println( e ); }
} }
Assinalar situação de excepção detectada
throw new Exception( “Vai mal” )
JAVA
Entrada/Saída
import java.io.*;
Streams
predefinidos:
system.in
System.out
system.err
public class DivideByTwo
{
public static void main( String [ ] args )
{
BufferedReader in = new BufferedReader(
new InputStreamReader( System.in ) );
int x;
String oneLine;
}
System.out.println( "Enter an integer: " );
try
{
oneLine = in.readLine( );
x = Integer.parseInt( oneLine );
System.out.println( "Half of x is " +
( x / 2 ) );
}
catch( Exception e )
{ System.out.println( e ); }
}
JAVA
Cristina Ribeiro
20
LEIC-FEUP 2001/2002
Algoritmos e Estruturas de Dados 1
Leitura em Ficheiros Sequenciais
Reading bytes
Reading characters
Unformatted
(Chapman, Cap. 14)
Formatted
JAVA
Escrita em Ficheiros Sequenciais
Writing bytes
Writing characters
Formatted
Unformatted
(Chapman, Cap. 14)
JAVA
Cristina Ribeiro
21
LEIC-FEUP 2001/2002
Algoritmos e Estruturas de Dados 1
Entrada/Saída
import java.io.*;
import java.util.*;
public class MaxTest
{
public static void main( String args[ ] )
{
BufferedReader in = new BufferedReader(new InputStreamReader( System.in ) );
String oneLine;
StringTokenizer str;
int x; int y;
System.out.println( "Enter 2 ints on one line: " );
try {
oneLine = in.readLine( );
str = new StringTokenizer( oneLine );
if( str.countTokens( ) != 2 )
throw new NumberFormatException( );
x = Integer.parseInt( str.nextToken( ) );
y = Integer.parseInt( str.nextToken( ) );
System.out.println( "Max: " + Math.max( x, y ) );
}
catch( Exception e )
{ System.err.println( "Error: need two ints" ); } } }
JAVA
Modificadores de Visibilidade
public: (método, variável, classe)
acessível por todas as outras classes (que importem o pacote) e seus membros
<sem declaração> = friend
acessível pelas classes do pacote
invisível para as outras (mesmo as subclasses)
private: (método, variável)
acessível apenas por métodos da classe
protected: (método, variável)
acessível pelas classes do pacote e pelas subclasses da que contém o item (por herança)
private protected
só acessível pelas subclasses
inacessível para as do pacote
Modificador é obrigatório em cada variável de instância ou método
JAVA
Cristina Ribeiro
22
LEIC-FEUP 2001/2002
Algoritmos e Estruturas de Dados 1
Uma classe privada
class Soup {
class Sandwich { // Uses Lunch
private Soup() {}
void f() { new Lunch(); }
// (1) Allow creation via static method:
}
public static Soup makeSoup() {
return new Soup();
public class Lunch {
}
void test() {
// (2) Create a static object and
//! Soup priv1 = new Soup();
// return a reference upon request.
Soup priv2 = Soup.makeSoup();
// (The "Singleton" pattern):
Sandwich f1 = new Sandwich();
private static Soup ps1 = new Soup();
Soup.access().f();
public static Soup access() {
return ps1;
}
}
}
public void f() {}
}
JAVA
Modificadores
abstract: (método) não tem corpo
declara funcionalidade que a classe derivada tem de fornecer
abstract: (classe) não tem instâncias
public abstract class Shape( ) {
public abstract void draw( );
}
public class Circle extends Shape {
public void draw( ) {
your method here...
}
}
JAVA
Cristina Ribeiro
23
LEIC-FEUP 2001/2002
Algoritmos e Estruturas de Dados 1
Classe abstract da API
public abstract class KeyAdapter
extends Object
implements KeyListener
Classe de adaptação para eventos do teclado
Estender esta para criar um “listener” para objectos KeyEvent e sobrepor
métodos só para os eventos de interesse
Vantagem sobre interface:
Se se implementa o KeyListener interface, têm de se definir todos os métodos
a classe abstracta define methods nulos para todos eles, quem usa sobrepõe só os de interesse
component.addKeyListener(new KeyAdapter() {
public void keyPressed(KeyEvent evt) {
}
});
JAVA
Aplicação
// Propriedades.java
import java.util.*;
//+ import java.io.*;
public class Propriedades {
public static void main(String args[]) {
//+ throws IOException
System.out.println(new Date());
System.getProperties().list(System.out);
// data do dia
// info sobre sistema
Runtime rt = Runtime.getRuntime();
// info sobre execução
System.out.println( "Memoria Total = " + rt.totalMemory()
+ " Memoria Livre = " + rt.freeMemory());
//+ int x = System.in.read()
// pausa
}
}
// activar instruções //+ para correr com jview
import
public
main
static
System
Date
<class>.<metodo>
JAVA
Cristina Ribeiro
24
LEIC-FEUP 2001/2002
Algoritmos e Estruturas de Dados 1
Applets
Applets: programas preparados
para serem executados no ambiente
de um vasculhador Web
applet tem que ser uma subclasse
de Applet e tem que ser pública
o vasculhador chama
automaticamente o método
paint(), usado para escrever no
écran
o método drawString tem como
parâmetros a cadeia e a respectiva
posição na janela
ficheiro HTML chama applet
// Ola.java
import java.awt.Graphics;
import java.applet.Applet;
public class Ola extends Applet {
public void paint( Graphics g )
{
g.drawString("Ola a todos!", 25,25);
}
}
<!Ola.html>
<html>
<applet code=Ola.class width=275
height=35 >
</applet>
</html>
JAVA
Métodos automáticos numa applet
public void init()
⌧chamado uma vez ao carregar a applet; inicializa variáveis e componentes GUI
public void resize( int width, int heigth ) redimensiona a applet
public void start()
⌧chamado a seguir ao init e sempre que o utilizador retorna à página HTML da
applet; arranca animações e fios de execução
public void paint( Graphics g )
⌧chamado depois do init acabar e de o start começar; (re)desenha a applet e é
chamado quando esta é coberto por outra janela
⌧public void repaint() permite chamar o paint sem precisar do g
public void stop()
⌧chamado para terminar a execução quando o vasculhador deixa a página HTML
da applet; interrompe animações e fios de execução
public void destroy()
⌧chamado para eliminar a applet da memória quando o vasculhador termina;
cancela fios de execução
JAVA
Cristina Ribeiro
25
LEIC-FEUP 2001/2002
Algoritmos e Estruturas de Dados 1
Applet
public class Spot extends Applet implements MouseListener {
private java.awt.Point clickPoint = null;
private static final int RADIUS = 7;
public void init() {
addMouseListener(this);
}
public void paint(Graphics g) {
g.drawRect(0, 0, getSize().width - 1,
getSize().height - 1);
if (clickPoint != null)
g.fillOval(clickPoint.x - RADIUS,
clickPoint.y - RADIUS,
RADIUS * 2, RADIUS * 2);
}
public void mousePressed(MouseEvent event) {
clickPoint = event.getPoint();
repaint();
}
public void mouseClicked(MouseEvent event) {}
public void mouseReleased(MouseEvent event) {}
public void mouseEntered(MouseEvent event) {}
public void mouseExited(MouseEvent event) {} }
import java.applet.Applet;
import java.awt.*;
import java.awt.event.*;
JAVA
Applet
import java.applet.*;
import java.awt.*;
public class BasicApplet extends Applet {
public void init() {
// Called once by the browser when it starts the applet.
}
public void start() {
// Called whenever the page containing this applet is made visible.
}
public void stop() {
// Called whenever the page containing this applet is not visible.
}
public void destroyed() {
// Called once when the browser destroys this applet.
}
public void paint(Graphics g) {
// Called whenever this applet needs to repaint itself.
}
}
JAVA
Cristina Ribeiro
26
LEIC-FEUP 2001/2002
Algoritmos e Estruturas de Dados 1
Applet
public class AdapterSpot extends Applet //no implements clause
{
private Point clickPoint = null;
private static final int RADIUS = 7;
import java.applet.Applet;
import java.awt.*;
import java.awt.event.*;
public void init() {
addMouseListener(new MyMouseAdapter());
}
public void paint(Graphics g) {
g.drawRect(0, 0, getSize().width - 1,
getSize().height - 1);
if (clickPoint != null)
g.fillOval(clickPoint.x-RADIUS,
clickPoint.y-RADIUS,
RADIUS*2, RADIUS*2);
}
class MyMouseAdapter extends MouseAdapter
{
public void mousePressed(MouseEvent event) {
clickPoint = event.getPoint();
repaint();
}}
JAVA
Packages
Organizam classes relacionadas
evitam o uso de nomes completos
sintaxe declaração package MeuPacote antes da definição da classe
sintaxe importação:
⌧import NomePackage.NomeClasse ou import NomePackage.*
pode tornar difícil, ao ler o código, identificar a origem das classes
importação de java.lang é automática; resultam classes Math, Integer, System, ...
Pesquisa de pacotes: em directórios do CLASSPATH
Classes do package P: no directório P, em caminho do CLASSPATH
Visibilidade
⌧sem modificador são friendly ; public são acessíveis fora do pacote
todas as classes encontradas em CLASSPATH e sem declaração de package são do
mesmo package por omissão
JAVA
Cristina Ribeiro
27
LEIC-FEUP 2001/2002
Algoritmos e Estruturas de Dados 1
Componentes genéricos
Reutilização de código:
implementação igual a menos do tipo
dos dados: fazer implementação
genérica
ex: ordenação de um vector não
depende do tipo dos seus elementos
// MemoryCell class
// Object read( )
//
--> Returns the stored value
// void write( Object x )
//
--> x is stored
public class MemoryCell
{
// Public methods
Programação genérica em
JAVA:
public Object read( )
{ return storedValue; }
public void write( Object x)
{ storedValue = x; }
classe genérica usa objectos de uma
superclasse apropriada (ex: Object)
ex: ordenação de um vector não
depende do tipo dos seus elementos
// Private internal data
private Object storedValue;
}
JAVA
Classes “wrapper”
Classes especiais para os 8 tipos primitivos
permitem tratá-los genericamente como objectos
public class TestMemoryCell
{
public static void main( String [ ] args )
{
MemoryCell m = new MemoryCell( );
m.write( new Integer( 5 ) );
System.out.println( "Contents are: " +
( (Integer) m.read( ) ).intValue( ) );
}
}
JAVA
Cristina Ribeiro
28
LEIC-FEUP 2001/2002
Algoritmos e Estruturas de Dados 1
Documentação automática
javadoc - aproveita a
informação no ficheiro
de descrição de uma
classe (implementação)
para documentar a
interface
Saída é ficheiro HTML
comentários com /** são usados
/**
* A class for simulating an integer memory cell
* @author Mark A. Weiss
*/
public class IntCell
{
/**
* Get the stored value.
* @return the stored value.
*/
public int read( )
{
return storedValue;
}
/**
* Store a value
* @param x the number to store.
*/
public void write( int x )
{
storedValue = x;
}
etiquetas especiais para metainformação
@author, @param, @return, @exception
private int storedValue;
}
JAVA
Packages na API Java
java.lang
construções básicas da linguagem; importado automaticamente
java.util
processamento de datas e horas, números aleatórios, cadeias, …
java.io (input/output)
entrada e saída de dados
java.net
suporte para comunicação via Internet
java.applet
criação de applets e respectiva interacção
java.awt (abstract windowing toolkit)
criação e manipulação de GUI
javax.swing
criação e manipulação de GUI, pacote “leve”
JAVA
Cristina Ribeiro
29
LEIC-FEUP 2001/2002
Algoritmos e Estruturas de Dados 1
Serialização de Objectos
Interface Serializable
em java.io
Classes que não implementam esta interface não têm o seu estado serializado or desserializado
Subclasses de classe “serializable” são também “serializable”
A interface de serialização não tem métodos nem atributos e serve apenas para
identificar a classe como serializável
Interface ObjectOutput em java.io
extends DataOutput inclui escrita de objectos
DataOutput tem métodos para saída de tipos primitivos
ObjectOutput alarga-a para incluir Object, arrays, Strings
Implementada por ObjectOutputStream
void writeObject(Object obj)
Write an object to the underlying storage or stream.
JAVA
Serialização de Objectos
Interface Serializable
em java.io
Classes que não implementam esta interface não têm o seu estado serializado or desserializado
Subclasses de classe “serializable” são também “serializable”
A interface de serialização não tem métodos nem atributos e serve apenas para
identificar a classe como serializável
Interface ObjectInput em java.io
extends DataInput inclui escrita de objectos
DataInput tem métodos para saída de tipos primitivos
ObjectInput alarga-a para incluir Object, arrays, Strings
Implementada por ObjectInputStream
Object readObject()
Read and return an object.
JAVA
Cristina Ribeiro
30
LEIC-FEUP 2001/2002
Algoritmos e Estruturas de Dados 1
Serialização- exemplo
FileOutputStream ostream = new FileOutputStream("t.tmp");
ObjectOutputStream p = new ObjectOutputStream(ostream);
p.writeInt(12345);
p.writeObject("Today");
p.writeObject(new Date());
p.flush();
ostream.close();
JAVA
Cristina Ribeiro
31