Sei sulla pagina 1di 43

30/10/2008

Programação
Orientada a Objeto
com Java

Capítulo 3
Programação Orientada
a Objeto
Prof. Jucimar Souza
jucibs@gmail.com

Capítulo 3
Classes, Métodos e Construtores
 Objetivos da Aula
 Definir e Implementar os conceitos de classes e
métodos.
 Aprender como criar e utilizar objetos.
 Entender como escrever e utilizar métodos que invocam
outros métodos.
 Entender a herança e a reutilização de software.
 Entender a diferença entre classes abstratas e classes
concretas.
 Aprender a trabalhar com pacotes e interfaces.

1
30/10/2008

3.0 – Motivação – Problemas do Paradigma


Procedural

 A Orientação a Objetos (OO) é uma maneira de


programar que ajuda na organização e resolve
problemas enfrentados pela programação
procedural
 Considere um problema para validação de CPF em um
formulário
 CPF = formulario->campo_cpf
 Valida(cpf)
 Alguém te obriga a sempre validar esse cpf ?
 Considere que existem 50 formulários que precisam
desta validação.
 Considere que existem 3 programadores. Quem fica
responsável pela validação ?

3.0 – Motivação (cont)

 A situação pode piorar na entrada de um novo


desenvolvedor no projeto.
 Ele precisa ser treinado e avisado de uma série de
informações sobre o projeto que na maioria das
vezes não interessa para ele.
 Muitas vezes a necessidade de ler código que não foi
desenvolvido por você.
 Vamos piorar a situação :
 Agora temos que verificar se o cliente tem mais de
18 anos.
 Teremos que colocar a validação nos 50 formulários
existentes.

2
30/10/2008

3.0 – Motivação (cont)

 Seria interessante se:


 Somente um programador ficasse responsável
pela validação.
 As validações para quem está fazendo os
formulários ficasse transparente.
 A OO vem ao encontro desta necessidade
ajudando na organização do desenvolvimento
do sistema, encapsulando a lógica do negócio.

3 - Programação Orientada a Objetos

 O paradígma da Orientação ao Objeto é um mecanismo que ajuda a


definir a estrutura de programas, baseado nos conceitos do mundo
real, sejam eles reais ou abstratos.

 A Orientação ao Objeto permite criar programas componentizados,


separando as partes do sistema por responsabilidades e fazendo com
que essas partes se comuniquem entre sí, por meio de mensagens.

 Os conceitos da OO envolvem: Classes, Objetos e seus


Relacionamentos, Herança e Polimorfismo.

 Dentre as vantagens que a OO proporciona, podemos destacar o


aumento de produtividade, reuso de código, redução das linhas de
código programadas, separação de responsabilidades, encapsulamento,
polimorfismo, componentização, maior flexibilidade do sistema, dentre
outras vantagens.

3
30/10/2008

3 – Modelagem Orientada a Objetos

 Os sistemas OO podem ser modelados com auxílio da


UML (Unified Modeling Language).
 UML é uma linguagem de modelagem para especificar,
modelar, visualizar e documentar sistemas OO e não-OO,
baseando-se em diagramas.
 A UML é composta por:
 Diagrama de Classes
 Diagrama de Seqüência
 Diagrama de Objetos
 Diagrama de Casos de Uso
 outros....

3.1 Introdução às Classes


 Classe
 Podemos entender uma classe como um
modelo ou como uma especificação para certos
objetos , ou seja, a descrição genérica dos
objetos individuais pertencentes a um dado
conjunto.
 Qualquer implementação feita em Java tem que
estar encapsulada em uma classe.
 A partir de uma classe definida pode-se criar
objetos, assim:
 Classe: é vista como um modelo para o objeto
 Objeto: uma instância de uma classe.

4
30/10/2008

3.1 – Introdução a classe

3.2 Estrutura da Classe


class nome_da_classe { Uma classe basicamente
tipo nome_do_atributo1; possui dois grupos de
tipo nome_do_atributo2; elementos: a declaração de
••• seus atributos e a
tipo nome_do_atributoN; implementação de seus
métodos.
tipo nome_do_método1(parâmetros) {
//corpo do método
} Nome da Classe
tipo nome_do_método2(parâmetros) {
//corpo do método
Atributos
}
•••
tipo nome_do_método (parâmetros) { Métodos
//corpo do método
}
}
 Os dados ou variáveis definidas dentro de uma classe são chamadas de
variáveis de instância (atributos).
 O código de uma classe fica encapsulada em métodos.
 Os métodos e variáveis definidas em uma classe são chamados de
membros da classe.

5
30/10/2008

3.2 Criando uma Classe

 Ao salvarmos uma classe em um arquivo


devemos tomar os seguintes cuidados :
 Em um único arquivo Java podem existir varias
diferentes definições de classes mas apenas
uma pode ser publica.
 O nome do arquivo deve ser o nome da classe
pública.

3.2 Criando uma Classe (cont)

 Regras para Denominação de Classes


 Em Java recomenda-se que as classes utilizem
nomes iniciados com letras maiúsculas,
diferenciado-se dos nomes das variáveis ou
instâncias de objetos . Caso o nome seja
composto por mais de um palavra estas
também devem ser iniciadas por maiúsculo. Ex:
FichaCadastro, AcessoBanco, Conta.
 O uso de caracteres númericos é permitido mas
o underscore (_ - sublinhado) não é
aconselhavel.

6
30/10/2008

3.2 Criando uma Classe (cont)


Retangulo
class Retangulo {
double largura, altura; largura:double
} altura:double

class RetanguloPrincipal {
public static void main(String args[ ]){
Retangulo obRetangulo; //declaração de um objeto
double area;

obRetangulo = new Retangulo(); //criação do objeto

//iniciando os atributos
obRetangulo.largura = 5;
obRetangulo.altura = 4;
//calcula a área do Retângulo
area = obRetangulo.largura * obRetangulo.altura;

System.out.println(“Area do Retangulo: “ + area);


} //fim do método principal
}//fim da classe

3.2 Definição de uma Classe


 Criando uma classe
 O arquivo deve ser salvo com mesmo nome da classe
que contém o método main():
 RetanguloPrincipal.java
 Para compilar:
 javac RetanguloPrincipal.java
 Após a compilação serão criados os arquivos
Retangulo.class e RetanguloPrincipal.class
 Para executar:
 java RetanguloPrincipal
 Atenção: as classes poderiam ser salvas em arquivos
diferentes. Neste caso, os nomes dos arquivos seriam
dados de acordo com o nome da classe.

7
30/10/2008

3.2 Definição de uma Classe

 Exercícios
 1) Inclua na classe RetanguloPrincipal códigos
