Programação Orientada a Objeto Com Java

30/10/2008

1

Programação Orientada a Objeto com Java

Prof. Jucimar [email protected]

Capítulo 3Capítulo 3

Programação Orientada Programação Orientada

a Objetoa Objeto

Capítulo 3

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

Classes, Métodos e Construtores

30/10/2008

2

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.

30/10/2008

3

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.

30/10/2008

4

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.

30/10/2008

5

3.1 – Introdução a classe

3.2 Estrutura da Classeclass nome_da_classe {

tipo nome_do_atributo1;tipo nome_do_atributo2;

• • •tipo nome_do_atributoN;

tipo nome_do_método1(parâmetros) {//corpo do método

}tipo nome_do_método2(parâmetros) {

//corpo do método}

• • •tipo nome_do_método (parâmetros) {

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

Uma classe basicamente possui dois grupos de elementos: a declaração de seus atributos e a implementação de seus métodos.

Nome da Classe

Atributos

Métodos

30/10/2008

6

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.

30/10/2008

7

3.2 Criando uma Classe (cont)

class Retangulo {double largura, altura;

}

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

Retangulo

largura:doublealtura:double

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.

30/10/2008

8

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étodostipo nome_do_método1 (tipo identificador1, tipo identificador2, ... ) {//corpo do métodoreturn 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 “( )”

30/10/2008

9

3.3 Métodos� Incluindo um Método na Classe

class Retangulo {double largura, altura;

//método para calcular e exibir a área de um triângulo

void area(){

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


obRetangulo.largura = 5;obRetangulo.altura = 4;//invocando o método

obRetangulo.area();}}

Retangulo

largura:doublealtura:doublearea():void

3.3 Métodos� Retornando um valorclass Retangulo {double largura, altura;

//método para calcular e exibir a área de um triângulo

double area(){

double area;area = largura * altura;return area;

}

}

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



obRetangulo.largura = 5;obRetangulo.altura = 4;//invocando o método

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

}}

Retangulo

largura:doublealtura:doublearea():double

30/10/2008

10

3.3 Métodos� Incluindo um Método com Parâmetrosclass Retangulo {

double largura, altura;//método para calcular e retornar a área de um retângulo

double area(){

return largura*altura;}

void inicia(double l, double a ){

largura = l;altura = a;

}

}

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

double area;



obRetangulo.inicia(5,4); //invocando o método

area = obRetangulo.area(); //invocando o método

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

Retangulo

largura:doublealtura:doublearea():double

inicia(l,a:double):void

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.

30/10/2008

11

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

5!

5 * 4!

4 * 3!

3 * 2!

2 * 1!

1

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

5!

5 * 4!

4 * 3!

3 * 2!

2 * 1!

1

Valor Final = 120

4! = 4 * 6 = 24 é retornado

5! = 5 * 24 = 120 é retornado

3! = 3 * 2 = 6 é retornado

1 retornado

2! = 2*1=2 é retornado

30/10/2008

12

1 //FatorialTeste.java

2 // Método recursivo com o Fatorial

3

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

18 static int fatorial( int numero )

19 {

20 // caso básico

21 if ( numero <= 1 )

22 return 1;

23 // etapa de recursao

24 else

25 return numero * fatorial( numero - 1 );

26 }

27 } // Fim da Classe FatorialTeste

Testa o caso básico (metodo fatorialpode ser resolvido

aqui)

Invoca o método fatorial

3.4 Construtores

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;

}

� 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:

30/10/2008

13

3.4 Construtoresdouble area(){


}

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.

30/10/2008

14

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()

protected void finalize() ){

// código de finalização}

� 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:

� A palavra-chave protected previne que o método finalize() tenha seu código definido fora da classe.

30/10/2008

15

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

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

largura = l;

area = largura*largura;return area;

}

} //fim da classe

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

double calcArea(double l, double a){

largura = l;

altura = a;

area = largura*altura;return area;

}

30/10/2008

