Escolar Documentos
Profissional Documentos
Cultura Documentos
Programacao Orientada A Objeto Com Java
Programacao Orientada A Objeto Com Java
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
2
30/10/2008
3
30/10/2008
4
30/10/2008
5
30/10/2008
6
30/10/2008
class RetanguloPrincipal {
public static void main(String args[ ]){
Retangulo obRetangulo; //declaração de um objeto
double area;
//iniciando os atributos
obRetangulo.largura = 5;
obRetangulo.altura = 4;
//calcula a área do Retângulo
area = obRetangulo.largura * obRetangulo.altura;
7
30/10/2008
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
}
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
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
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
14
30/10/2008
3.6 - Finalizadores
15
30/10/2008
obRetangulo.largura = 4.8;
obRetangulo.altura = 5;
16
30/10/2008
17
30/10/2008
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
Superclasse
Subclasse
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
MembroDaComunida
de é uma superclasse
indireta de Faculdade Empregado Aluno Graduado
Faculdade Funcionário
Administrador Professor
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
20
30/10/2008
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).
21
30/10/2008
3.11.1 - Encapsulamento
22
30/10/2008
Objeto Subclasse
Pode ser tratado como um objeto superclasse
O inverso não é verdade
Forma não é sempre um Circulo
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
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
25
30/10/2008
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
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
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
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
//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
32
30/10/2008
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.
33
30/10/2008
34
30/10/2008
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.
35
30/10/2008
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
}
3.17 Interface
Exemplo:
//definição da interface Forma
public interface Forma{
public double area();
public double volume();
public String getNome();
}
38
30/10/2008
Exercicio
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
40
30/10/2008
41
30/10/2008
42
30/10/2008
43