para calcular a diagonal, e mostrar altura e
largura de um retângulo.
 2) Crie um programa para se trabalhar com
algumas propriedades de uma caixa. A caixa
conterá como atributos: largura, altura e
profundidade. A classe conterá no método
principal os calculos de área e o volume da
caixa. (classes Caixa e CaixaPrincipal)

3.3 Métodos
tipo nome_do_método1 (tipo identificador1, tipo identificador2, ... ) {
//corpo do método
return valor_ou_expressão;
}
void nome_do_método2( ) {
//corpo do método
}

 O tipo de dado retornado pelo método pode ser:


 qualquer tipo (int, float, double, ...);
 os criados pelo programador;
 nenhum valor (void);
 Se o retorno for diferente de void, deve-se utilizar o operador
return.
 Os parâmetros são formados por:
 pares, contendo “tipo” e “identificador” separados por vírgula:
 (double a, double b, int c);

 caso não haja parâmetros informe só os parentes “( )”

8
30/10/2008

3.3 Métodos
 Incluindo um Método na Classe
class Retangulo {
double largura, altura; Retangulo
largura:double
//método para calcular e exibir a área de um triângulo
void area(){
altura:double
double area; area():void
area = largura * altura;
System.out.println(“Area da Figura: “ + area);
}
}
class RetanguloVoid {
public static void main(String args[ ]){
Retangulo obRetangulo; //declaração de um objeto
obRetangulo = new Retangulo (); //criação do objeto
//iniciando os atributos
obRetangulo.largura = 5;
obRetangulo.altura = 4;
//invocando o método
obRetangulo.area();
}
}

3.3 Métodos
 Retornando um valor
class Retangulo {
double largura, altura;
Retangulo
//método para calcular e exibir a área de um triângulo
double area(){ largura:double
double area; altura:double
area = largura * altura; area():double
return area;
}
}
class RetanguloRetornaValor {
public static void main(String args[ ]){
double area;
Retangulo obRetangulo; //declaração de um objeto
obRetangulo = new Retangulo (); //criação do objeto
//iniciando os atributos
obRetangulo.largura = 5;
obRetangulo.altura = 4;
//invocando o método
area = obRetangulo.area();
System.out.println(“Area da Figura: “ + area);
}
}

9
30/10/2008

3.3 Métodos
 Incluindo um Método com Parâmetros
class Retangulo {
double largura, altura;
//método para calcular e retornar a área de um retângulo Retangulo
double area(){ largura:double
return largura*altura;
}
altura:double
void inicia(double l, double a ){ area():double
largura = l; inicia(l,a:double):void
altura = a;
}
}
class RetanguloParametro{
public static void main(String args[ ]){
Retangulo obRetangulo ; //declaração de um objeto
double area;
obRetangulo = new Retangulo (); //criação do objeto
//iniciando os atributos
obRetangulo.inicia(5,4); //invocando o método
area = obRetangulo.area(); //invocando o método
System.out.println(“Area da Figura: “ + area);
}
}

3.3 Métodos
 Exercícios
 3) Inclua na classe Retangulo um
método para calcular a diagonal, um
método para retornar a largura e outro
para retornar a altura de um retângulo.
 4) Modifique o programa construído para
o exercício 2 para que contenha métodos
que retornem os valores.

10
30/10/2008

3.3 Métodos Recursivos

 É um método que chama a si próprio direta


ou inderamente, através de outro método.
 O Método realmente sabe como resolver
somentes o(s) caso(s) mais simples.
 Métodos dividem o problema
 Caso base
 Simplifica o problema
 O método vai dividindo o problema até resolver
 Chamada Recursiva
 Etapa de recursão

Valor Final = 120


5! 5!

5! = 5 * 24 = 120 é retornado
5 * 4! 5 * 4!

4! = 4 * 6 = 24 é retornado
4 * 3! 4 * 3!

3! = 3 * 2 = 6 é retornado
3 * 2! 3 * 2!

2 * 1! 2 * 1! 2! = 2*1=2 é retornado

1 retornado
1 1

(a) Processo da chamada recursiva (b) Valores retornados de cada chamada recursiva

11
30/10/2008

1 //FatorialTeste.java
2 // Método recursivo com o Fatorial Invoca o método
3 fatorial
4
5 class FactorialTeste {
6
7 public static void main(String args[]){
8
9 String resultado;
10 int n;
11 System.out.print("Digite um Numero ");
12 n=Console.readInteger();
13 System.out.println("\n\nFatorial de "+n+" = "+fatorial(n));
14
15 }
16
17 // Metodo recursivo fatorial Testa o caso básico
18 static int fatorial( int numero ) (metodo fatorial
19 { pode ser resolvido
20 // caso básico
21 if ( numero <= 1 ) aqui)
22 return 1;
23 // etapa de recursao
24 else
25 return numero * fatorial( numero - 1 );
26 }
27 } // Fim da Classe FatorialTeste

3.4 Construtores
 O construtor é responsável por iniciar o objeto imediatamente após
sua criação.
 Uma vez definido o construtor, ele é chamado automaticamente
após a criação do objeto antes que o operador new termine de
executar.
 O construtor é um método especial que não possui nenhum tipo de
retorno, pois o retorno implícito de um construtor é o objeto criado.
 O construtor tem o mesmo nome da classe.
 Podemos utilizar o construtor para iniciar as dimensões do retângulo
e, depois utilizar o método iniciar() para modificá-lo em tempo de
execução de acordo com o exemplo a seguir:
class Retangulo {
double largura, altura;
//definição do construtor
Retangulo(double l, double a){
inicia(l, a);
}
void inicia(double lar, double alt ){
largura = lar;
altura = alt;
}

12
30/10/2008

3.4 Construtores
double area(){
return largura*altura;
}
}
class RetanguloConstrutor{
public static void main(String args[ ]){
Retangulo obRetangulo; //declaração do objeto
double area;
obRetangulo = new Retangulo (5,4); //criação do objeto

//invocando o método e imprimindo a área do retângulo


area = obRetangulo.area();
System.out.println(“Area da Figura: “ + area);

//atribuindo novos valores aos atributos


obRetangulo.inicia(8,5);

//invocando novamente o método para recalcular a área do retângulo


area = obRetangulo.area();
System.out.println(“Area da Figura: “ + area);
}
}

Execícios
 Exercícios: desenvolva programas que
5) Modifique o exercício 4 (caixa) para que
contenha os métodos com passagem de
parâmetros com ou sem retorno e o
construtor.
6) Para trabalhar com um cilindro. O
usuário informará a altura e o raio do
cilindro, e o seu programa fornecerá a
área e o volume deste.