16

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 Construtoresclass Retangulo {

double largura, altura;//construtores com parâmetros e lados ≠≠≠≠s

Retangulo(double l, double a){inicia(l, a);

}

//construtores sem parâmetros

Retangulo(){inicia(0, 0);

}

//construtores com um parâmetro e lados =s

Retangulo(double l){inicia(l, l);

}

//método para atribuir valores para os lados



}

//calcula e retorna o valor da área

double calcArea(){


}

class RetanguloSobreConstrutor{public static void main(String args[ ]){double area;

Retangulo obRetangulo1 = new

Retangulo();


Retangulo(3.5);


Retangulo(3, 4.5);

//invocando o método para obRetangulo1

area = obRetangulo1.calcArea();

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







}}

30/10/2008

17

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(){id = proximoId;proximoId++;

}

harry.setId();

Então o campo id de harry é atribuido, e o valor do campo estático proximoId é incrementado.

30/10/2008

18

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.

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

Exercícios

30/10/2008

19

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çõesdefinidas em uma outra classe especificada como seu ancestral. Rigorosamente falando, a herança é o compartilhamento de atributose operações entre classes baseado num relacionamento hierárquicodo tipo pai e filho, ou seja, a classe pai contem definições que podemser 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

30/10/2008

20

3.11 Herança (cont)

Hierarquia de herança para MembroDaComunidade em uma universidade

MembroDaComunidade é uma superclasse direta de

Empregado

MembroDaComunida

de é uma superclasse indireta de Faculdade

MenbroDaComunidade

Empregado Aluno

Faculdade Funcionário

Administrador Professor

Graduado

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

� Java somente suporta herança simples, enquanto que C++ suporta herança simples e múltipla.

class nome_da_subclasse extends nome_da_superclasse {

// corpo da classe}

30/10/2008

21

3.11 Herança (Primeiro Exemplo)class Quadrilatero {

double largura, altura;//método para atribuir valores para os lados



}

double calcArea(double l, double a){

return l*a;}

double largura(){

return largura;}

}

class Quadrado extends Quadrilatero {

double area;//construtor da classe quadrada

Quadrado(double l){

inicia(l, l);}

//calcula a área

double calcAreaQ(double l){

area = calcArea(l,l);return area;

}

//atribui valores para os lados do quadrado

void iniciaQ(double l){

inicia(l,l);}

}

class QuadrilateroHeranca{

public static void main(String args[ ]){double area;

Quadrado obQuadrado= new

Quadrado (5.5);//invocando o método para calcular a área

area =

obQuadrado.calcAreaQ(obQuadrado.largura()

);

System.out.println(“Quadrado: “ + area);

//invoc. método para atribuir novos valores

area = obQuadrado.calcAreaQ(3.2);


//invocando o método para retornar altura

System.out.println(“Altura do Quadrado: “ +obQuadrado.altura);

}

}

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.

30/10/2008

22

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.

30/10/2008

23

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.

30/10/2008

24

1 // Ponto.java

2 // Definição da classe Ponto

3

