-
1
IntroduIntroduççãoão aoao
JavaJavaFEUP>DEEC>MRSC>FEUP>DEEC>MRSC>ProgramaProgramaççãoão
emem ComunicaComunicaççõesõesv1.4v1.4
Isidro Vila Verde Jaime Sousa Dias
2
O que O que éé o JAVA?o JAVA?
• É uma Linguagem de Programação• Orientada aos objectos Class
Based• Concorrente• High Level• Strongly Typed• Portável
• Um programa em JAVA é independente da arquitectura • Em
principio pode correr em qualquer plataforma
• Uma máquina virtual (JVM)• Biblioteca de Classes• API
-
2
ComparaComparaçção com outras linguagensão com outras
linguagens
4
DiferenDiferençças para o C++as para o C++
• Cada classe (pública) é gravada num ficheiro respectivo com o
mesmo nome da classe* e extensão .java• * Na realidade esta
afirmação só se aplica a Top Level Classes
• O que existe em Java• Run Time Type Check
• Array bounds• Null pointers access
• Interfaces• Concorrência (Multi-thread) nativa• Garbage
Collector
• Os recursos dos objectos são automaticamente libertados quando
osistema detecta que já não são necessários (referenciados)
-
3
5
DiferenDiferençças para o C++ (2)as para o C++ (2)
• O que não existe em Java• Estruturas (struct)• Uniões (union)•
Apontadores ou ponteiros (pointers)
• Apenas referências• Apontadores para funções (Function
Pointers)• Funções globais
• Incluindo a função do C/C++ main Em java o main é uma função
membro estática
• Variáveis/Objectos globais• Malloc’s ou delete’s A gestão de
memória é automática
(Garbage Colector) • Herança múltipla
6
DiferenDiferençças para o C++ (3)as para o C++ (3)
• O que não existe em Java (cont.)• Sobrecarga de operadores
(operator overloading)• Templates• Header Files (.h)• Directiva de
pré-processamento (ex: #pragma)• Variáveis-objecto Em java tudo o
que não seja tipo primitivo é
manuseado como referência
-
4
7
Java vs. outras linguagensJava vs. outras linguagens
• PERL, TCL, Python• São interpretadas• O código fonte é
distribuído aos utilizadores• Obriga à instalação prévia do
interpretador• Se fizer uso de primitivas/comandos do sistema terá
de haver uma
versão de código para cada S.O. • Execução lenta
8
Java vs. outras linguagens (2)Java vs. outras linguagens (2)
• C, C++, Pascal• São linguagens compiladas• O código fonte não
é distribuído aos utilizadores, apenas o código
binário• Se fizer uso de primitivas/comandos do sistema terá de
haver uma
versão de código para cada S.O.
-
5
9
Java vs. outras linguagens (3)Java vs. outras linguagens (3)
• C, C++, Pascal (cont.)• Necessita de uma versão binária por
cada ambiente (S.O. + CPU)
• Windows• Eventualmente: 95, NT, 2000• Necessáriamente: Intel,
Alpha, Mips
• Unix• Eventualmente: BSD, Linux, AIX, HP-UX, SCO•
Necessariamente: Sparc, Intel, Alpha, Mips
• Execução Eficiente• Em C ou C++ é possível controlar ao nível
do assembly a eficiência
• O programador pode controlar/garantir eficiência
10
Java vs. outras linguagens (4)Java vs. outras linguagens (4)
• JAVA• É compilado para uma máquina virtual
• O compilador gera Bytecodes• O Código fonte não é distribuído•
Uma só versão de código independente da plataforma (CPU e/ou
S.O.)• O código binário (Bytecodes) é carregado e interpretado
na JVM
(Java Virtual Machine)• $> java codigodaclass
• Obriga à existência ou instalação prévia do JRE (Java
RunTimeEnviroment)
• Incluí a JVM
• Execução lenta
-
6
11
Ambiente JAVAAmbiente JAVA
System Library classes Compile
Java SourceApp.java
Java Byte CodesApp.class
Java Interpreter
JJVVMM
JDKJDK
WRITEWRITE USEUSE
JREJRE
Operating System
Hardware
Runtime System
Just in Time Compiler
Class loader bytecode verifier
Java Libraries
12
TiposTipos de de programasprogramas JavaJava
• Aplicações• programas “Standalone”
• Applets• Componentes de código que correm num ambiente WEB
• Servlets• São componentes de código que correm num servidor
WEB por
oposição às Applets que correm no cliente (navegador)
• JSP• Java Server Pages – Directivas embutidas em páginas HTML
que
permitem executar código JAVA intercalado com HTML
-
7
Exemplo de UtilizaExemplo de Utilizaççãoão
14
Executar uma aplicaExecutar uma aplicaçção escrita em Javaão
escrita em Java
• O JRE• java, javaw, appletviewer
• O código da aplicação• App.class
• Executar• $> java App
• Omite-se a extensão “.class”• Nota: o ficheiro App.class deve
estar o directório corrente ou num
dos directórios incluídos na variável de ambiente CLASSPATH.
-
8
15
JRE instalado?JRE instalado?
• Verificar se já está instalado• Executar java -version
• Se corre então deve estar (devidamente?) instalado• Nas
distribuições recentes dos S.O.s já é fornecido e instalado por
omissão• Se não encontrou o programa java
• http://java.sun.com• Seleccionar o J2SE (última versão)•
Selecionar o JRE
• O SDK só é necessário para fazer desenvolvimento• Fazer o
download e instalar
16
Criar uma aplicaCriar uma aplicaçção em Javaão em Java
• Um editor de texto • vi, pico, notepad, wordpad, etc.
• O java JDK (SDK)• Verificar se já está instalado
• Executar javac -version• Se corre então deve estar
(devidamente?) instalado• Nota: não é java é javac (Java
Compiler)
• Se não encontrou o comando• http://java.sun.com• Seleccionar o
J2SE (última versão)• Seleccionar o SDK• Fazer o download e
instalar
-
9
17
Escrever a aplicaEscrever a aplicaççãoão
• Criar um ficheiro com o nome da aplicação e extensão .java•
Ex: App.java
• Editar o ficheiro App.java e criar uma classe (class)
Apppública (public)
public class App {
}
18
Escrever a aplicaEscrever a aplicaçção (2)ão (2)
• Incluír na definição da classe um método estático (static)
público (public) e sem tipo (void), de nome main com um argumento
do tipo array de strings (String[])
public class App {
public static void main(String[] args) {
}
}
-
10
19
Escrever a aplicaEscrever a aplicaçção (3)ão (3)
• Definir o método main para executar o código pretendido• Ex:
Escrever “Hello World”
public class App {
public static void main(String[] args) {
System.out.println("Hello World");
}
}
20
Compilar o cCompilar o cóódigodigo
• Gravar o ficheiro• Compilar o código em linha de comando
• Usar o “comando” javac• $> javac App.java
• Verificar que foi criado o ficheiro App.class• Testar o
código
• $> java App
-
11
AnAnáálise do lise do ““HelloHello WorldWorld””
22
O O HelloHello WorldWorld
public class App {
public static void main(String[] args) {
System.out.println("Hello World");
}
}
• Componentes do “Hello world”• Declaração da classe (class)•
método main• Classe String• System.out.println• Modificador de
acesso public• Modificador static
-
12
23
ClassClass
• O formato mais simples para definir uma classe é este:[] class
{
}
• No caso do exemplo “Hello World”:• Nomeclass é o nome que
quiser, tendo em atenção que:
• Deve ter o mesmo nome que o ficheiro onde está• É sensivel à
capitulação dos caracteres
• A visibilidade tem de ser public para ser visível do
exterior
24
MMéétodotodo
• Os métodos são funções ou procedimentos membros de uma dada
classe que permitem manusear o objecto
• Um caso especial dos métodos é o método public static void
main (String[] argv).
• Por se chamar main, ser estático (static) e público (public)
éinvocado sempre que se carrega a classe (programa standalone)
• $> java App
-
13
25
Classe StringClasse String
• A classe String • É uma classe do ‘core’ do Java• Está
definida na API• Está incluída na package
java.lang
• Como o próprio nome indica fornece um conjunto de métodos para
trabalhar com cadeias de caracteres
26
System.out.printlnSystem.out.println
• A classe System está definida na package java.lang
• Tem uma variável membro outdo tipo PrintStream
• out é o standard output e estáaberto e pronto a receber
caracteres
-
14
27
System.out.printlnSystem.out.println
• System.out• É uma instância /objecto da
classe java.io.PrintStream• A classe PrintStream está
definida na package java.io• Tem um método membro
println(String)
28
Modificador publicModificador public
• public é um modificador de acesso (visibilidade )• permite que
a classe App esteja acessível de fora da
package (neste caso o ficheiro)• Além da classe ser acessível
também é preciso dar
acessibilidade pública ao método main para poder ser invocado a
partir do exterior da package
-
15
29
Modificador staticModificador static
• O modificar static permite que o método main seja invocado sem
haver ainda qualquer instância da classe jácriada
• Aplica-se à classe e não a um objecto em particular
A linguagem JavaA linguagem Java
-
16
31
Componentes da Linguagem JavaComponentes da Linguagem Java
[]*
*****
**
**
32
Java KeywordsJava Keywords
volatilewhile
voidtrythrowsthrowthis
synchronisedswitchsuperstaticshort
returnpublicprotectedprivatepackage
nullnewnativelonginterface
intinstanceofimportimplementsif
gotoforfloatfinallyfinal
extendselsedoubledodefault
Continueconstclasscharcatch
casebytebreakbooleanabstract
-
17
ClassClass
34
ClassClass
• A declaração de uma classe é a principal declaração em
JAVA
• Em Java tudo é implementado em Classes• Uma classe é uma
colecção de dados e/ou código que
define intrinsecamente as características e comportamento de um
certo conjunto de objectos.
• Uma classe está para os objectos como um esquema electrónico
está para um equipamento fabricado em série.
-
18
35
ClassClass
• A declaração de uma classe define um novo tipo e descreve as
suas características e comportamento.
• O formato mínimo para declarar uma classe deve obedecer à
seguinte regra
* class {
*
}
• Por convenção o nome da classe () deve começar por uma
maiúscula
36
Ex1\Ex0.javapublic class Ex0 {
public static void main(String[] args) {A a = new A();B b = new
B();System.out.println(a.j);System.out.println(b.j);
}}
ClassClassEx1\A.javaclass A {
int j = 6;}class B {
int j = 66;}
Membros das Classes
-
19
Membros da ClasseMembros da Classe
38
Membros da ClasseMembros da Classe
• Uma classe é composta por:• Campos• Métodos• Classes •
Interfaces• Inicializadores
• Os campos são:• Variáveis de tipos primitivos• Ou referências
para objectos
-
20
39
Tipos PrimitivosTipos Primitivos
• Estes são os tipos primitivos do Java. Tudo o resto são
referências
• Inteiros• byte (1 byte, -128 to 127)• short (2 bytes)• int (4
bytes)• long (8 bytes)
• Vírgula flutuante• float (4 bytes, 6-7 significant decimal
digits)• double (8 bytes, 15 significant decimal digits)
40
Tipos Primitivos (2)Tipos Primitivos (2)
• char (2 byte, Unicode) (ASCII 1 byte)• boolean (true or
false)
• Não se pode converter booleanos em inteiros e vice-versa
-
21
41
MMéétodostodos
• Os métodos são funções ou procedimentos membros da classe
• A declaração dos métodos obedece a esta regra* (Arg*){
}
• No caso dos construtores a regra muda para:* (Arg*){
}
• O modificador pode assumir vários valores
42
MMéétodos todos –– ExemploExemploEx2\Counter.javapublic class
Counter {
int n = 0; //campo membro//método membro estáticopublic static
void main(String[] argv) {
Counter c = new Counter();c.print();mark("v = " +
c.n);c.go(5);mark("v = " + c.inc());c.go(7);
}//método membro que retorna um intint inc(){
return n++;}
Continua
-
22
43
Ex2\Counter.java (cont.)//método membro estáticostatic void mark
(String s){
System.out.println(s);}//método membrovoid print (){
System.out.println ("Counter = " + n);}//método membrovoid go
(int k){
while (k-- > 0){inc();print();
}}
}
MMéétodos todos –– Exemplo (2)Exemplo (2)
44
Operador de acesso aos membrosOperador de acesso aos membros
• O acesso aos membros da classe é feito com o operador “.”.
• Acesso aos métodos membroc.print();
• Acesso aos campos membroc.n
• Dentro de um método (não static) o nome da instância está
implícito e como tal é desnecessário
int inc(){return n++;
}
-
23
45
ConstrutorConstrutor
• Dentro dos métodos há uma situação particular designada por
Constructor
• Os construtores são métodos mas com algumas particularidades•
Têm o mesmo nome da classe e não têm um tipo definido
explicitamente• São invocados quando se instancia um novo
objecto (com o
operador new)• Não podem ser invocados explicitamente com o
operador “.”
• Racional para isto:• Se o objecto ainda não foi criado não se
pode invocar métodos sobre o
mesmo• Se já foi criado então não faz sentido cria-lo
novamente
46
Construtor Construtor –– ExemploExemploEx3\Counter2.javapublic
class Counter2 {
int n = 0;Counter2 (int x){
n = x;}public static void main(String[] argv) {
Counter2 c = new Counter2(5);mark("v = " + c.n);c.inc();mark("v
= " + c.n);
}int inc(){ return n++;}static void mark(String s){
System.out.println(s);}void print(){System.out.println("Counter = "
+ n);}
}
-
24
47
MMéétodos especiaistodos especiais
• Há dois métodos que têm um tratamento especial derivado do seu
nome• O método public static main (String[] argv)
• Se declarado dentro de uma classe publica é o primeiro a ser
invocado quando se carrega a classe
• $> java Counter2• O método protected void finalize()
• É invocado pelo sistema quando este detecta que o objecto já
não éusado
• Não é garantida a ordem de invocação deste método
48
MMéétodos especiais (por conventodos especiais (por
convençção)ão)
• Convencionou-se que as seguintes regras de atribuição de nome
aos métodos traduzem acções bem definidas• Métodos de atribuição de
valores
void setQualquerCoisa(tipo1){
variavelQualquerCoisa = arg1;
}
• Métodos de inspecção de valorestipo1 getQualquerCoisa(){
return variavelQualquerCoisa;
}
-
25
Classe vs. ObjectoClasse vs. Objecto
50
Classe vs. ObjectoClasse vs. Objecto
• Um objecto é uma instância de uma classe• Num programa em Java
cada classe é única mas pode
haver (e normalmente há) vários objectos da mesma classe• A
classe define as características e o comportamento do
conjunto de objectos do seu tipo
-
26
51
Classe vs. Objecto (2)Classe vs. Objecto (2)
• Em Java não há variáveis-objecto.• Todas as variáveis de algum
tipo não primitivo são na
realidade referências para o objecto e não o objecto em si
mesmo
ClasseT a = new ClasseT;
• Consequências A atribuição não copia o objectoClasseT b =
a;
• Algumas análogias• Esquema electrónico Equipamento produzido•
Planta Habitações (iguais) construídas
HeranHeranççaa
-
27
53
HeranHeranççaa
• A herança é uma técnica para derivar novas classes a partir de
classes já existentes
• As novas classes assim criadas são chamadas subclasses e
herdam das superclasses
• A subclasse herda os membros da superclasse e pode:•
Acrescentar mais membros• Redefinir os métodos da superclasse
(sobreposição)
54
HeranHerançça (2)a (2)
• Um objecto do tipo de uma subclasse é automaticamente também
do tipo da superclasse• O inverso é falso• Os objectos instanciados
da subclasse formam um subconjunto dos
objectos da superclasse
• O formato base para declarar uma subclasse é este
* class extends {
*
}
-
28
55
Ex4\Comp.java
class Storage{private int cap;void setCap(int c){cap = c;};int
getCap(){return cap;}int getCar(){return 0;}
}//Disco é uma subclasse de Storageclass Disco extends
Storage{
private int rpm = 7800;int getCar(){return rpm;}//sobreposição
do método
}//Memoria é uma subclasse de Storageclass Memoria extends
Storage{
private int vel = 233;int getCar(){return vel;}// sobreposição
do métodoint getDataWidth(){return 64;}
}
Continua
HeranHerançça a –– ExemploExemplo
56
HeranHerançça a –– Exemplo (2)Exemplo (2)Ex4\Comp.java
(cont.)public class Comp{
static public void main(String[] s){Disco d = new
Disco();Memoria m = new Memoria();d.setCap(80); //setCap é membro
de Disco por herançam.setCap(512);System.out.println("ds = " +
d.getCap());//Chama o membro getCar() de Disco porque foi
sobreposto //nesta classe ao getCar() de
StorageSystem.out.println("r = " +
d.getCar());System.out.println("ms = " +
m.getCap());System.out.println("v = " +
m.getCar());System.out.println(“dw = " + m.getDataWidth());
}}
$>java Compds = 80r = 7800ms = 512v = 233dw = 64
-
29
PolimorfismoPolimorfismo
58
PolimorfismoPolimorfismo
• Um nome, várias formas. • Em Java o polimorfismo manifesta-se
na forma de
múltiplos métodos (diferentes implementações) com o mesmo
nome.
• Dois tipos• Polimorfismo por sobrecarga de métodos: múltiplos
métodos com
o mesmo nome mas diferentes listas de parâmetros.• Polimorfismo
por sobreposição de métodos: múltiplos métodos
com o mesmo nome, a mesma lista de parâmetros e devolvem o mesmo
tipo.
-
30
59
SobrecargaSobrecarga
• Os métodos são identificados pelo seu nome e pela sua
assinatura• A assinatura é a combinação do tipo de argumentos com o
seu
número e a sua ordem• Algumas assinaturas possíveis para o
método estenome
• void estenome (String s)• void estenome (int n) • void
estenome (Strint s, int n)• void estenome (int n, String s)• void
estenome ()
• A sobrecarga de um método é feita definindo um outro método
com o mesmo nome mas com assinatura distinta
60
Sobrecarga Sobrecarga –– ExemploExemploEx11\comp.javapublic
class Comp{
private int n;private String nome;/** A sobrecarga também se
aplica aos Construtores./* Por omissão o Java fornece um construtor
nulo se não houver qualquer construtor /* definido. No entanto, se
isso acontecer e quisermos continuar a ter um construtor /* nulo,
temos de o definirpublic Comp(){}public Comp(String s){nome =
s;}public Comp(String s, int x){nome = s; n = x;}public Comp(int
x){n = x; nome ="";}public void setCaract(String s){nome =
s;}public void setCaract(String s,int x){nome = s; n = x;}public
void setCaract(int x){n = x;}static public void main(String[]
s){
Comp c0 = new Comp();Comp c1 = new Comp(5);Comp c2 = new
Comp("garfield");Comp c3 = new
Comp("snoopy",6);c0.setCaract(3);c0.setCaract("alf",3);c1.setCaract("bunny");
}}
-
31
61
SobreposiSobreposiççãoão
• Quando a superclasse e a subclasse implementam um método com o
mesmo nome e a mesma assinatura.
• Com a sobreposição, a escolha do método a executar baseia-se
no tipo do objecto cuja referência está guardada na variável de
referência e não no tipo da variável de referência através da qual
o método é invocado.
• Ao contrário da sobrecarga, onde a decisão do método a invocar
é feita durante a compilação, na sobreposição a decisão só pode ser
feita em run-time (late binding ou Dynamic Bind).
62
SobreposiSobreposiççãoão
• Permite que os métodos de objectos de subclasses diferentes
com uma superclasse comum sejam uniformemente invocados
• resultando na invocação de diferentes métodos de acordo com a
sua subclasse de forma transparente para o programador e para o
compilador
• Permite o uso do mesmo código para manipular dados cujo tipo
(subclasse) ainda não é conhecido
-
32
63
SobreposiSobreposiçção ão –– ExemploExemploEx5\Comp.javaclass
Storage{
private int cap;void setCap(int c){cap = c;};int getCap(){return
cap;}int getCar(){return 0;}String getCarUnits(){return
"desconhecidas";}
}class Disco extends Storage{
private int rpm = 7800;//métodos sobrepostosint getCar(){return
rpm;}String getCarUnits(){return "Rpm";}
}class Memoria extends Storage{
private int vel = 233;int getDataWidth(){return 64;}//métodos
sobrepostosint getCar(){return vel;}String getCarUnits(){return
"Mhz";}
}Continua
64
SobreposiSobreposiçção ão –– Exemplo (2)Exemplo (2)Ex5\Comp.java
(cont.)public class Comp{
static public void main(String[] s){Storage s0 = new
Disco();Storage s1 = new
Memoria();s0.setCap(80);s1.setCap(512);System.out.println("ds = " +
s0.getCap());System.out.print("r = " +
s0.getCar());System.out.println(" " +
s0.getCarUnits());System.out.println("ms = " +
s1.getCap());System.out.print("v = " +
s1.getCar());System.out.println(" " +
s1.getCarUnits());//System.out.println("dw = " +
s1.getDataWidth());/**Erro! s1 é do tipo Storage e esta classe não
*define qualquer membro getDataWidth()System.out.println("dw = " +
((Memoria)s1).getDataWidth());//OK: foi feito o downcasting da
referência para o tipo Memoria
}}$>java Compds = 80r = 7800 Rpmms = 512v = 233 Mhzdw =
64
-
33
PackagePackage
66
PackagePackage
• Cada classe em Java é compilada para um ficheiro distinto
mesmo que tenha sido definida no mesmo ficheiro• Ex.: no exemplo
anterior (ficheiro fonte Comp.java) a
compilação produziu os seguintes ficheiros
• Um só ficheiro .java, mas um ficheiro .class por cada classe
definida
$>dir01-09-2003 13:45 1.140 Comp.class01-09-2003 13:45 1.348
Comp.java01-09-2003 13:45 454 Disco.class01-09-2003 13:45 532
Memoria.class01-09-2003 13:45 621 Storage.class
-
34
67
PackagePackage
• Cada classe pública precisa de ser definida num ficheiro
independente
• Se várias classes públicas precisarem de partilhar entre si
determinadas características o elemento de armazenamento (isto é, o
ficheiro), não é uma solução
• Para atender a essa funcionalidade existe, em Java, o conceito
de Package• Várias classes podem pertencer à mesma package se antes
da
declaração de classe incluírem a identificação da packagepackage
;
68
PackagePackage (2)(2)
• As packages tem uma estrutura hierárquica e reflectem uma
árvore de directórios onde as classes são armazenadas
• Para se usar uma classe de uma package énecessário
importá-la
• Alternativamente pode-se usar o nome completo da classe
(qualified name)
-
35
69
PackagePackage (3)(3)
• A ordem de declaração tem de obedecer a esta regraPackage
[Import ]
Classe* | Interfaces*
• Qualquer classe (ou interface) declarada sem package pertence
a uma package especial designada por “unnamed”
• O import vai buscar as classes a partir das
subdirectóriasdefinidos em CLASSPATH
70
PackagePackage ––
ExemploExemploEx6\info\componentes\abstractos\Storage.javapackage
info.componentes.abstractos;public class Storage{
private int cap = 16;public void setCap(int c){cap = c;};public
int getCap(){return cap;}public int getCar(){return 0;}public
String getCarUnits(){return "desconhecidas";}
}
info\componentes\Disco.javapackage info.componentes;import
info.componentes.abstractos.Storage; //Só importa a classe
Storagepublic class Disco extends Storage {
private int rpm = 7800;public int getCar(){return rpm;} public
String getCarUnits(){return "Rpm";}
}info\componentes\Memoria.javapackage info.componentes;import
info.componentes.abstractos.*; //Importa tudo o que estiver
declarado nesta packagepublic class Memoria extends Storage {
private int vel = 233;public int getCar(){return vel;} public
int getDataWidth(){return 64;} public String getCarUnits(){return
"Mhz";}
}
-
36
71
PackagePackage –– Exemplo (2)Exemplo
(2)Ex6\info\Comp.java//declaração da packagepackage
info;//importação das classes definidas na subpackageimport
info.componentes.*;//declaração dos tipospublic class Comp{
private Disco d;private Memoria m;Comp(){
d = new Disco(); m = new Memoria();
}
//Esta classe não foi previamente importadapublic
info.componentes.abstractos.Storage getStor(){
return m;}public static void main(String[] s){
Comp c = new Comp();int cap =
c.getStor().getCap();System.out.println("capaciade (memoria) = " +
cap);
}}
Operador Operador thisthis
-
37
73
Operador Operador thisthis
• Refere-se ao próprio objecto • auto-referência
• Pode ser usada nos:• métodos não estáticos • Construtores
• Serve para aceder aos campos membros quando hávariáveis locais
ou argumentos com o mesmo nome
• Nos construtores serve ainda para invocar outros construtores
da mesma classe (polimorfismo)
74
Operador Operador thisthis ––
ExemploExemploEx16\Counter.javapublic class Counter{
private int n = 0;private String nome;public Counter(String
nome){
this.nome = nome; //Sem o this o campo nome ficava inacessível
por //causa do nome do argumento ser igual ao nome do campo
}public Counter(int n){
this.n = n;}public Counter(int n, String nome){
this(n); //chama o construtor Counter(int n)//O this(...) só
pode ser usado na 1ª instrução; e esta tem //de pertencer a um
construtor
//this(nome); //ERRO! só pode ser usado uma vezthis.nome =
nome;
}public Counter(){
this(100,"sem nome");}
Continua
-
38
75
Operador Operador thisthis –– Exemplo (2)Exemplo
(2)Ex16\Counter.java (cont.)
public void print(){// Aqui é desnecessário porque não há
qualquer outra variável com // o mesmo nomeSystem.out.println("n =
" + this.n);System.out.println("nome = " + this.nome);
}static public void main(String[] s){
Counter c0 = new Counter(), c1 = new Counter(20); Counter c2 =
new Counter("C2");Counter c3 = new Counter(50,"C3");c0.print();
c1.print(); c2.print(); c3.print();
}}
Operador superOperador super
-
39
77
Operador superOperador super
• Refere-se à superclasse• É uma referência para os membros da
superclasse do
objecto• Serve para aceder aos membros da superclass quando
há
sobreposição (nos campos e nos métodos) • Nos construtores serve
ainda para seleccionar e invocar os
construtores da superclasse
78
Operador super Operador super –– Exemplo Exemplo
Ex17\Counter.javapublic class Counter{
private int n = 0;protected String nome;public Counter(String
nome){this.nome = nome;}public Counter(int n){this.n = n;}public
Counter(int n, String nome){
this(n);this.nome = nome;
}public Counter(){}public void inc(){++n;}public int
getVal(){return n;}public void reset(){n = 0;}
}
-
40
79
Operador super Operador super –– Exemplo (2) Exemplo (2)
Ex17\ModCounter.javapublic class ModCounter extends Counter {
public int n;public void inc(){
super.inc(); // acede/invoca o inc de Counterif (getVal() >
n){reset();}
}ModCounter(String nome, int i, int n){
//chama o construtor Counter(int,String)super(i,nome); //O
super(...) só pode ser usado na 1ª instrução; e esta
//tem de pertencer a um construtorthis.n = n;
}ModCounter(int n){
this.n = n;}
}
ModificadoresModificadores
-
41
81
ModificadoresModificadores
• Um modificador é uma keyword que afecta o tempo de vida
(lifetime) ou a acessibilidade de uma classe, variável ou
método.
Modificadores de acessoModificadores de acesso
-
42
83
Modificadores de acessoModificadores de acesso
• public, protected e private• Recorrendo aos modificadores de
acesso é possível
controlar quem tem acesso a uma classe ou aos respectivos
membros.
• Este modificadores são mutuamente exclusivos• É desejável e
aconselhável que o acesso se restrinja apenas
ao necessário
84
Modificadores de acesso Modificadores de acesso ––
ClassesClasses
• Uma classe declarada sem package que não tenha modificador de
acesso () fica acessível apenas pelas classes também elas
declaradas sem package.
• Só pode haver uma classe pública por ficheiro.
Universo – classes de todas as packages
Classes na mesma package
Quem tem acesso
public
Modificador
-
43
85
Modificadores de acesso Modificadores de acesso ––
MembrosMembros
• O controlo de acesso dos membros funciona como um
encapsulamento, onde é possível controlar que membros estão
acessíveis/visíveis para o exterior da classe• Cada classe deve
declarar privado/protegido o que não precisa de
ser visto pelo exterior• Do exterior só deve ser visível o
estritamente necessário,
escondendo os pormenores de implementação
86
Modificadores de acesso Modificadores de acesso ––
MembrosMembros
• Uma classe pode ter como membros• Campo• Método• Classe•
Interface
• No caso de uma classe ou interface estas são consideradas
inner class e inner interface respectivamente.
• Os modificadores aplicam-se à inner class ou innerinterface da
mesma forma que se aplicam a qualquer outro membro.
-
44
87
Modificadores de acesso Modificadores de acesso ––
MembrosMembros
Só dentro da própria classe
Subclasses e classes na mesma package
Universo – classes de todas as packages
Classes na mesma package
Quem tem acesso
protected
private
public
Modificador
88
Modificadores de acesso Modificadores de acesso ––
ExemploExemploEx7\info\componentes\abstractos\Storage.javapackage
info.componentes.abstractos;public class Storage{
int cap = 16;public int base = 2;protected String origem =
"Portugal";public void setCap(int c){cap = c;}public int
getCap(){return cap;}int getCar(){return 0;}public String
getCarUnits(){return "desconhecidas";}
}Ex7\info\componentes\Memoria.javapackage
info.componentes;import info.componentes.abstractos.*; public class
Memoria extends Storage {
private int vel = 233;int getCar(){return vel;} public int
getDataWidth(){return 64;} public String getCarUnits(){return
"Mhz";}public String getOrigem(){return origem;} //tem acesso a
origem por herança
}
-
45
89
Modificadores de acesso Modificadores de acesso –– Exemplo
(2)Exemplo (2)Ex7\info\componentes\Teste.javapackage
info.componentes;import info.componentes.abstractos.*;public class
Teste{
static public void main(String[] args){Storage s = new
Storage();Memoria m = new Memoria();
System.out.println("s.base:
"+s.base);//System.out.println(s.cap);
//Erro: cap não apresenta modificador de acesso
()//System.out.println(s.origem);
//Erro: origem é um campo protegido de
StorageSystem.out.println("m.getOrigem(): "+m.getOrigem());
//OK: Memoria tem acesso ao campo origem porque é//uma subclasse
de Storage
//System.out.println(m.vel); //Erro: vel é um campo privado de
Memoria
System.out.println("getCar(): "+m.getCar()); //OK: o método
getcar está acessível às classes da mesma package
}}
Modificador Modificador staticstatic
-
46
91
Modificador Modificador staticstatic
• Só se aplica aos membros da classe• Permite que o método/campo
seja invocado/acedido sem
haver qualquer instância criada do objecto• Aplica-se à classe e
não a um objecto em particular• Dito de outro modo, aplica-se às
características comuns ao
conjunto de objectos deste tipo, presentes ou futuros.• Um
membro estático é partilhado por todos os objectos
92
Modificador Modificador staticstatic –– Exemplo 1Exemplo
1Ex10\Comp3.javapublic class Comp3 {
private int n;static private int ncomp = 0;public Comp3(){
n = ++ncomp;}static public int getNumOfInstances(){
//isto produz um erro de compilação//return n;return ncomp;
//OK: ncom é um campo estático
}public int getInstanceNumber(){return n;}public String
getInstancesRel(){
String s = "Instance " + n + " of "+ ncomp + " Instances";//OK!
Os membros não estáticos podem aceder a membros estáticosreturn
s;
}}
-
47
93
Modificador Modificador staticstatic –– Exemplo 1 (2)Exemplo 1
(2)Ex10\Test3.javapublic class Test3 {
private static Comp3 c0, c1, c2;public static void
showAndCreate(Comp3 c){
int n = Comp3.getNumOfInstances();print("N Of I (antes) = " +
n);c = new Comp3();//int i = Comp3.getInstanceNumber();//Erro: Um
método não estático só pode ser invocado para um objectoint i =
c.getInstanceNumber();//int n = c.getNumOfInstances;//Erro: Um
método estático só pode ser invocado para uma Classprint("Instance
Number = " + i);print(c.getInstancesRel());
}public static void main(String[] args) {
showAndCreate(c0); showAndCreate(c1);showAndCreate(c2);
}private static void print(String s){
System.out.println(s);}
}
94
Modificador Modificador staticstatic –– Exemplo 2Exemplo
2Ex10a\Comp3.javapublic class Comp{
private int n;static private int ncomp = 0;public Comp(){n =
++ncomp;}public static void main(String[] s){
Comp c1 = new Comp();c1.printn("c1."); c1.printncomp("c1.");Comp
c2 = new Comp();c2.printn("c2.");
c2.printncomp("c2.");c1.printn("c1.");c1.printncomp("c1.");
}void printn(String s){System.out.println(s + "n = " + n);}void
printncomp(String s){
System.out.println(s + "ncomp = " + ncomp);}
} //O campo ncomp é partilhado por c1 e c2. Se c2 alterar ncomp
essa alteração reflecte-se em c1$>java Compc1.n = 1c1.ncomp =
1c2.n = 2c2.ncomp = 2c1.n = 1c1.ncomp = 2
-
48
Modificador finalModificador final
96
Modificador final Modificador final
• Quando usado na declaração da classe esta não pode ser
derivada (superclasse)
• Quando usado num método este não pode ser sobreposto• Usado da
declaração de um campo este não pode ser
actualizado (mas deve ser inicializado)• Usando em conjunto com
o static serve para implementar
constantes
-
49
97
Modificador final Modificador final –– Exemplo Exemplo
Ex18\Counter.javafinal public class Counter{
private int n = 0;final protected String nome; //o campo nome
tem de ser inicializado no construtorfinal protected String ID =
"a0"; //inicialização do campovoid serveParaNada(String lixo){
//nome = lixo; //um campo final não pode ser alterado//ID =
lixo; //a atribuição a um campo final dá sempre erro
}public Counter(int n){
this.n = n;/* dentro do construtor a inicialização é possível e,
* no caso do nome, necessária*/nome = "sem nome";//ID = "zero"; //
Erro: ID já foi inicializado
}public Counter(int n, String nome){
this(n); //chamado outro construtor//this.nome = nome; //Erro:
nome já foi inicializado
}final public void inc(){++n;} //não pode ser sobreposto
}
98
Modificador final Modificador final –– Exemplo (2) Exemplo (2)
Ex18\ModCounter.javafinal public class ModCounter extends Counter
{
public int n;//public void inc(){}//ERRO! o inc é um método
final em CounterModCounter(String nome, int i, int n){
super(i,nome);this.n = n;
}ModCounter(int n){
super(0);this.n = n;
}}//class ExtModCounter extends ModCounter{}//Erro: ModCounter é
final
-
50
Modificador Modificador abstractabstract
100
Modificador Modificador abstractabstract
• Permite indicar que uma classe não foi totalmente
implementada.
• Quando usado na declaração da classe esta não pode ser
instanciada• Uma classe abstract não tem instâncias (objectos)• Uma
classe abstract tem de ser derivada
• Quando usado num método este tem de ser obrigatoriamente
sobreposto na subclasse• Não tem corpo• Só existe a sua declaração•
A implementação é deixada para a subclasse• Implica que a classe
também seja declarada como abstract
-
51
101
Modificador Modificador abstractabstract ––
ExemploExemploEx19\Counter.javaabstract public class Counter{
protected int c = 0;final protected String nome;public
Counter(int n){
c = n;nome = "";
}public Counter(int n, String nome){
c = n;this.nome = nome;
}abstract public void inc(); //inc() não tem corpopublic int
getVal(){return c;}
}
102
Ex19\ModCounter.javaabstract class AbsModCounter extends Counter
{
public int n;//public void inc(){} //não precisa de ser
implementada nesta classeAbsModCounter(String nome, int i, int
n){super(i,nome);this.n = n;
}}public class ModCounter extends AbsModCounter{
//nesta class é obrigatorio implementar o método inc()public
void inc(){c = ++c % n; }public ModCounter(String nome, int i, int
n){super(nome,i,n);}public static void main(){Counter c;//c = new
Counter(0,"teste"); //Erro: Counter é abstract//c = new
AbsMoCounter("teste",0,16); //Erroc = new
ModCounter("teste",0,16);c.inc();System.out.println("c = " +
c.getVal());
}}
Modificador Modificador abstractabstract –– Exemplo (2)Exemplo
(2)
-
52
InicializaInicializaççãoão dos Camposdos Campos
104
InicializaInicializaççãoão
• A inicialização dos campos membro pode ser feita de 4 modos:•
Omissão• Explícita• Blocos de inicialização• Construtor
-
53
105
InicializaInicializaççãoão
• Inicialização por omissão• Declarando apenas as variáveis
estas são inicializadas pelo java de
acordo com a tabela anexa
Valor inicialTipo
nullreferência
falsebooleano
0númerico
106
InicializaInicializaççãoão
• Explícita• Ao declarar o campo atribui-se-lhe um valor fixo ou
o resultado de
uma expressão
• Blocos de inicialização• O Java permite definir blocos de
código como membros da classe.
Estes blocos são executados quando:• a classe é carregada
(blocos estáticos)• o objecto é criado (blocos não estáticos)
• Construtor • A inicialização é feita no corpo do
construtor
-
54
107
InicializaInicializaçção omissa ão omissa –– ExemploExemplo
$>java Compncomp = 0n = 0nome = nullactivo = false
Ex12\Comp.javapublic class Comp{
private int n;private String nome;static private int
ncomp;private boolean activo;static public void main(String[]
s){
System.out.println("ncomp = " + ncomp);Comp c = new
Comp();System.out.println("n = " + c.n);System.out.println("nome =
" + c.nome);System.out.println("activo = " + c.activo);
}}
108
Ex14\Comp.javapublic class Comp{
//pode ser o valor de um método membro estáticoprivate int n =
initN();//pode ser uma constanteprivate String nome = "madrinha
precisa-se";//pode ser uma expressãostatic private int ncomp = 100
* 2;static private int initN(){
return ++ncomp;}static public void main(String[] s){
System.out.println("ncomp = " + ncomp);Comp c = new
Comp();System.out.println("n = " + c.n);System.out.println("nome =
" + c.nome);
}}
InicializaInicializaçção explicita ão explicita ––
ExemploExemplo
-
55
109
Ex13\Comp.javapublic class Comp{
private int n;private String nome;{//bloco de inicialização para
cada objecto
nome = "madrinha precisa-se";n = initN(); /* A inicialização
pode ser feita recorrendo a * métodos membro mas estes têm de ser
estáticos*/
}static private int ncomp;static private int initN(){return
++ncomp;}static { //bloco de inicialização para a class
ncomp = 100;}static public void main(String[] s){
System.out.println("ncomp = " + ncomp);Comp c = new
Comp();System.out.println("n = " + c.n);System.out.println("nome =
" + c.nome);
}}
InicializaInicializaçção por bloco ão por bloco ––
ExemploExemplo
110
Ex15\comp.javapublic class Comp{
private int n;private String nome;static private int
ncomp;public Comp(int x){
n = x;nome = "Madrinha precisa-se";
}static public void main(String[] s){
System.out.println("ncomp = " + ncomp);Comp c = new
Comp(5);System.out.println("n = " + c.n);System.out.println("nome =
" + c.nome);
}}
InicializaInicializaçção por Construtor ão por Construtor ––
ExemploExemplo
-
56
InterfacesInterfaces
112
InterfacesInterfaces
• Uma interface é um conjunto de requisitos para as classes que
quiserem ser conformes
• Uma interfaces consiste numa colecção de constantes e
declarações de métodos com as respectivas assinaturas• Os métodos
não têm corpo (são apenas declarados mas não
implementados)
• As interfaces fornecem um mecanismo para impor à(s) classe(s)
determinados métodos.• Assegura que os objectos disponibilizam
certos métodos sem
impor à partida qual a acção resultante
-
57
113
Interfaces (2)Interfaces (2)
• As interfaces são similares às classes mas:• Os campos são
sempre public static final
• Na declaração dos campos pode-se omitir estes modificadores•
Obriga à inicialização explicita
• Os métodos são sempre public abstract• Na declaração dos
métodos pode-se omitir estes modificadores
• Uma interface nunca tem instâncias (tal como uma classe
abstracta)
• Uma interface não tem construtores
114
Interfaces (3)Interfaces (3)
• A declaração de um interface obedece a esta regra:* interface
{
[public final satic] *
[public abstract] *
}
• Uma interface também pode herdar de outra interface:*
interface [extends]{
[public final static] *
[public abstract] *
}
-
58
115
Interfaces Interfaces –– ExemploExemploEx20\SO.javapublic
interface SO{
String getName(); //os métodos são sempre public abstractString
getVersion(); //Não tem corpo//String getVersion2(){}; //Erro: os
métodos são abstractos//SO(){} //Erro: as interfaces não tem
construtoresString WIN = "Windows"; //os campos são sempre public
static finalString UNIX = "Unix"; //logo tem de ser inicialização
explicita
}
Ex20\Unix.java//uma interface pode herdar de outrapublic
interface Unix extends SO {
String LINUX = "Linux";String HPUX = "HP-UX";String AIX =
"AIX";String getVariante();
}
116
Interfaces (4)Interfaces (4)
• Uma interface é implementada numa ou mais classes• Uma classe,
não abstracta, que implemente uma interface
tem sempre de implementar todos os métodos da interface• A
declaração de implementação de uma interface é feita na
declaração da classe
* class [extends ] implements , InterfaceName2,... {
*
}
-
59
117
Interfaces Interfaces –– Exemplo (2)Exemplo
(2)Ex20\Windows.javapublic class Windows implements SO {
private final String version;public String getName() {return
WIN;}public String getVersion() {return version;}Windows(String
v){version = v;}
}
Ex20\Dist.javapublic interface Dist {
String REDHAT = "RedHat";String MANDRAKE = "Mandrake";String
getDist();
}Ex20\Linux.java//Como a classe é abstracta, pode mas não
precisa de implementar os métodos das interfacesabstract public
class Linux implements Unix, Dist{
protected final String kernelversion;Linux(String
k){kernelversion = k;}// dois métodos implementados. Um de Unix e
outro de SOpublic String getName(){return UNIX;}public String
getVariante(){return LINUX;}// As subclasses já só precisam de
implementar os restantes métodos
}
118
Ex20\Mandrake.javapublic class Mandrake extends Linux {
private final String version;public String getVersion(){
return "dv = "+version+"\nkv = "+kernelversion;}Mandrake(String
v, String kv){
super(kv);version = v;
}public String getDist(){return MANDRAKE;}
}
Interfaces Interfaces –– Exemplo (3)Exemplo (3)
• A class Mandrake implementa implicitamente as interfaces Unix
e Dist, logo tem de implementar os métodos :
• getName() e getVersion() de SO;• getVariante() de Unix; •
getDist() de Dist;
• Visto que a superclasse Linux já implementou os métodos
getName() e getVariante() aqui é suficiente definir o getVersion()
e o getDist()
-
60
119
Ex20\Teste.javapublic class Teste {
static void print(String s){System.out.println(s);}static void
showSO(SO so){
print(so.getName());print(so.getVersion());
}static void showUnix(Unix u){
showSO(u);print(u.getVariante());
}static void showDist(Linux l){
showUnix(l);print(l.getDist());
}public static void main(String[] args) {
Mandrake m = new Mandrake("8.2","2.4");Windows w = new
Windows("XP");showDist(m);print("-----------");showSO(w);
}}
Interfaces Interfaces –– Teste do Exemplo Teste do Exemplo
$>java TesteUnixdv = 8.2kv =
2.4LinuxMandrake-----------WindowsXP
120
Interfaces (4)Interfaces (4)
• Em Java a herança múltipla é conseguida com o recurso a
interfaces public class Linux implements Unix, Dist
• Diferenças entre as interfaces e as classes abstractas• As
interfaces não podem ter:
• Métodos estáticos• Construtores• Os métodos não podem ter
implementação• Membros não públicos
• Um classe pode herdar de múltiplas interfaces mas não de
múltiplas classes abstractas
-
61
ExcepExcepççõesões
122
ExcepExcepççõesões
• As Excepções permitem definir o comportamento dos métodos em
circunstâncias excepcionais
• Ocorrendo uma excepção o código abandona o percurso normal do
método e salta para o código de tratamento da excepção
método(){
try{
código onde não ocorreu qualquer excepção
código onde ocorreu a excepção E
código que não chegou a ser corrido
}catch (Excepção E){
código que vai tratar a excepção E
}
}
-
62
123
ExcepExcepçções (2)ões (2)
• O segmento de código onde podem ocorrer excepções édelimitado
pela construção
try{código onde podem ocorrer excepções}
• Para apanhar as excepções usa-se a construçãocatch(Excepção
E){código para tratar a excepção}
• É possivel ter vários “catches” para tratar diferentes tipos
de Excepções
try{código onde ocorrem diversas excepções}
catch(Excepção E) {código para tratar a excepção}
catch(Excepção F) {código para tratar a excepção}
catch(Excepção G) {código para tratar a excepção}
finally{este código é executado sempre quer haja ou não
excepções}
124
ExcepExcepçções (3)ões (3)
• Após uma excepção os diversos “catchs” são percorridos por
ordem até ser encontrado um com uma excepção do tipo da
ocorrida
• Depois de encontrar o “catch” respectivo os restantes são
ignorados• Se F é uma subclasse de E então o “catch” do F deve ser
incluído
antes do “catch” de E• Uma instância de F é uma instância de E
logo ao passar pelo
“catch” E a condição é verificada e o código de E executado• Uma
técnica para evitar multiplos “catchs“ é colocar um “catch”
de uma superclasse de todas as possíveis excepções Perde-se o
tratamento especializado de cada excepção mas pode ser uma opção em
estágios preliminares de desenvolvimento
-
63
125
ExcepExcepçções (4)ões (4)
• O finally é opcional. • O código do finally é sempre
executado
• Mesmo que seja encontrado um return no código do try ou do
catch
126
UncheckedNão são verificadas pelo compilador A inexistência de
código de tratamento não gera erros na compilação
CheckedSão verificadas pelo compilador.A inexistência de código
de tratamento gera erros na compilação
Classes para excepClasses para excepççõesõesObject
Throwable
Error Exception
RuntimeException IOException
...
...
NullPointerException... SocketException
BindException
EOFException ...
...
-
64
127
ExcepExcepçções (4)ões (4)
• Uma excepção é gerada por disparo de um objecto
“throwable”
if (cond) throw new Exception()
• Uma excepção é sempre um objecto de uma subclasse da classe
throwable
• Normalmente da classe Exception ou das suas derivadas
128
ExcepExcepçções (5)ões (5)
• Na compilação as excepções dividem-se em dois tipos:•
Checked
• É verificado na compilação se há tratamento, ou redisparo
destas excepções
• Numa aplicação Java as excepções checked tem de ser sempre
tratadas
• Unchecked• Não é verificado pelo compilador. O que não implica
que em runtime
não seja possível dar lugar à paragem da aplicação
-
65
129
ExcepExcepçções ões –– Exemplo 1Exemplo
1Ex21\ModCounter.javapublic class ModCounter{
private int c = 0;private int n;public void inc(){c = ++c % n;
}public ModCounter(int i, int n){
try{if (i > n) throw new Exception(i + " > "+ n);if (i
< 0) throw new Exception(i + " < 0");c = i;this.n = n;
}catch(Exception e){
e.printStackTrace();}
}public int getVal(){return c;}public void setVal(int i) throws
Exception{
if (i > n) throw new Exception(i + " > " + n);c = i;
}}
130
ExcepExcepçções (6)ões (6)
• Um método no qual podem ocorrer excepções checked tem duas
opções• Ou faz o tratamento com try e catch• Ou redispara as
excepções, declarando no método quais as
Excepções que podem ocorrer (Args) throws
Exception1, Exception2,...{ ... }
• É da responsabilidade de quem chama o método fazer o
tratamento das excepções
• Um método pode tratar algumas excepções e (re)disparar outras
• Um “catch” pode redisparar a mesma excepção
-
66
131
ExcepExcepçções ões –– Exemplo 2Exemplo
2Ex22\ModCounter.javapublic class ModCounter{
private int c = 0;private int n;public void inc(){c = ++c % n;
}public ModCounter(int i, int n) throws InitException {
if (i > n) throw new InitException(i + " > " + n);if (i
< 0) throw new InitException(i + " < 0");c = i; this.n =
n;
}public int getVal(){return c;}public void setVal(int i) throws
ModException{
if (i > n) throw new ModException(i + " > " + n);c =
i;
}}
132
ExcepExcepçções ões –– Exemplo 2 (2)Exemplo 2
(2)Ex22\InitException.javapublic class InitException extends
Exception {
public final String s;public InitException(String a){
s = "Erro na inicialização:\n\t" + a;}
}
Ex22\ModException.javapublic class ModException extends
Exception {
public ModException(String s){super(s);}}
-
67
133
ExcepExcepçções ões –– Exemplo 2 (3)Exemplo 2
(3)Ex22\Teste.javaclass NegativeException extends ModException
{
NegativeException(String s){super(s);}String getMoreInfo(){
return "Erro:\n\tO argumento do setVal”+ “ tem de ser
positivo";}
}public class Teste{
static ModCounter c;static void setVal(int v) throws
ModException, NegativeException{
if (v < 0) throw new NegativeException( v + " <
0");c.setVal(v);
}public static void print(String s){
System.out.println(s);}public static void print(int n){
System.out.println(n);}
Continua
134
ExcepExcepçções ões –– Exemplo 2 (4)Exemplo 2 (4)Ex22\Teste.java
(cont.)
public static void main(String[] s){try{
c = new ModCounter(0,16);c = new ModCounter(20,16);//as linhas
que se seguem não serão processadas devido à//ocorrência de uma
excepção do tipo InitExceptionsetVal(7);
print(c.getVal());c.setVal(18); print(c.getVal());setVal(-10);
print(c.getVal());return;
}catch (NegativeException te){ // o Negative Exception tem de
surgir antes do ModException
print(te.getMoreInfo());}catch (ModException me){
print ("ERRO: " + me.getMessage()); //O getMessage é membro da
superclass Trowableme.printStackTrace(); //O printStackTrace é
membro da
}catch(InitException ie){ // superclass trowableprint(ie.s);
}finally{print("finally: Por aqui passo sempre, haja ou não
erro");}}
}
$>java TesteErro na inicialização:
20 > 16finally: Por aqui passo sempre,haja ou não erro
-
68
Classes do JavaClasses do Java
136
Classes do utilizador
Java APIClasses JavaClasses Java
Object
ThrowableString Class ... Number Math System
IntegerExcepion Character... ...
...
...
AppletServletSocket
PrinterWriter
Minhaclasse
InputStreamPrinterStream
Outraclasse
Subclasse1Subclasse2
Subclasse2
Qualquer classe é automaticamente subclasse de Object
...
-
69
137
API do JavaAPI do Java
Classes para acesso aos protocolos de redejava.net
Ver a API do JavaEtc…
GUI usando swingjavax.swing
ClassesPackage
Creates appletsjava.applet
GUIjava.awt
Entrada e Saída – acesso a ficheiros, etcjava.io
Matemáticasjava.math
Classes e Interfaces utilitáriasjava.util
Classes “core” do Javajava.lang
• A utilização de qualquer classe das packages obriga a utilizar
o import• No entanto a package java.lang não precisa de ser
explicitamente “importada”
138
API do JavaAPI do Java
• http://java.sun.com/j2se/1.4.2/docs/api/index.html
-
70
ArraysArrays
140
ArraysArrays
• Os arrays em Java são objectos mas são manipulados de forma
especial pelo programador
• Declaraçãoint v[];
Ouint[] v;
• Alocação de espaço (memória) v = new int[n];
• n não precisa de ser uma constante. Pode ser uma variável ou
uma expressão
• Ou numa só instruçãoint[] v = new int[n];
-
71
141
ArraysArrays –– ExemploExemplo
$>java Test primeiro argumento e, julgo eu, o segundo
argumentos[0]=primeiros[1]=argumentos[2]=e,s[3]=julgos[4]=eu,s[5]=os[6]=segundos[7]=argumento
Ex23\Test.javapublic class Test{
public static void main(String[] s){print(s);
}private static void print(String[] s){
for (int n = 0; n < s.length;
n++){System.out.println("s["+n+"]="+s[n]);
}}
}
142
ArraysArrays
• Inicializaçãov[2] = 3;
• Declaração, reserva de espaço e inicializaçãoint[] v =
{3,7,6,8};
• Podem ser multidimensionaisint[][] vv={{1,3},{7,4,5}};
int[][] vw= new int[5][3];
• Um arrays de arrays pode conter arrays de dimensão
diferente
• Pode-se declarar arrays de objectosObj[] ov = new Obj[4];
ov[2] = new Obj();
-
72
143
ArraysArrays –– Exemplo 2Exemplo 2
$>java Testv[1][2]=8v[1][1]=3v[1][0]=5v[0][1]=4v[0][0]=3
Ex24\Test.javapublic class Test{
public static void main(String[] s){int[][] v =
{{3,4},{5,3,8}};for(int n = v.length; n-- > 0;)
for(int k = v[n].length; k-- > 0;)print("v[" + n + "][" + k +
"]=" + v[n][k]);
}private static void print(String s){
System.out.println(s);}
}
144
ArraysArrays –– Exemplo 2Exemplo 2Ex25\Test.javaclass
MeuObjecto{
private int k;private int n;MeuObjecto(int a, int b){k = a; n =
b;}int getProd(){return n * k;}
}public class Test{
public static void main(String[] s){int n = 2, k =
3;MeuObjecto[][] mov = new MeuObjecto[n][k];while (n-- > 0){
int j = k;while(j-- > 0)
mov[n][j] = new MeuObjecto(n+1,j+1);}while(k-- > 0)
print(mov[1][k].getProd());
}private static void print(int i){
System.out.println(i);}
}
$>java Test642
-
73
145
ArraysArrays
• Os arrays são implementados internamente com objectos de uma
classe “built-in” (não listada na API Java)• São subclasses de
Object e herdam, naturalmente, todos os
membros deste• clone• equals• finalize• ...
• Adiciona aos métodos de Object o campo final length
StringsStrings
-
74
147
StringsStrings
• As Strings são objectos definidos na classe java.lang.String
mas tem algumas particularidades não partilhadas por outros
objectos• Podem ser inicializados sem recurso ao operador new
String s = “Esta é uma String”;
• Tem definida a operação de concatenação com o operador +String
s1 = s + “ concatenada”;
• Como objectos que são, as variáveis do tipo String são
referências• O teste s == s1 compara se s e s1 se referem ao mesmo
objecto e
não se as strings são iguais
Entrada/SaEntrada/Saíídada
-
75
149
Classe FileClasse File
• Usada para representar o sistema de ficheiros• É apenas uma
abstracção: a existência de um objecto File
não significa a existência de um ficheiro ou uma directoria.•
Contém métodos para testar a existência de ficheiros, para
definir permissões (nos S.O.s onde for aplicável), para apagar
ficheiros, criar directorias, listar o conteúdo de directorias,
etc..
150
Classe File (2)Classe File (2)
• Alguns métodos• String getAbsolutePath()• String getParent():
devolve a directoria (objecto File) superior• boolean exists()•
boolean isFile()• boolean isDirectory()• boolean delete(): tenta
apagar a directoria ou ficheiro• long length(): devolve o tamanho
do ficheiro em bytes• boolean mkdir(): cria uma directoria•
String[] list(): lista dos ficheiros contido na directoria
-
76
151
Classe File Classe File ––
ExemploExemploEx26\Fileteste.javaimport java.io.*;
public class FileTeste {public static void main(String[]
args){
try {File directoria = new File("teste");directoria.mkdir(); //
cria, se possívelFile ficheiro = new File(directoria,
"lixo.txt");FileOutputStream out= new FileOutputStream(ficheiro);//
se ficheiro não existe, tenta criar
out.write( new byte[]{'l','i','x','o'} ); //escrever uma
sequência de bytes
out.close();Continua
152
Classe File Classe File –– Exemplo (2)Exemplo
(2)Ex26\Fileteste.java (cont.)
File subdir = new File(directoria,
"subdir");subdir.mkdir();String[] ficheiros = directoria.list();for
(int i = 0; i
-
77
153
Fluxos de Entrada/SaFluxos de Entrada/Saíídada
• Um fluxo (stream) é um conceito abstracto. Representa uma
sequencia linear de bytes ou caracteres de uma entrada ou para uma
saída.
• Existem várias fontes de onde se deseja ler ou destinos para
onde se deseja escrever ou enviar dados• Ficheiros• Conexões de
rede• Consola (teclado / Monitor)• Memória
• Existem várias formas diferentes de ler/escrever dados•
Sequencialmente / aleatoriamente• Como bytes / como caracteres•
Linha por linha / palavra por palavra, ...
154
Classes e Interfaces para fluxos de E/SClasses e Interfaces para
fluxos de E/S
• A package java.io fornece objectos que abstraem•
fontes/destinos (nós) e fluxos de bytes e caracteres
• Dois grupos• orientado ao byte: InputStream e OutputStream•
orientado ao caractere (char): Reader e Writer
-
78
155
E/S E/S orientadaorientada aoao bytebyte
• InputStream• Classe abstracta para lidar com fluxos de bytes
de entrada e nós de
fonte (dados para leitura).• Método principal: read()
• OutputStream• Classe abstracta para lidar com fluxos de bytes
de saída e nós de
destino (dados para gravação).• Método principal: write()
156
E/S E/S orientadaorientada aoao byte (2)byte (2)
• Principais implementações• Entrada/leitura no nó fonte:
• FileInputStream (ficheiros), • ByteArrayInputStream (memória)
e • PipedInputStream (pipe).
• Entrada/tratamento de fluxo: • FilterInputStream (abstract) e
respectivas subclasses
• Saída/escrita no nó destino: • FileOutputStream (ficheiros), •
ByteArrayOutputStream (memória) e • PipedOutputStream (pipe).
• Saída/tratamento de fluxo: • FilterOutputStream (abstract) e
respectivas subclasses.
-
79
157
E/S E/S orientadaorientada aoao bytebyte ––
ExemploExemploEx27\FileCopia.javaimport java.io.*;//Esta aplicação
copia um ficheiro: fonte -> destinopublic class FileCopia {
public static void main(String[] args){if
(args.length>1){
try {String nomeFonte = args[0];String nomeDestino =
args[1];File fonte = new File(nomeFonte);File destino = new
File(nomeDestino);if (fonte.exists() && !destino.exists())
{
FileInputStream in = new FileInputStream(fonte);FileOutputStream
out = new FileOutputStream(destino);byte[] buffer = new byte[8192];
//array de bytesint length = in.read(buffer);while ( length != -1)
{ // -1 sinaliza o EOF//grava apenas os bytes lidos e não o buffer
completo
out.write(buffer, 0, length);length = in.read(buffer);
}Continua
158
E/S E/S orientadaorientada aoao bytebyte –– Exemplo (2)Exemplo
(2)Ex27\FileCopia.java (cont.)
in.close();out.flush();out.close();
}} catch (IOException e){System.exit(1);} //é necessário tratar
as excepções
} else {System.out.println("java FileCopia ffonte
fdestino");}}
}
-
80
159
FilterInputStreamFilterInputStream
• Recebe fonte de bytes e oferece métodos para ler dados
filtrados. Implementações (subclasses):• DataInputStream:
• readInt(), • readUTF(), • readDouble()
• BufferredInputStream: • read() mais eficiente
• ObjectInputStream: • readObject() lê objectos serializados
160
FilterOutputStreamFilterOutputStream
• Recebe destino de bytes e escreve dados via filtro.
Implementações:• DataOutputStream:
• writeUTF(), • writeInt(), etc.
• BufferedOutputStream: • write() mais eficiente
• ObjectOutputStream: • writeObject() serializa objectos
• PrintStream: • classe que implementa println()
-
81
161
E/S orientada ao caractereE/S orientada ao caractere
• Reader• Classe abstracta para lidar com fluxos de caracteres
de entrada:
método read() lê um caractere (16 bits) de cada vez.
• Writer• Classe abstracta para lidar com fluxos de caracteres
de saída:
método write() grava um caractere de cada vez.
162
E/S orientada ao caractere (2)E/S orientada ao caractere (2)
• Principais implementações• Entrada/leitura no nó fonte:
• FileReader (ficheiro), • CharArrayReader (memória), •
PipedReader (pipe) e • StringReader (memória).
• Entrada/tratamento de fluxo: • FilterReader (abstract), •
BufferedReader, • InputStreamReader (conversor de byte para char),
• LineNumberReader
-
82
163
E/S orientada ao caractere (3)E/S orientada ao caractere (3)
• Principais implementações (cont.)• Saída/escrita no nó
destino:
• FileWriter (ficheiro), • CharArrayWriter (memória), •
PipedWriter (pipe) e • StringWriter (memória).
• Saída/tratamento de fluxo: • FilterWriter (abstract), •
BufferedWriter, • OutputStreamWriter (conversor de char para byte),
• PrintWriter
164
E/S orientada ao caractere E/S orientada ao caractere ––
ExemploExemploEx28\InputCmd.javaimport java.io.*; //permite ler da
consola. Faz echo para o monitor daquilo que lêpublic class
InputCmd {
public static String readCmd(String inputMsg){
System.out.print(inputMsg); //InputStream/byte
InputStreamReader/char BufferedReader/charBufferedReader br = new
BufferedReader(
new InputStreamReader(System.in)); String input = null; try
{
input = br.readLine(); // lê uma linha} catch (IOException ioe)
{
System.out.println("IO error trying to read from the cmd!");
System.exit(1);
} return input;
}
public static void main (String[] args) { String s =
readCmd("Input: ");System.out.println("Echo input: "+s);
} }
-
83
ConcorrênciaConcorrência
166
ThreadsThreads
• Threads dividem o problema em tarefas independentes• Threads
vs. Processos
• Processos: tarefas em espaços de endereços diferentes que
comunicam entre si através de pipes fornecidos pelo S.O.
• Threads: tarefas dentro do espaço de endereços da aplicação
que comunicam entre si através de pipes fornecidos pela JVM
• Em Java o suporte de threads é nativo• Um thread é um objecto
que parece e age como um programa
individual.
-
84
167
Como criar um threadComo criar um thread
• Há duas estratégias• Herdar da classe java.lang.Thread•
Implementar a interface java.lang.Runnable
• Herdar da classe Thread• O objecto é um thread, e sobrepõe o
comportamento associado à
classe Thread
• Implementar a interface Runnable• O objecto, que define o
comportamento da execução, é passado para
um objecto Thread que o executa.
• Em ambos os casos• É necessário sobrepor o método run() que é
o "main()" do Thread• A invocação do método start() inicia o thread
(invoca run())• Quando o método run() termina, o thread morre.
168
CriaCriaçção de ão de threadsthreads ––
ExemploExemploEx29\EstThread.javaclass EThread extends Thread {
int n;EThread(int i){n=i;}public void run(){
for (int i=0; ijava EstThreadThread1: 0Thread2: 0Thread1:
1Thread2: 1Thread1: 2Thread2: 2Thread1: 3Thread2: 3Thread1:
4Thread2: 4
-
85
169
CriaCriaçção de ão de threadsthreads –– Exemplo 2Exemplo
2Ex29\ImpRunnable.javaclass IThread implements Runnable {
int n;IThread(int i){n=i;}public void run(){
for (int i=0; ijava impRunnableThread1: 0Thread2: 0Thread1:
1Thread2: 1Thread1: 2Thread2: 2Thread1: 3Thread2: 3Thread1:
4Thread2: 4
170
CicloCiclo de de vidavida de um threadde um thread
Thread t = new Thread()
Executável Bloqueado
Morto
start()
run() acaba(stop())
run() acaba(stop())
wait()sleep()I/O blocking
notify()sleep time-outI/O acabou
run() acaba(stop())
-
86
171
ClasseClasse ThreadThread
• Principais métodos:• Estáticos
• Thread currentThread()• Devolve a referência para o thread que
está a executar no momento
• void sleep(long tempo)• Coloca o thread bloquado durante pelo
menos tempo ms.
• void yield()• Faz com que o thread atual pare e permita que
outros que estão na sua
fila de prioridades executem.
172
ClasseClasse Thread (2)Thread (2)
• Principais métodos (cont.):• De instância (não estáticos)
• void run()• É o "main()" do Thread. Deve ser implementado no
Thread ou no
objecto Runnable passado ao thread• void start()
• É um bootstrap. Faz o JVM chamar o run()• boolean
isAlive()
• Verifica se thread está vivo
-
87
173
MonitorMonitor
• Permite proteger os recursos impedindo que mais do que um
thread os utilize em simultâneo.
• Recorre-se à keyword synchronized• Por questões de desempenho
deve-se limitar a sua
aplicação ao essencial.
174
Monitor (2)Monitor (2)
• Aplica-se a blocos ou métodos.• por bloco:
synchronized (this){
}
• por métodosynchronized * (Arg*){
}
-
88
175
Sem Monitor Sem Monitor ––
ExemploExemploEx30a\SemMonitor.javaclass Utilizador extends Thread
{
Conta conta;Utilizador (Conta c){ conta=c; }public void
run(){
for (int i=0;i=1000) {try {
Thread.sleep((long)(Math.random()*1000));
//adormece durante alguns ms} catch (InterruptedException e){
System.exit(1);}saldo-=1000; //levantamentoSystem.out.println("-
1000, Saldo= "+saldo);
} else {saldo+=1000; //depósitoSystem.out.println("+ 1000,
Saldo= "+saldo);
}}
}continua
$>java SemMonitor+ 1000, Saldo= 1000- 1000, Saldo= 0+ 1000,
Saldo= 1000- 1000, Saldo= 0+ 1000, Saldo= 1000- 1000, Saldo= 0+
1000, Saldo= 1000- 1000, Saldo= 0- 1000, Saldo= -1000+ 1000, Saldo=
0
176
Sem Monitor Sem Monitor –– Exemplo (2)Exemplo
(2)Ex30a\SemMonitor.java (cont.)public class SemMonitor {
public static void main(String[] args){Conta c = new Conta();new
Utilizador(c).start();new Utilizador(c).start();
}}
-
89
177
Com Monitor Com Monitor ––
ExemploExemploEx30b\CemMonitor.javaclass Utilizador extends Thread
{
Conta conta;Utilizador (Conta c){ conta=c; }public void
run(){
for (int i=0;i=1000) {try {
Thread.sleep((long)(Math.random()*1000));
//adormece durante alguns ms} catch (InterruptedException e){
System.exit(1);}saldo-=1000; //levantamentoSystem.out.println("-
1000, Saldo= "+saldo);
} else {saldo+=1000; //depósitoSystem.out.println("+ 500, Saldo=
"+saldo);
}}
}continua
$>java SemMonitor+ 1000, Saldo= 1000- 1000, Saldo= 0+ 1000,
Saldo= 1000- 1000, Saldo= 0+ 1000, Saldo= 1000- 1000, Saldo= 0+
1000, Saldo= 1000- 1000, Saldo= 0+ 1000, Saldo= 1000- 1000, Saldo=
0
178
Com Monitor Com Monitor –– Exemplo (2)Exemplo
(2)Ex30b\SemMonitor.java (cont.)public class ComMonitor {
public static void main(String[] args){Conta c = new Conta();new
Utilizador(c).start();new Utilizador(c).start();
}}
-
90
ComunicaComunicaçções TCP/IPões TCP/IP
180
Pilha Protocolar TCP/IPPilha Protocolar TCP/IP
• Rede• IP (Internet protocol)• ICMP (Internet Control
Message Protocol)• IGMP (Internet Group
Management Protocol)
• Transporte• TCP (transmission Control Protocol) (orientado à
conexão)• UDP (User datagram Protocol) (orientado ao datagrama)•
Exemplo de outros protocolos (não suportados pelo Java):
• SCTP (Stream Control Transmission Protocol) (orientado à
conexão)• DCCP (Datagram Congestion Control Protocol) (orientado ao
datagrama)
• Aplicação• HTTP, SMTP, POP3, FTP, etc.
-
91
181
ModelosModelos de de distribuidistribuiççãoão de dadosde
dados
• Unicast• De um ponto para um outro ponto• Endereço destino
identifica/localiza ponto destino
endereço unicast
• Multicast• De um ponto para um grupo de pontos• Endereço
destino identifica o grupo destino• Nós destino associam os seus
endereços (unicast) ao grupo destino
• Broadcast• De um ponto para todos os pontos• Endereço destino
corresponde a um endereço universal
correspondido por todos os nós
182
TCPTCP
• Transmission Control Protocol• Protocolo de transporte
orientado à conexão
• Antes de começar a enviar dados é necessário proceder ao
estabelecimento da conexão
• Depois dados são enviados/recebidos sob a forma de um fluxo de
bytes
• Unicamente unicast• Não existe um limite para o tamanho das
mensagens a enviar.• Fiável Implementa mecanismo de recuperação de
dados• Modelo cliente/servidor servidor fica à espera que o
cliente
inicie o estabelecimento da conexão.
-
92
183
UDPUDP
• User Datagram Protocol• Protocolo de transporte orientado ao
datagrama
• Cada mensagem é enviada num datagrama independente dos
(possíveis) restantes.
• Não é necessária qualquer sinalização prévia.• Cada datagrama
contém toda a informação necessária para a
correcta comunicação (portos origem e destino) necessário
especificar/verificar aquando do envio/recepção de cada
datagrama
• Pode ser utilizado em todos os modelos de distribuição.•
Tamanho das mensagens limitado a 64 kbytes (cabeçalho IP
incluído)• Não é fiável Não implementa mecanismos de recuperação
de
datagramas
184
java.netjava.net
• TCP é suportado pelas classes• Socket (permite a comunicação
através de uma conexão TCP)• SeverSocket (permite ao servidor ficar
à escuta de pedidos de
conexão)
• UDP é suportado pelas classes• DatagramSocket (permite a
comunicação via UDP)• DatagramPacket (datagrama UDP)•
MulticastSocket (permite a comunicação via UDP em multicast)
• Endereçamento• InetAddress (representa um endereços IP)• URL
(representa um URL e oferece um conjunto de operações
para comunicação)
-
93
185
ClasseClasse SocketSocket
• Ponto de contacto entre a aplicação e a conexão TCP•
Principais construtores
• Socket()• Socket(InetAddress address, int port)
• Cria um socket e conecta-o a um socket em address/port.•
Socket(String host, int port)
• Cria um socket e conecta-o a um socket em host/port.
• Principais métodos servem para obter fluxos de entrada, saída•
getInputStream(), getOutputStream()• close()
• Depois de obtido os fluxos, basta ler ou escrever dados como
se de um ficheiro se tratasse.
186
ClasseClasse ServerSocketServerSocket
• Permite a um servidor TCP ficar à escuta num dado porto
(local), até receber um pedido, para depois devolver um socket que
fica associado à nova conexão
• Principais contrutores• ServerSocket(int port)
• Fica à escuta em no porto port de todas as interfaces
(endereços IP) locais
• ServerSocket(int port, int backlog, InetAddress bindAddr)
• Fica à escuta no porto port do endereço bindAddr
• Principal método• accept()
• Aceita a conexão e devolve um socket para acesso à mesma
-
94
187
Cliente TCP Cliente TCP ––
ExemploExemploEx31\ClienteTcpHttp.java//Esta aplicação é um cliente
TCP que faz o pedido de uma página a um servidor HTTPimport
java.io.*;import java.net.*;public class ClienteTcpHttp {
public static void main(String[] args) throws IOException
{Socket socket = null;PrintWriter out = null;BufferedReader in =
null;try{
//cria o socket e associa-o a um endereçosocket = new
Socket("www.google.com",80);
out = new PrintWriter(new OutputStreamWriter(
socket.getOutputStream()), true);
in = new
BufferedReader(newInputStreamReader(socket.getInputStream()));
} catch (UnknownHostException e) {System.out.println("Host
desconhecido");System.exit(1);
} catch (IOException e) {System.out.println("Não foi possível
estabelecer uma conexão");System.exit(1);
}Continua
188
Cliente TCP Cliente TCP –– Exemplo (2)Exemplo
(2)Ex31\ClienteTcpHttp.java (cont.)// envia ao servidor o pedido da
página por omissão (index.html...)
out.println("GET / HTTP/1.1\r\n"); //não esquecer o \r\nString
resp="";while ((resp = in.readLine()) != null) {
System.out.println(resp); //imprime a resposta do
servidor}out.close(); //fecha os fluxos e depois o
socketin.close();socket.close();
}}
-
95
189
Servidor TCP Servidor TCP ––
ExemploExemploEx32\EchoServer.java//Esta aplicação é um servidor
TCP que devolve o que recebe (faz echo)import java.net.*;import
java.io.*;
public class EchoServer {public static void main(String[] args)
throws IOException{
//fica associado ao porto local 3000ServerSocket serverSocket =
new ServerSocket(3000); Socket clienteSocket=null;try {
//fica à espera (escuta) de uma conexãoclienteSocket =
serverSocket.accept();//o socket para escuta é diferente do socket
para a conexão
} catch (IOException e) {System.out.println("O accept
falhou");System.exit(-1);
}Continua
190
Servidor TCP Servidor TCP –– Exemplo (2)Exemplo
(2)Ex32\EchoServer.java (cont.)
PrintWriter out = null;BufferedReader in = null;out = new
PrintWriter(new OutputStreamWriter(
clienteSocket.getOutputStream()), true);in = new
BufferedReader(new InputStreamReader(
clienteSocket.getInputStream()));String str="";while ((str =
in.readLine()) != null) {
//quando recebe uma string do cliente imprime-a no monitor e
//deveolve-a (echo)System.out.println(str);out.println(str);
}out.close(); //primeiro fecham-se os fluxos e só depois os
socketsin.close();clienteSocket.close();serverSocket.close();
}}
-
96
191
Servidor TCP com Servidor TCP com
threadsthreadsExemploExemploEx37\EchoServerThread.javaimport
java.net.*;import java.io.*;class Connection extends Thread{
private Socket clienteSocket;static int stConNum=1; int
ConNum=stConNum++;public Connection(Socket cliente) { clienteSocket
= cliente; }public void run() {
PrintWriter out = null;BufferedReader in = null;try {
out = new PrintWriter(new OutputStreamWriter(
clienteSocket.getOutputStream()), true);
in = new
BufferedReader(newInputStreamReader(clienteSocket.getInputStream()));
while ((str = in.readLine()) != null) {
System.out.println("Con"+ConNum+": "+str);out.println(str);
}out.close(); in.close(); clienteSocket.close();
}catch (IOException ioe) { System.out.println(ioe);}}
}Continua
192
Servidor TCP com Servidor TCP com threadsthreadsExemplo
(2)Exemplo (2)Ex37\EchoServerThread.java (cont.)public class
EchoServerThread{
public static final int PORT = 3000;public static void
main(String[] args) throws IOException {
ServerSocket sock = null;try {
sock = new ServerSocket(PORT);while (true) {
//Fica à escuta de conexões. Cada nova conexão é servida //num
thread separadoThread worker = new
Connection(sock.accept());worker.start();
}}catch (IOException ioe) {
System.out.println(ioe);}finally {
if (sock != null) sock.close();}
}}
-
97
193
ClasseClasse InetAddressInetAddress
• Representa um endereço IP• Principais métodos estáticos
• getLocalHost()• Devolve um objecto InetAddress com um endereço
do host local
• getByName(String hostname) • Devolve um objecto InetAddress
com o endereço do host cujo nome
é hostname
• Principais métodos de instância• getHostAddress()
• Devolve uma string com o IP do host a que o objecto
InetAddress se refere
• getHostName() • Devolve uma string com o nome do host a que o
objecto
InetAddress se refere
194
ClasseClasse InetAddressInetAddress ––
ExemploExemploEx34\ResLocalhost.javaimport java.net.*;//Para
descobrir o IP e nome da máquina localpublic class ResLocalhost
{
public static void main(String[] args) throws Exception
{InetAddress address = InetAddress.getLocalHost();String ip =
address.getHostAddress();String nome =
address.getHostName();System.out.println("O seu computador chama-se
"+nome+" e tem o
endereço IP "+ip);}
}
-
98
195
ClasseClasse DatagramSocketDatagramSocket
• Representa o ponto de acesso para envio e recepção de
datagramas UDP (unicast e broadcast)
• Principais métodos constructores• DatagramSocket()
• Cria um socket e associa-o a um porto local livre (>1024)•
DatagramSocket(int port)
• Cria um socket e associa-o ao porto local port. •
DatagramSocket (int port, InetAddress addr)
• Cria um socket e associa-o ao porto local port e endereço
local addr.
196
ClasseClasse DatagramSocketDatagramSocket (2)(2)
• Principais métodos servem para enviar e receber datagramas•
send(DatagramPacket p)
• Envia um datagram a partir deste socket. •
receive(DatagramPacket p)
• Recebe um datagrama por este socket.• int getLocalPort()
• Devolve o porto local ao qual o socket está associado.•
close()
• Fecha o socket.
-
99
197
ClasseClasse DatagramPacketDatagramPacket
• Representa um datagrama UDP.• Principais construtores:
• DatagramPacket(byte[] buf, int length)• Cria um datagrama para
enviar e receber mensagens com um tamanho
máximo de length bytes.• DatagramPacket(byte[] buf, int length,
InetAddress
address, int port)• Cria um datagrama e inicializa-o com o par
endereço/porto destino.
198
ClasseClasse DatagramPacketDatagramPacket (2)(2)
• Principais métodos :• InetAddress getAddress()
• Devolve o endereço do socket remoto.• void
setAddress(InetAddress addr)
• Altera o endereço destino para addr.• int getPort()
• Devolve o porto do socket remoto.• void setPort(int port)
• Altera o porto destino para port• byte[] getData()
• Devolve a mensagem contida no datagrama.• void setData(byte[]
buf)
• Copia a mensagem contida em buf para o datagrama.
-
100
199
UDP envio UDP envio –– ExemploExemploEx35\UDPSend.javaimport
java.io.*;import java.net.*;// Envia um pacote para uma aplicação
UDP, neste caso no localhost, no porto 3000public class UDPSend
{
static final int port = 3000; //porto destinostatic final String
host = “localhost”; //host destinopublic static void main(String
args[]) throws Exception {
//Obtem o endereço do host destinoInetAddress address =
InetAddress.getByName(host);String msg = "Isto é um teste";int
msglen = msg.length();//Converte a string para um array de
bytesbyte[] message = msg.getBytes();// inicializa o datagrama com
os dados a enviar e os endereçosDatagramPacket packet = new
DatagramPacket(message, msglen, address, port);// Cria um socket e
envia o datagrama através deleDatagramSocket socket = new
DatagramSocket();socket.send(packet);socket.close();
}}
200
UDP recepUDP recepçção ão ––
ExemploExemploEx35\UDPReceive.javaimport java.io.*;import
java.net.*;//Fica à espera de datagramas no porto 3000. Imprime
qual a sua origem e qual o seu conteúdopublic class UDPReceive
{
static final int port = 3000;public static void main(String
args[]) throws Exception {
byte[] buffer = new byte[1024];DatagramSocket socket = new
DatagramSocket(port); //fica à escuta no porto 3000
while(true) {DatagramPacket packet = new DatagramPacket(buffer,
buffer.length);// Espera pela chegada de um
datagramasocket.receive(packet);// Converte o buffer de bytes para
uma string através// do contrutor: String(byte[] bytes, int offset,
int length) String s = new String(packet.getData(), 0,
packet.getLength());System.out.println("UDPReceive: received from
"
+packet.getAddress().getHostName()+ ":" +packet.getPort()+ ": "
+ s);
}}
}
-
101
201
ClasseClasse MulticastSocketMulticastSocket
• Representa o ponto de acesso para envio e recepção de
datagramas UDP em multicast
• IPv4: 224.0.0.0 a 239.255.255.255• IPv6: endereços começados
por FF• Principais construtores:
• MulticastSocket()• Cria um socket UDP para multicast.
• MulticastSocket(int port)• Cria um socket UDP associado ao
porto port para multicast.
202
ClasseClasse MulticastSocketMulticastSocket (2)(2)
• Principais métodos:• void joinGroup(InetAddress mcastaddr)
• Associa o socket a um grupo (endereço) multicast mcastaddr.•
void leaveGroup(InetAddress mcastaddr)
• Sai do grupo multicast mcastaddr.• void
setLoopbackMode(boolean disable)
• Inibe/permite o loopback de datagramas multicast.• void
setTimeToLive(int ttl)
• Altera o valor do TTL.
-
102
203
MulticastMulticast envio envio ––
ExemploExemploEx36\MulticastSender.javaimport java.net.*;
public class MulticastSender {public static void main(String[]
args) throws Exception{String addr = "230.0.0.1"; //endereço
multicastint port = 6000; //porto destino InetAddress group =
InetAddress.getByName(addr);
String msg = "Aqui vai alguma coisa via
multicast\r\n";DatagramPacket dp = new
DatagramPacket(msg.getBytes(), msg.length(), group,
port);MulticastSocket ms = new MulticastSocket();
ms.send(dp);ms.close();
}}
204
MulticastMulticast receprecepçção ão ––
ExemploExemploEx36\MulticastReceiver.javaimport java.net.*;
public class MulticastReceiver {public static void main(String[]
args) throws Exception {
int port = 6000;String addr= "230.0.0.1";InetAddress group =
InetAddress.getByName(addr);MulticastSocket ms = new
MulticastSocket(port);ms.joinGroup(group);
byte[] buffer = new byte[8192];int c=0;while(c++
-
103
205
Classe URLClasse URL
• Representa um Uniform Resource Locator• Ex:
http://www.google.pt:80/index.html
• protocol: http• host: www.google.pt• port: 80 (porto por
omissão associado ao http)• file: index.html (ficheiro por
omissão)
• Principais contrutores• URL(String spec)• URL(String protocol,
String host, String file) • URL(String protocol, String host, int
port, String file)
206
Classe URLClasse URL
• Principais métodos• openStream()
• Obtém um InputStream para os dados• openConnection()
• Devolve um objecto URLConnection que contém métodos para ler o
cabeçalho dos dados
• getContent()• Devolve os dados directamente como Object se
conteúdo for