13
30/10/2008

3.5 Coletores de Lixo

 Os construtores adquirem vários recursos


de sistema, como a mémoria. Precisamos
de uma maneira disciplinada de devolver
estes recursos para o sistema quando eles
não são mais necessários, para evitar
desperdícios de recursos.
 Este processo é feito de forma
transparente e automática pela JVM e,
recebe o nome de Garbage Collection.
 Este processo ocorre de forma esporádica
(ou nunca, caso não haja necessidade).

3.6 O Método finalize()


 Algumas vezes um objeto precisa executar alguma
ação antes de ser destruído.
 Para estas situações específicas, Java oferece um
mecanismo chamado de finalização.
 Desta forma, o programador pode especificar ações
que ocorrerão quando o objeto é liberado pelo
sistema de Garbage Collection.
 Sintaxe: protected void finalize() ){
// código de finalização
}
 A palavra-chave protected previne que o método
finalize() tenha seu código definido fora da
classe.

14
30/10/2008

3.6 - Finalizadores

 A coleta de lixo pode ser acionada via


programa, através de uma chamada
explícita existente a método estático na
classe java.lang.System.
 System.gc();
 É importante resaltar que o objeto não é
imediatamente destruido, mas apenas
marcado para eliminação futura.

3.7 Sobrecarga de Métodos


 Quando em uma classe existir mais de um método com o mesmo
nome e implementações diferentes desde que as listas de
parâmetros sejam diferentes.
 Sobrecarga de Métodos é uma das formas que Java implementa o
polimorfismo.
class Retangulo {
double largura, altura, area;
void calcArea(){
area = largura*altura;
System.out.println(“Area do Retangulo sem parametros: “+area);
}
void calcArea(int l){
largura = l;
area = largura*largura;
System.out.println(“Area do Retangulo com inteiro: “+area);
}
double calcArea(double l){ double calcArea(double l, double a){
largura = l; largura = l;
area = largura*largura; altura = a;
return area; area = largura*altura;
} return area;
}
} //fim da classe

15
30/10/2008

3.7 Sobrecarga de Métodos


class RetSobreMetodoPrincipal {

public static void main(String args[ ]){

Retangulo obRetangulo = new Retangulo (); //declaração e criação do obj


double area;

obRetangulo.largura = 4.8;
obRetangulo.altura = 5;

//invocando as diferentes versões para calcular a área


obRetangulo.calcArea();
obRetangulo.calcArea(3);
area = obRetangulo.calcArea(5.5);
System.out.println(“Método com retorno e um parametro: “+area);
area = obRetangulo.calcArea(5.3, 3.2);
System.out.println(“Método com retorno e dois parametros: “+area);
}
}

3.8 Sobrecarga de Construtores


class Retangulo { class RetanguloSobreConstrutor{
double largura, altura; public static void main(String args[ ]){
//construtores com parâmetros e lados ≠s double area;
Retangulo(double l, double a){ Retangulo obRetangulo1 = new
inicia(l, a); Retangulo();
} Retangulo obRetangulo2 = new
//construtores sem parâmetros Retangulo(3.5);
Retangulo(){ Retangulo obRetangulo3 = new
inicia(0, 0); Retangulo(3, 4.5);
}
//construtores com um parâmetro e lados =s //invocando o método para obRetangulo1
Retangulo(double l){ area = obRetangulo1.calcArea();
inicia(l, l); System.out.println(“Retangulo 1: “ + area);
}
//método para atribuir valores para os lados //invocando o método para obRetangulo2
void inicia(double l, double a ){ area = obRetangulo2.calcArea();
largura = l; System.out.println(“Retangulo 2: “ + area);
altura = a;
} //invocando o método para obRetangulo3
//calcula e retorna o valor da área area = obRetangulo3.calcArea();
double calcArea(){ System.out.println(“Retangulo 3: “ + area);
return largura*altura;
} }
} }

16
30/10/2008

3.9 A Palavra-Chave static


 Cada objeto de uma classe tem sua própria cópia de todas as
variávcis de instância da classe. Em certos casos, apenas uma
cópia de uma variável deve ser compartilhada por todos os objetos
de uma classe.
 É possível a definição de um membro de uma classe que pode ser
acessado diretamente antes que qualquer objeto da classe seja
criado e sem referenciar qualquer objeto. Basta ...

usar static em sua declaração


 O método main é declarado como static porque é necessário chamá-
lo antes mesmo que qualquer objeto seja criado.
 Variáveis de instâncias declaradas como static são, essencialmente,
variáveis globais. Quando objetos de sua classe são declarados
nenhuma cópia da variável static é feita. Na verdade todas as
instâncias da classe compartilham a mesma variável static.
 Um método declarado static não pode acessar os membros não-static.

3.9 A Palavra-Chave static (cont)


class Funcionario
{
...
private int id;
private static int proximoId = 1;
}
 Agora todo objeto funcionário tem seu campo id, mas somente um
proximoId que é compartilhado por todos os objetos instânciados desta
classe. Se você instanciou um mil objetos da classe Funcionário então
existe um mil instâncias do campo Id, um para cada objeto. Mas existe
somente um campo estático proximoId.
public void setId()
{ harry.setId();
id = proximoId;
proximoId++; Então o campo id de harry é atribuido, e o
} valor do campo estático proximoId é
incrementado.

17
30/10/2008

3.10 A Palavra-Chave final


 Para evitar que uma variável seja modificada a palavra-
chave final pode ser utilizada.
 Mas é necessário iniciar uma variável final em sua
declaração.
 Uma variável final pode ser considerada como uma
constante em C/C++ declara como const.
final int BOTAO_I CLUIR = 1;
final int BOTAO_EDITAR = 2;
final int BOTAO_SALVAR = 3;
final int BOTAO_EXCLUIR = 4;
 A partir deste ponto as outras variáveis do programa podem
utilizar estas variáveis como constantes sem se preocupar se os
seus valores serão alterados.
 O método que é declarado final não pode ser sobrescrito em
uma subclasse. Os métodos que são declarados static e os
métodos que são declarados private são implicitamente final.

Exercícios
 Desenvolva programas que:
7) Modifique o programa da caixa para que
contenha os métodos e sobrecarga de
método, construtores e sobrecarga de
construtores.
8) Construa uma classe Figuras2D para
trabalhar, além de outros atributos, com o
atributo PI=3.1415 e métodos, que
envolvam figuras de duas dimensões,
para calcular a área de um círculo e de
um retângulo . Faça a classe principal, e
sem utilizar objetos, use os membros da
classe Figuras2D.

18
30/10/2008