4 public class Ponto {

5 protected int x, y; // coordenadas do Ponto

6

7 // construtor sem argumentos

8 public Ponto()

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

Membros protected

previnem os clientes de acesso direto (menos os clientes da

subclasse de Ponto ou os que estão no mesmo pacote)

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

30/10/2008

25

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

2 // Definição da classe Circulo

3

4 public class Circulo extends Ponto { // herança de Ponto

5 protected double radius;

6


8 public Circulo()

9 {

10 ` // chamada implicita para o construtor da superclasse

11 setRadius( 0 );

12 }

13

14 // construtor

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

23 }

24

25 // set radius of Circulo

26 public void setRadius( double CirculoRadius )

27 {

28 radius = ( CirculoRadius >= 0.0 ? CirculoRadius : 0.0 );

29 }

30

Circulo é uma subclasse de Ponto

Chamada implicita do cosntrutor da classe Ponto

Circulo herda as variaveis protected e os métodos public de

Ponto

Chamada explicita de Ponto usando super

30/10/2008

26

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 }

42

43 // converte o Circulo para uma String


45 {

46 return "Centro = " + "[" + x + ", " + y + "]" +

47 "; Radiano = " + radius;

48 }

49

50 } // fim da classe Circulo

Sobreescreve o metodo toString da classe Ponto usando o mesmo nome

1 // HerancaTeste.java

3

4 // Java core packages

5 import java.text.DecimalFormat;

6

7

10 public class HerancaTeste {

11

12 // Testa as classes Ponto e Circulo

13 public static void main( String args[] )

14 {

15 Ponto ponto1, ponto2;

16 Circulo circulo1, circulo2;

17

18 ponto1 = new Ponto( 30, 50 );

19 circulo1 = new Circulo( 2.7, 120, 89 );

20

21 String dados = "Ponto ponto1: " + ponto1.toString() +

22 "\nCirculo circulo: " + circulo1.toString();

23

24 // usa o relacionamento “é um" para fazer referencia a um Circulo

25 // com uam referencia de Ponto

26 ponto2 = circulo1; // atribui Circulo a uma referencia para Ponto

27

28 dados += "\n\nCirculo circulo1 (via referencia do ponto2 ): " +

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;

34

Instancia os objetos Ponto e Circulo

Circulo invoca o método sobrescrito toString

Objeto da Superclasse pode referenciar a objeto

subclasse

Ponto ainda invoca o método sobrescrito de Circulo

Downcast Ponto para Circulo

30/10/2008

27

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

42 // tentando fazer referencia a um objeto Ponto com uma referencia a

43 // Circulo

43 if ( ponto1 instanceof Circulo ) {

44 circulo2 = ( Circulo ) ponto1;

45 dados += "\n\ncast successful";

46 }

47 else

48 dados += "\n\nponto1 não faz referencia a um Circulo";

49

50 System.out.println(dados);

53

54 System.exit( 0 );

55 }

56

57 } // end class HerancaTeste

Circulo invoca o metodo area

Usa-se instanceof para determinar se Ponto refere-se

ao Circulo

Se Ponto refere a Circulo, é feita uma coerção de Ponto para

Circulo

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()

8 {

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

22 // finalizador

23 protected void finalize()

24 {

25 System.out.println( “Finalizador de Point : " + this );

26 }

27

28 // converte Point para uma representação de String


30 {

31 return "[" + x + ", " + y + "]";

32 }

33

34 } // fim da class Point

Construtor da Superclasse

Método finalize da Superclasse usa protected para acesso da subclasse,

mas não para outros clientes

30/10/2008

28

1 // Circle.java

2 // Definição da classe Circle

3 public class Circle extends Point { // herda a classe Point

4 protected double radius;

5


7 public Circle()

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 {

18 // chamada do construtor da superclass

19 super( xCoordinate, yCoordinate );

20

21 radius = circleRadius;

22 System.out.println( “Construtor Circle com arg: " + this );

23 }

24

25 // finalizador

26 protected void finalize()

27 {

28 System.out.println( “Finalizador de Circle " + this );

29 super.finalize(); // chamada do método finalize da superclasse

30 }

31

Chamada implicita do construtor da Point

Chamada explicita do construtor da classe

Point usando super

Sobreposição do método finalize da classe Point, mas efetua a chamada usando super

32 // converte o Circle para String


34 {

35 return "Center = " + super.toString() +

36 "; Radius = " + radius;

37 }

38

39 } // fim da classe Circle

30/10/2008

29

1 // Test.java

2 // Demonstra quando os construtores e finalizados

3 // da superclasse são chamados.

4 public class Test {

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

Instancia o objeto Circle

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

30/10/2008

30

//Definição da classe Ponto (Ponto.java)

public class Ponto{protected int x, y; //coordenadas do ponto//construtor sem argumentopublic Ponto(){ setPonto(0,0);

}//construtorpublic Ponto(int a, int b) { setPonto(a,b); }//atribui valores às coordenadas x e y do Pontopublic void setPonto(int a, int b){x = a; y = b;

}//obtém a coordenada xpublic int getX() { return x; }//obtém a coordenada ypublic int getY() { return y;

}

//informa os valores dos atributos do pontopublic String getPonto(){return "Centro: [" + x + "," + y + "]";

}} //fim da classe Ponto

//Definição da classe Circulo (Circulo.java)

public class Circulo extends Ponto{protected double raio; //construtor sem argumentopublic Circulo(){//chamada implícita ao construtor de superclassesetRaio(0);}//construtorpublic Circulo(double r, int a, int b){

super(a,b); //chama o construtor da superclassesetRaio(r);

}//atribui valores para o raio do Circulopublic void setRaio(double r){if (r>=0)

raio = r;else

System.out.print("valor invalido");}

//atribui valores para o Circulo: raio, x, ypublic void setCirculo(double r, int a, int b){if (r>=0){raio = r; x = a; y = b;

}elseSystem.out.println("valor invalido do raio:"+r);}//obtém raio do Circulopublic double getRaio(){return raio;}//calcula a área de Circulopublic double area(){return Math.PI*raio*raio;}//calcula a circunferência do Circulopublic double circ(){return 2*Math.PI*raio;}//informa os valores dos atributos do Circulopublic String getCirculo(){return "Raio: " + raio + "\t" + getPonto();

}} //fim da classe Circulo

//Definição da classe Cilindro (Cilindro .java)

public class Cilindro extends Circulo{protected double altura;

//construtor sem argumentopublic Cilindro(){ //chamada implícita ao construtor de superclasse

setAltura(0);}//construtorpublic Cilindro(double h, double r, int a, int b){

super(r,a,b); //chama o construtor da superclassesetAltura(h);

}//atribui valores para a altura do Cilindropublic void setAltura(double h){

if (h>=0)altura = h;

elseSystem.out.println("valor invalido");

}

30/10/2008

31

//atribui valores para Cilindro: altura, raio, x, ypublic void setCilindro(double h, double r,

int a, int b){if (h>=0 && r>=0){

altura = h; raio = r; x = a; y = b;}elseSystem.out.println("valor invalido para a

altura = " + h + " ou raio = "+r);}//obtém raio do Cilindropublic double getAltura(){return altura;}//calcula a área do Cilindropublic double area(){return 2*super.area() + circ()*altura;

}//calcula o volume do Cilindropublic double volume(){return super.area()*altura;}

//informa os valores dos atributos do Cilindropublic String getCilindro(){return "Altura: " + altura + "\t"+ getCirculo();}} //fim da classe Cilindro

//Definição da classe teste (CilindroTeste.java)

import java.text.DecimalFormat;public class CilindroTeste{public static void main(String args[]){Cilindro c = new Cilindro(5, 3.5, 43, 70);DecimalFormat p = new DecimalFormat("0.00");System.out.println(c.getCilindro());c.setAltura(10);System.out.println(c.getCilindro());c.setCilindro(2,-10, 20,20);System.out.println(c.getCilindro());System.out.println("Area do circulo: "+ c.area());System.out.println("Area do circulo: "+

p.format(c.area()));System.out.println("Volume do circulo: "+

c.volume());System.out.println("Volume do circulo: "+

p.format(c.volume()));}}

30/10/2008

32

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 {

double largura, altura;Figuras2D(double l, double a){


}

double area( ){

System.out.println(“A area para Figuras2D e indefinida.”);

return 0;}

} //fim da classe Figuras2D

class Retangulo extends Figuras2D {

Retangulo(double l, double a){

super(l,a); //invoca o construtor da superclasse}

double area( ){

System.out.println(“Calculando a area do Retangulo.”);


} //fim da classe Retangulo

class Triangulo extends Figuras2D {

Triangulo(double l, double a){


double area( ){

System.out.println(“Calculando a area do Triangulo.”);

return (largura*altura)/2;}

} //fim da classe Triangulo

class Fig2DSobreposicaoMet {

public static void main(String args[ ]){double area;

Figuras2D f = new Figuras2D (3.5, 10);

Retangulo r= new Retangulo (4.5, 10);

Triangulo t = new Triangulo(5.5, 20);

//invocando o método para retornar a area

System.out.println(“Area: “ + f.area());System.out.println(“Area:“ + r.area());System.out.println(“Area:“ + t.area());}

}

30/10/2008

33

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 interfacese/ou implementação.

� Classes Concretas� São as classes da qual os objetos podem ser

instanciados.


� 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 classeo o o

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

}

30/10/2008

34


abstract class Figuras2D {

double largura, altura;Figuras2D(double l, double a){


}

abstract double area( );

} //fim da classe Figuras2D

class Retangulo extends Figuras2D {

Retangulo(double l, double a){


double area( ){

System.out.println(“Calculando a area do Retangulo.”);


} //fim da classe Retangulo

class Triangulo extends Figuras2D {

Triangulo(double l, double a){


double area( ){

System.out.println(“Calculando a area do Triangulo.”);

return (largura*altura)/2;}

} //fim da classe Triangulo

class Fig2DAbstract {

public static void main(String args[ ]){Figuras2D r= new Retangulo (4.5, 10);

Figuras2D t = new Triangulo(5.5, 20);

//invocando o método para retornar a area

System.out.println(“Area:“ + r.area());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;

30/10/2008

35

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)

30/10/2008

36

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;

class TempoSimples {

private int hora, minuto, segundo;

public TempoSimples(int hora, int minuto, int segundo){

this.hora = hora;this.minuto = minuto;this.segundo = segundo;

}

public String getTempo(){return "this.toSring(): " + this.toString() +

"\ntoSring(): " + toString() + "\nthis (com chamada implcita de toString()): “ +

this;}

public TempoSimples setHora(int h){this.hora = ((h>=0 && h<24)?h:0);return this;

}

public TempoSimples setMinuto(int m){this.minuto = ((m>=0 && m<60)?m:0);return this;

}

public TempoSimples setSegundo(int s){this.segundo = ((s>=0 && s<60)?s:0);

return this;

}

public String toString(){DecimalFormat doisDigitos = new DecimalFormat("00");return doisDigitos.format(this.hora) + ":" +doisDigitos.format(this.minuto) + ":" +doisDigitos.format(this.segundo);}

}

class ThisTeste{

public static void main(String args[ ]){

TempoSimples t1 = new TempoSimples(12,3,9); TempoSimples t2 = new TempoSimples(10,1,1);

System.out.println(t1.getTempo()); System.out.println(t2.getTempo());

//chamada de métodos em cascatat1.setHora(5).setMinuto(25).setSegundo(5);System.out.println(t1.getTempo());

}

}

30/10/2008

37

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;public int populacao;public PontoGeografico coordenadas;

public Cidade(){nome = new String(“ “);populacao = 0;coordenadas = new PontoGeografico();

}}

A composição é uma carac-

terística freqüentemente

utilizada quando se deseja

representar uma relação do

tipo “tem um”, indicando que

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.

30/10/2008

38

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 Formapublic interface Forma{public double area();public double volume();public String getNome();

}

//definição da classe Pontopublic class Ponto extends Object implements Forma{

//corpo da classepublic double area(){

//corpo do metodo}public double volume(){

//corpo do metodo}public String getNome(){

//corpo do metodo}

}

30/10/2008

39

Exercicio

1. Reescreva os programas Point, Circle e Cylindersubstituindo 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.

30/10/2008

40

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.

30/10/2008

41


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


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

30/10/2008

42


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

30/10/2008

43


� 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.javaUNIX: 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

Documents

Programação Orientada a Objeto Com Java