3.11 Herança

 Representação de Herança em notação UML

Superclasse

Subclasse

É uma técnica onde uma classe passa a utilizar atributos e operações


definidas em uma outra classe especificada como seu ancestral.
Rigorosamente falando, a herança é o compartilhamento de atributos
e operações entre classes baseado num relacionamento hierárquico
do tipo pai e filho, ou seja, a classe pai contem definições que podem
ser utilizadas nas classes definidas como filho.

3.11 Herança (cont)

Superclasse Subclasses
Aluno AlunoDeGraduação
AlunoDePosGraduação
Forma Círculo
Triângulo
Retângulo
Financiamento FinanciamentoDoCarro
FinanciamentoDaReformaDaCasa
FinanciamentoDaCasa
Empregado CorpoDocente
Funcionário
Conta ContaCorrente
ContaDePoupança
Alguns exemplos simples de herança nos quais a subclasse “é uma” superclasse

19
30/10/2008

3.11 Herança (cont)


MembroDaComunidade é
uma superclasse direta de
Empregado
MenbroDaComunidade

MembroDaComunida
de é uma superclasse
indireta de Faculdade Empregado Aluno Graduado

Faculdade Funcionário

Administrador Professor

Hierarquia de herança para MembroDaComunidade em


uma universidade

3.11 Herança
 Permite uma classificação hierárquica.
 Pode-se definir uma classe contendo características
comuns a um conjunto de itens relacionados.
 Esta classe pode então ser herdada por outras
classes mais específicas, cada uma delas
acrescentando novas características únicas

class nome_da_subclasse extends nome_da_superclasse {


// corpo da classe
}
 Java somente suporta herança simples, enquanto que C++
suporta herança simples e múltipla.

20
30/10/2008

3.11 Herança (Primeiro Exemplo)


//atribui valores para os lados do quadrado
class Quadrilatero {
void iniciaQ(double l){
double largura, altura;
//método para atribuir valores para os lados inicia(l,l);
void inicia(double l, double a ){ }
largura = l; }
altura = a; class QuadrilateroHeranca{
} public static void main(String args[ ]){
double calcArea(double l, double a){ double area;
return l*a; Quadrado obQuadrado= new
} Quadrado (5.5);
double largura(){ //invocando o método para calcular a área
return largura; area =
} obQuadrado.calcAreaQ(obQuadrado.largura()
} );
class Quadrado extends Quadrilatero { System.out.println(“Quadrado: “ + area);
double area;
//construtor da classe quadrada //invoc. método para atribuir novos valores
Quadrado(double l){ area = obQuadrado.calcAreaQ(3.2);
inicia(l, l); System.out.println(“Retangulo 2: “ + area);
}
//calcula a área //invocando o método para retornar altura
double calcAreaQ(double l){ System.out.println(“Altura do Quadrado: “ +
area = calcArea(l,l); obQuadrado.altura);
return area; }
} }

3.11.1 – Controle de acesso dos membros

 Os membros public (+) são acessados de qualquer lugar em que o programa


tenha uma referência para o tipo dessa superclasse ou para um dos tipos de
suas subclasses.

 Os membros private ( - ) de uma superclasse são acessados apenas em


métodos dessa superclasse.

 Os membro protected (#)de uma superclasse podem ser acessados apenas por
métodos da superclasse, por métodos de subclasse e por métodos de outras
classes no mesmo pacote (os membros protected têm acesso de pacote).

 Os membros de subclasse normalmente poder fazer referência aos membros


public e protected da superclasse simplesmente com os nomes dos membros.

21
30/10/2008

3.11.1 - Encapsulamento

 Começamos a ver é a idéia de encapsular,


isto é, esconder todos os membros de uma
classe, além de esconder como funcionam
as rotinas (no caso métodos) do nosso
sistema.

3.11.2 – Getters e Setters

 Para permitir o acesso aos atributos (já que


eles são private) de uma maneira
controlada, a prática mais comum é criar
dois métodos, um que retorna o valor e
outro que muda o valor.
 O padrão para esses métodos é de colocar a
palavra get ou set antes do nome do
atributo.

22
30/10/2008

3.11.2 – Getters e Setters

public class Conta {


private double saldo, limite;
private String titular;

public double getSaldo() {


return this.saldo;
}

public void setLimite(double limite) {


this.limite = limite;
}
public Cliente getTitular() {
return this.titular;
}
public void setTitular(String titular) {
this.titular = titular;
}
}

3.11.3 – Relacionamento entre objetos de


superclasse e objetos de subclasse

 Objeto Subclasse
 Pode ser tratado como um objeto superclasse
 O inverso não é verdade
 Forma não é sempre um Circulo

 Toda classe implicitamente herda


java.lang.Object
 A menos que seja especificado o contrário na
primeira linha da definição da classe, caso em que a
classe estende Object indiretamente. Portanto, a
classe Object é a superclasse de toda a hierarquia
Java.

23
30/10/2008

1 // Ponto.java
2 // Definição da classe Ponto Membros protected
3
4 public class Ponto { previnem os clientes de acesso
5 direto
protected int x, y; // coordenadas do (menos os clientes da
Ponto
6 subclasse de Ponto ou os que
7 // construtor sem argumentos
8 public Ponto() estão no mesmo pacote)
9 {
10 // chamada implicita do construtor da superclasse ocorre aqui
11 setPonto( 0, 0 );
12 }
13
14 // construtor
15 public Ponto( int xCoordenada, int yCoordenada )
16 {
17 // chamada implicita do construtor da superclasse ocorre aqui

18 setPonto( xCoordenada, yCoordenada );


19 }
20
21 // configura as coordenadas x e y do Ponto
22 public void setPonto( int xCoordenada, int yCoordenada )
23 {
24 x = xCoordenada;
25 y = yCoordenada;
26 }
27
28 // obtém a coordenada X
29 public int getX()
30 {
31 return x;
32 }
33

34 // get y coordinate
35 public int getY()
36 {
37 return y;
38 }
39
40 // convert into a String representation
41 public String toString()
42 {
43 return "[" + x + ", " + y + "]";
44 }
45
46 } // end class Ponto

24
30/10/2008

3.11.2 - Construtores e Finalizadores

 Quando um objeto de uma subclasse é instanciado, o construtor da superclasse


deve ser chamado para fazer qualquer inicialização necessária das variáveis de
instância da superclasse do objeto de subclasse. Uma chamada explicita ao
construtor da superclasse (através da referência super) pode ser fornecida
como primeira instrução no construtor de superclasse. Caso contrário, o
construtor de subclasse chamará o construtor default da superclasse
implicitamente.
 Se as classes em sua hieraquia de classes definem métodos finalize, o método
finalize da subclasse deveria invocar o método finalize da superclasse para
assegurar que todas as partes de um objeto são finalizados adequadamente se o
coletor de lixo reinvidicar a memória para o objeto.

1 // Circulo.java Circulo é uma subclasse de


2 // Definição da classe Circulo
3 Ponto
4 public class Circulo extends Ponto { // herança de Ponto
5 protected double radius;
6 Circulo herda as variaveis
7 // construtor sem argumentos protected e os métodos public de
8 public Circulo()
9 { Ponto
10 ` // chamada implicita para o construtor da superclasse
11 setRadius( 0 );
12 }
13 Chamada implicita do cosntrutor da classe
14 // construtor
15
Ponto
public Circulo( double CirculoRadius, int xCoordenada, int yCoordenada )
17 {
18 // chamada p/ construtor da superclasse com parametros da coordenada
19 super( xCoordenada, yCoordenada );
20
21 // set radius
22 setRadius( CirculoRadius ); Chamada explicita de
23 } Ponto usando super
24
25 // set radius of Circulo
26 public void setRadius( double CirculoRadius )
27 {
28 radius = ( CirculoRadius >= 0.0 ? CirculoRadius : 0.0 );
29 }
30

25
30/10/2008

31 // obtem radius do Círculo


32 public double getRadius()
33 {
34 return radius;
35 }
36
37 // calcula a área do Circulo
38 public double area()
39 {
40 return Math.PI * radius * radius;
41 } Sobreescreve o metodo toString da
42
43 // converte o Circulo para uma String classePonto usando o mesmo nome
44 public String toString()
45 {
46 return "Centro = " + "[" + x + ", " + y + "]" +
47 "; Radiano = " + radius;
48 }
49
50 } // fim da classe Circulo

1 // HerancaTeste.java
3
4 // Java core packages
5 import java.text.DecimalFormat;
6
7
10 public class HerancaTeste {
11 Instancia os objetos Ponto e Circulo
12 // Testa as classes Ponto e Circulo
13 public static void main( String args[] )
14 {
15 Ponto ponto1, ponto2;
16 Circulo circulo1, circulo2;
17
Circulo invoca o método
18 ponto1 = new Ponto( 30, 50 ); sobrescrito toString
19 circulo1 = new Circulo( 2.7, 120, 89 );
20
21 String dados = "Ponto ponto1: " + ponto1.toString() +
22 "\nCirculo circulo: " + circulo1.toString(); Objeto da Superclasse
23 pode referenciar a objeto
24 // usa o relacionamento “é um" para fazer referencia a um Circulo
25 // com uam referencia de Ponto subclasse
26 ponto2 = circulo1; // atribui Circulo a uma referencia para Ponto
27 Ponto ainda invoca o método
28 sobrescrito
dados += "\n\nCirculo circulo1 (via referencia Circulo
do ponto2de): " +
29 ponto2.toString();
30
31 // usa downcasting (coerção de uma referência para superclasse para
32 // um tipo de dado de subclasse) para atribuir ponto2 a circulo2
33 circulo2 = ( Circulo ) ponto2; Downcast Ponto para
34 Circulo

26
30/10/2008

35 dados += "\n\nCirculo circulo1 (via circulo2): " +


36 circulo2.toString();
37
38 DecimalFormat precisao2 = new DecimalFormat( "0.00" );
39 dados += "\nArea do circulo (via circul22): " +
40 precisao2.format( circulo2.area() );
41
Circulo invoca o metodo
42 // tentando fazer referencia a um objeto Ponto com uma referencia a area
43 // Circulo
43 if ( ponto1 instanceof Circulo ) {
44 circulo2 = ( Circulo ) ponto1; Usa-se instanceof para
45 dados += "\n\ncast successful"; determinar se Ponto refere-se
46 } ao Circulo
47 else
48 dados += "\n\nponto1 não faz referencia a um Circulo";
49
50 System.out.println(dados);
Se Ponto refere a
53 Circulo, é feita uma
54 System.exit( 0 ); coerção de Ponto para
55 }
56
Circulo
57 } // end class HerancaTeste

1 // Point.java
2 // Definição da classe Point
3 public class Point extends Object {
4 protected int x, y; // coordinates of the Point
5
6 // construtor sem argumento
7 public Point()
Construtor da
8 { Superclasse
9 x = 0;
10 y = 0;
11 System.out.println( “Construtor Point sem arg: " + this );
12 }
13
14 // construtor
15 public Point( int xCoordinate, int yCoordinate )
16 {
17 x = xCoordinate;
18 y = yCoordinate;
19 System.out.println( “Construtor Point c/ arg: " + this );
20 }
21
Método finalize da Superclasse usa
22 // finalizador protected para acesso da subclasse,
23 protected void finalize() mas não para outros clientes
24 {
25 System.out.println( “Finalizador de Point : " + this );
26 }
27
28 // converte Point para uma representação de String
29 public String toString()
30 {
31 return "[" + x + ", " + y + "]";
32 }
33
34 } // fim da class Point

27
30/10/2008

1 // Circle.java
2 // Definição da classe Circle
3 public class Circle extends Point { // herda a classe Point
4 protected double radius;
5
6 // construtor sem argumentos Chamada implicita do construtor
7 public Circle() da Point
8 {
9 // chamada implicita do construtor da superclasse
10 radius = 0;
11 System.out.println( “Construtor Circle sem arg: " + this );
12 }
13
14 // Construtor
15 public Circle( double circleRadius, int xCoordinate,
16 int yCoordinate )
17 { Chamada explicita do
18 // chamada do construtor da superclass construtor da classe
19 super( xCoordinate, yCoordinate );
20
Point usando super
21 radius = circleRadius;
22 System.out.println( “Construtor Circle com arg: " + this );
23 }
24
25 // finalizador Sobreposição do método finalize da
26 protected void finalize() classe Point, mas efetua a
27 {
28
chamada usando super
System.out.println( “Finalizador de Circle " + this );
29 super.finalize(); // chamada do método finalize da superclasse
30 }
31

32 // converte o Circle para String


33 public String toString()
34 {
35 return "Center = " + super.toString() +
36 "; Radius = " + radius;
37 }
38
39 } // fim da classe Circle

28
30/10/2008

1 // Test.java
2 // Demonstra quando os construtores e finalizados
3 // da superclasse são chamados.
4 public class Test { Instancia o objeto Circle
5
6 // testa quando os construtores e finalizadores são chamados
7 public static void main( String args[] )
8 {
9 Circle circle1, circle2, circle3;
10
11 circle1 = new Circle( 4.5, 72, 29 );
12 circle2 = new Circle( 10, 5, 5 );
13 circle3 = new Circle();
14 circle1 = null; // marca para coleta de lixo
15 circle2 = null; // marca para coleta de lixo
16
17 System.gc(); // chama o coletor de lixo
18 }
19
20 } // end class Test
Invoca o método finalize de
Circle pela chamada do
System.gc

3.11.3 – Composição versus Herança

 Herança
 Relacionamento do tipo “É um ”
 Professor é um Funcionário
 Composição
 Relacionamento do tipo “Tem um ”
 Funcionário tem um NumeroDeTelefone

29
30/10/2008

//informa os valores dos atributos do ponto


//Definição da classe Ponto (Ponto.java) public String getPonto(){
public class Ponto{ return "Centro: [" + x + "," + y + "]";
protected int x, y; //coordenadas do ponto }
//construtor sem argumento } //fim da classe Ponto
public Ponto(){
setPonto(0,0); //Definição da classe Circulo (Circulo.java)
} public class Circulo extends Ponto{
//construtor protected double raio;
public Ponto(int a, int b) { //construtor sem argumento
setPonto(a,b); public Circulo(){
} //chamada implícita ao construtor de superclasse
//atribui valores às coordenadas x e y do Ponto setRaio(0);
public void setPonto(int a, int b){ }
x = a; y = b; //construtor
} public Circulo(double r, int a, int b){
//obtém a coordenada x super(a,b); //chama o construtor da superclasse
public int getX() { setRaio(r);
return x; }
} //atribui valores para o raio do Circulo
//obtém a coordenada y public void setRaio(double r){
public int getY() { if (r>=0)
return y; raio = r;
} else
System.out.print("valor invalido");
}

//atribui valores para o Circulo: raio, x, y //Definição da classe Cilindro (Cilindro .java)
public void setCirculo(double r, int a, int b){ public class Cilindro extends Circulo{
if (r>=0){ protected double altura;
raio = r; x = a; y = b;
} //construtor sem argumento
else public Cilindro(){
System.out.println("valor invalido do raio:"+r); //chamada implícita ao construtor de superclasse
} setAltura(0);
//obtém raio do Circulo }
public double getRaio(){ //construtor
return raio; public Cilindro(double h, double r, int a, int b){
} super(r,a,b); //chama o construtor da superclasse
//calcula a área de Circulo setAltura(h);
public double area(){ }
return Math.PI*raio*raio; //atribui valores para a altura do Cilindro
} public void setAltura(double h){
//calcula a circunferência do Circulo if (h>=0)
public double circ(){ altura = h;
return 2*Math.PI*raio; else
} System.out.println("valor invalido");
//informa os valores dos atributos do Circulo }
public String getCirculo(){
return "Raio: " + raio + "\t" + getPonto();
}
} //fim da classe Circulo

30
30/10/2008

//atribui valores para Cilindro: altura, raio, x, y //informa os valores dos atributos do Cilindro
public void setCilindro(double h, double r, public String getCilindro(){
int a, int b){ return "Altura: " + altura + "\t"+ getCirculo();
if (h>=0 && r>=0){ }
altura = h; raio = r; x = a; y = b; } //fim da classe Cilindro
}
else //Definição da classe teste (CilindroTeste.java)
System.out.println("valor invalido para a import java.text.DecimalFormat;
altura = " + h + " ou raio = "+r); public class CilindroTeste{
} public static void main(String args[]){
//obtém raio do Cilindro Cilindro c = new Cilindro(5, 3.5, 43, 70);
DecimalFormat p = new DecimalFormat("0.00");
public double getAltura(){
System.out.println(c.getCilindro());
return altura;
c.setAltura(10);
} System.out.println(c.getCilindro());
//calcula a área do Cilindro c.setCilindro(2,-10, 20,20);
public double area(){ System.out.println(c.getCilindro());
return 2*super.area() + circ()*altura; System.out.println("Area do circulo: "+ c.area());
} System.out.println("Area do circulo: "+
//calcula o volume do Cilindro p.format(c.area()));
public double volume(){ System.out.println("Volume do circulo: "+
return super.area()*altura; c.volume());
} System.out.println("Volume do circulo: "+
p.format(c.volume()));
}
}

31
30/10/2008

3.11.4 Sobreposição de Métodos


 Ao utilizar a herança, quando um método da subclasse possui
um nome igual a um método da superclasse, diz-se que o
método da subclasse sobrepõe (override) o método da
superclasse.
 A sobreposição de métodos permite que Java suporte
polimorfismo em tempo de execução.
 O polimorfismo é essencial em POO por uma razão:
 Permite que uma classe geral especifique métodos que serão
comuns a todos os seus descendentes, permitindo que as
subclasses definam uma implementação específicas de alguns ou
todos os métodos da superclasse.
 Exemplo:
 Será criada uma superclasse Figuras2D que modela várias figuras
bidimensionais. Esta classe define um método area() que calcula a
área de um objeto. O exemplo apresenta duas subclasses:
Retangulo e Triangulo. Cada uma das subclasses sobrepõe o
método area() de forma a retornar o valor correto.

class Figuras2D { class Triangulo extends Figuras2D {


double largura, altura; Triangulo(double l, double a){
Figuras2D(double l, double a){ super(l,a); //invoca o construtor da superclasse
largura = l; }
altura = a; double area( ){
} System.out.println(“Calculando a area do
double area( ){ Triangulo.”);
System.out.println(“A area para Figuras2D return (largura*altura)/2;
e indefinida.”); }
return 0; } //fim da classe Triangulo
}
} //fim da classe Figuras2D class Fig2DSobreposicaoMet {
public static void main(String args[ ]){
class Retangulo extends Figuras2D { double area;
Retangulo(double l, double a){ Figuras2D f = new Figuras2D (3.5, 10);
super(l,a); //invoca o construtor da superclasse Retangulo r= new Retangulo (4.5, 10);
} Triangulo t = new Triangulo(5.5, 20);
double area( ){
System.out.println(“Calculando a area do //invocando o método para retornar a area
Retangulo.”); System.out.println(“Area: “ + f.area());
return largura*altura; System.out.println(“Area:“ + r.area());
} System.out.println(“Area:“ + t.area());
} //fim da classe Retangulo }
}

32
30/10/2008

3.12 Classes Abstratas e Concretas

 Classes Abstratas
 São as classes para as quais o programador não
pode instanciar nenhum objeto.
 Essas classes são utilizadas como superclasses em
situações de herança (superclasses abstratas).
 Nenhum objeto das superclasses abstratas pode ser
instanciado.
 Propósito: é fornecer uma superclasse apropriada
da qual as outras classes possam herdar interfaces
e/ou implementação.
 Classes Concretas
 São as classes da qual os objetos podem ser
instanciados.

3.12 Classes Abstratas e Concretas


 Sintaxe das Classes Abstratas
 Em geral, é um classe que declara a estrutura geral
de um conjunto de objetos sem prover uma
implementação de todos os métodos.
 Os métodos não implementados são chamados de
métodos abstratos e as classes que possuem este
tipo de método são chamadas de classes abstratas.
abstract class nome_da_classe {
// corpo da classe
o o o

abstract tipo nome_do_método_abstrato(lista de parâmetros);


o o o

33
30/10/2008

3.12 Classes Abstratas e Concretas


class Triangulo extends Figuras2D {
abstract class Figuras2D { Triangulo(double l, double a){
double largura, altura; super(l,a); //invoca o construtor da superclasse
Figuras2D(double l, double a){ }
largura = l; double area( ){
altura = a; System.out.println(“Calculando a area do
} Triangulo.”);
abstract double area( ); return (largura*altura)/2;
} //fim da classe Figuras2D }
} //fim da classe Triangulo
class Retangulo extends Figuras2D {
Retangulo(double l, double a){ class Fig2DAbstract {
super(l,a); //invoca o construtor da superclasse public static void main(String args[ ]){
}
Figuras2D r= new Retangulo (4.5, 10);
double area( ){
System.out.println(“Calculando a area do Figuras2D t = new Triangulo(5.5, 20);
Retangulo.”);
return largura*altura; //invocando o método para retornar a area
} System.out.println(“Area:“ + r.area());
} //fim da classe Retangulo System.out.println(“Area:“ + t.area());
}
}

3.13 Vinculação Dinâmica (Dynamic Binding)

 Implementa o processo polimórfico de


objetos;
 Usa a superclasse para fazer referência a
objetos da subclasse;
 O programa escolhe corretamente o método
a ser chamado na subclasse;

34
30/10/2008

3.13 Vinculação Dinâmica (Dynamic Binding)

 Por Exemplo ,
 Superclasse Shape
 Subclasses Circle, Rectangle e Square
 Cada classe desenha ela mesma de acordo com
o tipo de classe
 Shape tem o método draw
 Cada classe sobreescre o método draw
 Chamar o método draw da superclasse Shape
 O programa determina dinamicamente de qual subclasse o
método draw será invocado.

 Verificar estudo de caso do Deitel sobre


sobreposição de metodos, uso de classes
final e Dynamic Binding (Vinculação
dinâmica)

35
30/10/2008

3.14 Utilizando a referência this


 Quando um método de uma classe referencia
outro membro dessa classe para um objeto
específico dessa classe, como Java assegura
que o objeto adequado é referenciado?
 É que cada objeto tem acesso a uma referência a
ele próprio – chamada de referência this.
 A referência this é implicitamente utilizada
para referenciar variáveis de instâncias e
métodos de um objeto.
 Outra utilização da referência this está em
permitir chamadas de métodos em cascata.
 Usar uma referência this em um método
static é um erro de sintaxe.

3.14 Utilizando a referência this


// ThisTeste.java
import java.text.DecimalFormat; public TempoSimples setSegundo(int s){
class TempoSimples { this.segundo = ((s>=0 && s<60)?s:0);
private int hora, minuto, segundo; return this;
}
public TempoSimples(int hora, int minuto, int
segundo){ public String toString(){
this.hora = hora; DecimalFormat doisDigitos = new DecimalFormat("00");
this.minuto = minuto; return doisDigitos.format(this.hora) + ":" +
this.segundo = segundo; doisDigitos.format(this.minuto) + ":" +
} doisDigitos.format(this.segundo);
}
public String getTempo(){
return "this.toSring(): " + this.toString() + }
"\ntoSring(): " + toString() + class ThisTeste{
"\nthis (com chamada implcita de toString()): “ + public static void main(String args[ ]){
this; TempoSimples t1 = new TempoSimples(12,3,9);
} TempoSimples t2 = new TempoSimples(10,1,1);

public TempoSimples setHora(int h){ System.out.println(t1.getTempo());


this.hora = ((h>=0 && h<24)?h:0); System.out.println(t2.getTempo());
return this;
} //chamada de métodos em cascata
t1.setHora(5).setMinuto(25).setSegundo(5);
public TempoSimples setMinuto(int m){ System.out.println(t1.getTempo());
this.minuto = ((m>=0 && m<60)?m:0); }
return this; }
}

36
30/10/2008

3.16 Composição
 Significa a construção de novas classes através do uso de
outras classes existentes, isto é, a nova classe possui
internamente atributos que representam objetos de outras
classes.
 Por exemplo, uma classe Cidade poderia conter como atributos
o seu nome, número de habitantes e suas coordenadas
representadas através de uma classe PontoGeográfico como
abaixo:
public class Cidade{
public string nome; A composição é uma carac-
public int populacao; terística freqüentemente
public PontoGeografico coordenadas;
utilizada quando se deseja
public Cidade(){ representar uma relação do
nome = new String(“ “); tipo “tem um”, indicando que
populacao = 0;
coordenadas = new PontoGeografico();
um objeto tem um ou outro
} como parte de si.
}

3.17 Interface
 É um tipo de dado especial que especifica o que uma
classe deve fazer, mas não especifica como fazer.
 As interfaces são muito semelhantes às classes,
contudo, são desprovidas de variáveis de instância (se
existir devem ser estáticas e finais) e, seus métodos
são declarados sem implementação.
 Uma vez definida uma interface, qualquer classe pode
implementá-la e uma classe pode implementar
quantas interfaces quiser, permitindo resultados
semelhantes aos obtidos com a herança múltipla.
 As interfaces são utilizadas para que classes não
relacionadas possam implementar métodos com a
mesma interface.

37
30/10/2008

3.17 Interface
 Sintaxe:
acesso interface NomeDaInterface{
//declaração de atributos final static
o o o
//declaração de métodos (sem implementação)
o o o
}

 É possível criarmos uma interface estendendo outra, isto é, através


da herança simples de outra interface, mas não de uma classe
simples e vice-versa, sendo a sintaxe:

acesso interface NomeDaInterface extends InterfaceBase{


//declaração de atributos final static
o o o
//declaração de métodos (sem implementação)
o o o
}

3.17 Interface
 Exemplo:
//definição da interface Forma
public interface Forma{
public double area();
public double volume();
public String getNome();
}

//definição da classe Ponto


public class Ponto extends Object implements Forma{
//corpo da classe
public double area(){
//corpo do metodo
}
public double volume(){
//corpo do metodo
}
public String getNome(){
//corpo do metodo
}
}

38
30/10/2008

Exercicio

1. Reescreva os programas Point, Circle e Cylinder


substituindo a herança por composição.
2. Liste todas as formas que conseguir – tanto
bidimensional como tridimensional – e organize as
formas em hierarquia de forma. Sua hierarquia deve ter
a superclasse abstract Forma que contêm a interface
para hierarquia. Derive a partir dela a classe
DuasDimensoes e a classe TresDimensoes estas
classes também deve ser abstract. Utilize o método
abstract imprima para imprimir os dados das
dimensões de cada classe. Também inclua os métodos
area e volume a fim de que esses calculos possam ser
realizados com objetos de cada classe concreta na
hierarquia. Escreva um programa para testar a classe
Forma.
3. Reescreva o exercicio 2 para utilizar uma interface
Forma no lugar da classe abstrata.

3.13 Pacotes
 Um pacote (package) em Java nada mais é do que
um diretório onde residem uma ou mais classes, ou
seja, é um conjunto de classes.
 Num pacote, usualmente, colocam-se classes
relacionadas com o mesmo propósito.
 Os pacotes reproduzem a idéia de bibliotecas em outras
linguagens de programação.
 Fornecem um mecanismo de reutilização de software.
 Dependendo do nível de acesso, as classes podem ser
acessadas somente pelas classes internas do pacote ou
pelas classes de outros pacotes.

39
30/10/2008

3.13.1 Revisando Controle de Acesso


 Java possui 3 modificadores: private,
protected e public.
 Mas, no total, Java permite 4 níveis de acesso.
 Níveis de acesso:
 Padrão: nenhum modificador é especificado. Neste
nível, um membro da classe é visível para qualquer
classe e subclasse do pacote.
 Privado (private): neste nível, um membro da
classe pode ser acessado somente pelos membros da
mesma classe.
 Protegido (protected): neste nível, um membro da
classe pode ser visto por subclasses de qualquer
pacote e qualquer classe do mesmo pacote.
 Público (public): neste nível, um membro da classe
pode ser visto por qualquer classe ou subclasse de
qualquer pacote.

3.13.2 Criando pacotes


 Passos para criação de pacotes
 1) Defina uma classe public. Se a classe não for
public, ela pode ser utilizada somente por
outras classes do mesmo pacote.
 2) Escolha um nome de pacote e adicione uma
instrução package ao arquivo de código-fonte
para definição da classe reutilizável.
 3) Compile a classe assim que ela for colocada
na estrutura de diretórios de pacote apropriada e
torne a nova classe disponível para o compilador
e para o interpretador.
 4) Importe a classe reutilizável para um
programa e utilize a classe.

40
30/10/2008

3.13.2 Criando pacotes


 1° Passo
 Trabalharemos com as classes Ponto, Circulo e
Cilindro.
 2° Passo
 Incluir o comando package no início de cada arquivo
fonte.
 Todas as classes declaradas dentro deste arquivo (ou
salvas dentro do mesmo diretório como .class) farão
parte do mesmo pacote.
 Sintaxe:
 package nome_do_pacote;
 Java utiliza o sistema de arquivos para gerenciar os
pacotes, levando em consideração case sensitive.
 Hierarquia de pacotes, são separados por um ponto.
 package pacote1.pacote2. ... .pacoteN;

3.13.2 Criando pacotes


 2° Passo (continuação)
 Então, um pacote declarado como
 package br.edu.cefetam.geometria;
 Precisa ser armazenado no diretório
br\edu\cefetam\geometria,
br/edu/cefetam/geometria ou
br:edu:cefetam:geometria em um sistema de
arquivos Windows, UNIX ou Macintosh,
respectivamente.
 Cuidado ao escolher um nome de um pacote, pois
ao renomeá-lo, é necessário alterar o seu nome em
todos os seus arquivos e o nome do diretório onde
o pacote está armazenado.

41
30/10/2008

3.13.2 Criando pacotes


 2° Passo (continuação)
 Em um esforço para fornecer nomes únicos para
cada pacote, a Sun Microsystems convenciona:
 o nome de pacote deve ser formado pelo nome de
domínio Internet na ordem inversa, mais
 o nome que queira dar ao seu pacote.
 3° Passo
 Compilar a classe para que seja armazenada no
pacote apropriado e se torne disponível.
 No Java 2, esse processo é simplificado, uma
vez que há um diretório chamado classes.
 Esse diretório é parte do novo mecanismo de
extensão Java (JavaBeans).

3.13.2 Criando pacotes


 3° Passo (continuação)
 Caminho do diretório classes:
 Windows: c:\j2sdk1.4.1_03\jre\classes
 UNIX: é o diretório em que você instalou o JDK seguido por
j2sdk1.4.1_03/jre/classes, por exemplo:
/usr/local/ j2sdk1.4.1_03/jre/classes
 O diretório classes não existe por padrão.
 Adicionando o package no arquivo (Ponto.java):
 package br.edu.cefetam.geometria;
 Após a compilação do arquivo um .class resultante é
colocado no diretório especificado pela instrução package.
 Se esses diretórios não existirem antes da classe ser
compilada, o compilador os cria.

42
30/10/2008

3.13.2 Criando pacotes


 3° Passo (continuação)
 Ao compilar uma classe em um pacote, há uma
opção extra (-d) que deve ser passada para o
compilador especificando onde criar (ou locali-zar
todos os diretórios na instrução package:
Win: javac –d c:\j2sdk1.4.1_03\jre\classes Ponto.java
UNIX: javac –d $HOME/c:\j2sdk1.4.1_03\jre\classes Ponto.java
 Um arquivo de código-fonte Java tem a seguinte
ordem:
 uma instrução package (se houver);
 instruções importe (se houver); e
 então definições de classe.
 Obs.: se mais de uma classe for criada num arquivo,
somente uma das definições de classe pode ser pública.
Inclusive formará o nome do arquivo.

3.13.2 Criando pacotes


 4° Passo
 Uma vez que a classe é compilada e armazenada em
seu pacote, ela pode ser importada. Como
 uses em Object Pascal e include no C/C++.
 Importando um Pacote
 Sintaxe:
import pacote1.pacote2. ... .pacoteN[.nome_da_classe|*];
 Exemplos:
import java.io.*;
import java.awt.Button;
import br.edu.cefetam.geometria.Ponto;
 Como ficaria os cabeçalhos de Circulo.java e Cilindro.java?

package br.edu.cefetam.geometria; //Circulo.java

package br.edu.cefetam.geometria; //Cilindro.java

43

Potrebbero piacerti anche