Aula 06 - Conceitos OO 1

Prévia do material em texto

JAVA 
Orientação a Objetos 
Prof. M. Sc. Edgar Gurgel 
Orientação a Objetos 
 
v  A Programação Orientada a Objetos é uma forma 
de programação que se baseia na construção de 
classes e objetos destas classes, fazendo com que 
trabalhem em conjunto para que os propósitos da 
criação sejam atingidos; 
O que é Orientação a Objetos? 
2 
O que é uma Classe?(1/2) 
Orientação a Objetos 
v  A estrutura fundamental para definir novos objetos 
 é a classe. Uma classe é definida em código- 
 fonte, e possui nome, um conjunto de atributos e 
 métodos. 
 
v Por exemplo, em um programa que manipula 
formas geométricas, seria possível conceber uma 
classe denominada Retangulo: 
3 
O que é uma Classe? 
 Uma classe é um tipo de modelo que define como são 
os objetos que pertencem a esta classe. É como se fosse 
um projeto que os objetos devem seguir para serem 
considerados como pertencentes à classe. Neste projeto 
estão definidos as características (que chamamos de 
atributos) e os comportamentos que representam as 
operações que os objetos dessa classe podem realizar 
(chamamos a isso de métodos). 
4 
Exemplos de Classes 
 Os animais podem ser classificados em 
classes, tais como mamíferos, aves, peixes, etc. 
Cada uma dessas c l asses t em suas 
características e comportamentos comuns, que 
poderiam ser relacionados (descritos) como 
atributos e métodos dessas classes. 
5 
Orientação a Objetos 
Retangulo public class Retangulo 
{ 
 
 
 
} 
Código em Java UML 
O que é uma Classe?(2/2) 
6 
Atributos, ou Propriedades(1/4) 
❚  As classes podem ter zero, um ou mais atributos, 
que são variáveis destinadas a armazenar 
informações intrinsecamente associadas aos 
objetos representados. 
 
Orientação a Objetos 
7 
Exemplos de atributos 
 Uma classe pessoa, por exemplo, pode ter 
atributos como nome, endereço, identidade, ou 
seja, características (dados) específicas de cada 
pessoa. 
8 
Orientação a Objetos 
Retangulo public class Retangulo 
{ 
 public int base; 
 public int altura; 
} 
Código em Java 
UML 
+ base: int 
+ altura: int 
Atributos, ou Propriedades (2/4) 
•  Esta classe possui dois atributos 
9 
 A sintaxe utilizada para definir um atributo de um objeto é: 
 
 [modificador] tipo nome [ = default]; 
onde: 
• modificador (opcional), uma combinação de especificador de acesso (public, 
 protected ou private); final e static. 
• tipo deve ser um dos tipos de dados da linguagem Java ou o nome de uma 
 classe. 
• nome deve ser um identificador válido. 
• default (opcional) é a especificação de um “valor inicial” para a variável. 
 
exemplos de declarações: 
public int campoInt; // atributo com acesso público do tipo inteiro 
protected boolean campoBoolean; // atributo com acesso protegido do tipo lógico 
private char campoChar; // atributo com acesso privado do tipo char 
Atributos, ou Propriedades (3/4) 
Orientação a Objetos 
10 
private Apenas a própria classe tem acesso 
protected O membro pode ser acessado pela 
 própria classe ou por subclasses ou 
 classes no mesmo pacote (package) 
final Declara que é constante 
static Declara que é uma variável de classe 
 mesmo valor para todas as instâncias 
“default”, “frendily” A própria classe e demais classes do 
 mesmo pacote tem acesso 
public Acesso completo a todas as classes 
Atributos, ou Propriedades (4/4) 
Orientação a Objetos 
11 
Métodos, ou operações (1/4) 
v  Enquanto os atributos permitem armazenar dados 
associados aos objetos, ou seja, valores que 
descrevem a aparência ou o estado de um certo 
objeto, os métodos (methods) ou funções-membro 
realizam operações sobre os atributos de uma 
classe. 
Orientação a Objetos 
12 
Exemplos de métodos 
 Uma classe peixe pode ter um método nadar, 
uma classe pessoa pode ter um método andar 
ou um método fa la r , po is es tes são 
comportamentos (ações) típicos destas classes. 
13 
Métodos, ou operações (2/4) 
Orientação a Objetos 
public class Retangulo { 
 public static int base=5; 
 public static int altura=7; 
 
 public static void exibeArea( ) 
 { 
 System.out.println("A área do retângulo é :"+(base*altura)); 
 } 
 
 public static void exibePerimetro( ) 
 { 
 System.out.println("O Perímetro do retângulo é :"+(2*base+2*altura));} 
 } 
Código em Java Retangulo 
+ base: int 
+ altura: int 
+ exibeArea( ):void 
+ exibePerimetro( ):void 
UML 
14 
A forma genérica para a definição de um método em uma classe é a seguinte: 
 
 [modificador] tipo nome([parâmetros]) { 
 // Corpo do Método 
 } 
onde: 
• modificador (opcional), uma combinação de especificador de acesso (public, 
 protected ou private); abstract ou final e static. 
• tipo é um indicador do valor de retorno (void quando o método não possuir um 
 valor de retorno = procedimento). 
• nome do método deve ser um identificador válido. 
• parâmetros (opcional) são representados por uma lista de parâmetros separados 
 por vírgulas, onde cada parâmetro obedece à forma: tipo nome. 
 
Métodos são essencialmente subrotinas que podem manipular atributos de objetos para os quais o método 
foi definido. Além dos atributos de objetos, métodos podem definir e manipular variáveis locais; também 
podem receber parâmetros por valor através da lista de argumentos. Uma boa prática de programação é 
manter a funcionalidade de um método simples, desempenhando uma única tarefa. O nome do método 
deve refletir de modo adequado a tarefa realizada. 
Orientação a Objetos 
15 
Modificadores para métodos 
private Apenas a própria classe tem acesso 
static Método da classe. Não é necessária uma 
 instância para executá-lo 
final O Método não pode ser polimorfizado 
 por subclasses 
abstract Não tem implementação e precisa ser 
 um membro de uma classe abstract 
“default”, “frendily” A própria classe e demais classes do 
 mesmo pacote tem acesso 
public Acesso completo a todas as classes 
Métodos, ou operações (4/4) 
16 
v  Objeto é uma instância de uma classe, é uma 
variável do tipo de dados definida pela classe. 
v  Um programa orientado a objetos é composto 
por um conjunto de objetos que interagem 
através de "trocas de mensagens". Na prática, 
essa troca de mensagem traduz-se na invocação 
de métodos entre objetos. 
O que é um Objeto? (1/2) 
Orientação a Objetos 
17 
O que é um objeto? 
l  C o m o v i m o s , u m a c l a s s e é u m a 
representação de uma entidade do mundo 
real; 
 
l  Um objeto é uma ocorrência (chamamos a 
isso de uma instância) de uma determinada 
classe. 
18 
Exemplos de objetos 
l  Matheus é um objeto da classe pessoa; 
l  Thor (o peixe do Matheus) é um objeto da classe 
peixe; 
 
19 
Outros exemplos de objetos 
Classes Objetos 
 
Carro 
Gol 
Palio 
Corsa 
 
Empregado 
João 
Maria 
Carlos 
 
Formulário 
Demissão 
Cadastro 
Vendas 
20 
Interface, mensagens e 
encapsulamento 
l  Vamos explorar os conceitos de O.O. Como vimos, 
podemos ter carro como sendo uma classe; 
l  As características ou atributos poderiam ser a cor, o 
modelo, a potência do motor e assim sucessivamente; 
l  Os comportamentos ou funcionalidades, poderiam ser ligar 
e desligar, abrir e fechar a porta, acelerar e frear, e outras 
ações (operações) que fossem consideradas úteis para 
descrever um carro. 
21 
Interface 
l  Os atributos e métodos da classe carro 
constituem o que chamamos de interface dessa 
classe com o mundo externo; 
lUm objeto da classe carro só será acessível por 
outro objeto através de seus métodos, de forma 
que a interface da classe carro deve definir todos 
os comportamentos desejáveis a um objeto 
desta classe. 
22 
Encapsulamento 
l  O fato dos objetos esconderem sua forma de funcionamento 
é um conceito importante em OO, e está ligado à existência 
da interface. Somente a classe carro conhece a forma de 
funcionamento (implementação) de seus métodos. É o que 
chamamos de encapsulamento. 
l  Ou seja, conhecemos as características e as funcionalidades 
de um carro, mas não sabemos (nem precisamos saber) 
quais técnicas e processos os projetistas utilizaram para a 
construção do projeto, ou seja para implementar a forma de 
funcionamento de seus métodos. 
23 
Encapsulamento 
l  Encapsulamento está intimamente ligado ao conceito de 
“esconder informação” (information hiding); 
l  define quais partes de um objeto estão visíveis 
(pública) e quais partes estão escondidas (privada); 
l  extremamente útil quando da alteração do código 
(promove reusabilidade). 
§  o código pode ser utilizado como uma “caixa 
preta”; 
24 
Encapsulamento em Java 
l  Java suporta o conceito de módulos, possibilitando a 
carga dinâmica destes de qualquer parte da Internet; 
25 
Encapsulamento Resumo 
•  private: esconde os membros do resto do mundo. 
Faça isso para os membros que são usados apenas 
pela própria classe. (Classe) 
•  public: membros serão visíveis por todos. (Classe, 
Subclasses e Instâncias) 
•  protected: membros visíveis para as subclasses e 
para as classes dentro de um mesmo pacote. 
(Classe, Subclasses) 
•  visibilidade padrão: todos os membros que fazem 
parte do mesmo pacote. (Pacote) 
26 
Visibilidade 
27 
Mensagens 
l  Uma vez que tenhamos definido a interface da classe carro e que 
tenhamos um objeto dessa classe, como fazer para que ele execute a 
operação ligar? Devemos enviar uma mensagem para esse carro 
(ligue!) e ele executará a operação. Nós (externamente ao objeto) é 
que pedimos ao objeto para que execute essa operação, sem precisar 
saber como o carro faz para ligar (que tipo de algoritmo ele usa para 
isso); 
l  O mesmo ocorre se quisermos saber a cor do carro. Simplesmente 
perguntamos (qual é a sua cor?) e o carro responde (naturalmente 
precisaríamos ter criado um método que respondesse a isso). Onde e 
como ele armazena a informação da cor não é relevante. Apenas 
sabemos que ele é capaz de armazenar seus atributos e informá-los 
quando necessitarmos deles. 
28 
Um objeto é uma entidade que possui: 
1. atributos, ou propriedades, que descrevem o estado 
de um objeto no mundo real; 
2. ações, ou métodos, que representam os processos 
associados ao objeto no mundo real; 
3. um identificador , ou nome , que designa 
univocamente o objeto na representação. 
Composição do Objeto (2/2) 
Orientação a Objetos 
29 
Instanciando uma Classe (1/2) 
v  Uso do operador new: 
 
 Retangulo R; 
R R = new Retangulo(); 
base = 0 
altura =0 
 
base = 7 
altura =5 
Exemplos de acesso aos dados: 
R.base = 7; 
R.altura = 5; 
this 
Retangulo 
+ base: int 
+ altura: int 
+ exibeArea():void 
+ exibePerimetro():void 
Orientação a Objetos 
30 
Instanciando uma Classe (2/2) 
Orientação a Objetos 
public class Retangulo { 
 public static int base=5; 
 public static int altura=7; 
 
 public static void exibeArea( ) 
 { 
 System.out.println("A área do retângulo é :"+(base*altura)); 
 } 
 
 public static void exibePerimetro( ) 
 { 
 System.out.println("O Perímetro do retângulo é :”+(2*base + 
2*altura));} 
 } 
Retangulo 
+ base: int 
+ altura: int 
+ exibeArea( ):void 
+ exibePerimetro( ):void 
UML 
31 
Instanciando uma Classe (2/2) 
Orientação a Objetos 
public class UsaRetangulo 
{ 
 public static void main (String args[]) 
 { 
 Retangulo r1 = new Retangulo(); 
 
 System.out.print("\n**Retangulo r1**"); 
 System.out println("\nBase: " + "" + r1.base); 
 System.out.println("Altura: " + "" + r1.altura); 
 } 
} 
32 
Acessando Dados e Métodos de um Objeto 
v  Usa-se o objeto seguido de um ponto antes do nome do dado ou do 
método para poder acessá-lo: 
 Retangulo r1 = new Retangulo(); 
 
 base = 7; 
 altura = 5; 
r1 
 
base = 7 
altura= 5 
this 
Retangulo 
+ base: int 
+ altura: int 
+ exibeArea():int 
+ exibePerimetro():void 
area = 35 
R1.exibeArea(); 
Orientação a Objetos 
33 
public class UsaRetangulo 
{ 
 public static void main (String args[]) { 
 Retangulo r1 = new Retangulo(); 
 
 System.out.print("\n**Retangulo r1**"); 
 System.out.println("\nBase: " + "" + r1.base); 
 System.out.println("Altura: " + "" + r1.altura); 
 
 r1.exibeArea(); 
 r1.exibePerimetro(); 
 } 
} 
Acessando Dados e Métodos de um Objeto 
Orientação a Objetos 
34 
Criação de Objetos 
v  A seguinte sentença realiza três ações: 
Circulo c = new Circulo(); 
v  Declaração 
v  Declarações não criam objetos! 
v  Instanciação 
v  new é um operador que cria dinamicamente um novo 
objeto. Ele requer um único argumento: uma chamada a 
um construtor. 
v  Inicialização 
v  Chamada ao construtor da classe Circulo. 
35 
Representação do problema - 
UML 
l  Para estudarmos a Programação Orientada a Objetos (POO), é 
necessário que entendamos a Modelagem Orientada a Objetos (MOO); 
l  Essa técnica representa as estruturas através de uma linguagem 
padrão, conhecida como UML (Unified Modeling Language), usada 
para a criação de modelos que representam os problemas do mundo 
real. A UML classifica os “objetos” envolvidos no domínio do problema 
e define as formas como os mesmos se relacionam. Não é o nosso 
foco uma abordagem profunda dos conceitos e ferramentas da UML. 
Utilizaremos apenas os principais elementos da MOO, que são 
necessários para dar andamento à POO. 
36 
Representação do problema - UML 
l  Na UML as classes são representadas 
na forma de caixas com, no máximo, 
três compartimentos. O primeiro deles 
contém o nome da classe (sempre no 
singular e com a primeira letra em 
maiúsculo), o segundo contém a lista 
de atributos e o terceiro contém a lista 
de operações. Veja a classe carro: 
l  A UML (e o Java) sugere que todos os 
nomes de atributos e métodos se 
iniciem com letra minúscula. Na classe 
Carro foram criados três atributos: dois 
do tipo String, marca e cor e o terceiro, 
motorEstado, é um booleano que 
indica se o motor está desligado ou 
ligado. 
37 
Representação do problema - UML 
l  Além dos atributos da classe, queremos também criar métodos que 
contenham as operações que objeto poderá realizar. Um carro pode fazer 
muitas coisas, mas, para manter a simplicidade, vamos criar inicialmente 
apenas três métodos: 
l  O primeiro é o método ligaMotor, que muda o estado do motor para 
ligado, isto é, para true e depois exibe uma mensagem de aviso. 
l  O segundo é o método desligaMotor, que muda o estado do motor 
para desligado, isto é, para false e depois exibe uma mensagem de 
aviso. 
l  O terceiro método, mostraAtributos, exibe os valores dos atributos de 
um objeto ou instância da classe Carro. 
38 
Exemplo: 
l  Edite o texto abaixo que contém os atributos e métodos da classe Carro: 
 public class Carro { 
 String marca; 
 String cor; 
 boolean motorEstado; 
 
 void ligaMotor() { 
 motorEstado = true; 
 System.out.println("O motor foi ligado."); 
 } 
 void desligaMotor() { 
 motorEstado = false; 
 System.out.println("O motor foi desligado."); 
 } 
 void mostraAtributos() { 
 System.out.println("Ocarro tem a cor " + cor + "e eh da marca " + marca); 
 if (motorEstado == true) 
 System.out.println("O motor ja esta ligado."); 
 else { 
 System.out.println("O motor esta desligado."); 
 } 
 } 
} 
 
39 
Exemplo(Continuação) 
l  Crie também um objeto dessa classe. Em Java podemos fazer isso 
adicionando o método main à classe Carro e nele instanciando 
efetivamente um objeto da classe Carro (comando new). 
 
public static void main (String args[]) { 
 Carro meuCarro = new Carro(); // instancia o objeto 
 meuCarro.marca = "Palio"; // inicia o atributo marca 
 meuCarro.cor = "azul"; // inicia o atributo cor 
 System.out.println("Mostrando os atributos:"); 
 meuCarro.mostraAtributos(); //mensagem para o objeto 
 
 System.out.println("---------"); 
 System.out.println("Ligando o motor..."); 
 meuCarro.ligaMotor(); //mensagem para ligar o carro 
 System.out.println("Mostrando os atributos:"); 
 meuCarro.mostraAtributos(); 
 
 System.out.println("---------"); 
 System.out.println("Desligando o motor..."); 
 meuCarro.desligaMotor(); 
 System.out.println("Mostrando os atributos:"); 
 meuCarro.mostraAtributos(); 
} 40 
Exercício 1 
l  1. Crie o objeto outroCarro da classe carro com a marca Gol e a cor prata; 
l  2. Insira um novo atributo rotacaoMotor e inicie-o com zero. O método 
ligaMotor deve atualizar esse atributo para 1000 e o método desligaMotor 
deve atualizá-lo para zero.; 
l  3. Crie um novo método acelerar que some 100 ao valor corrente do atributo 
rotacaoMotor. Crie também o desacelerar, que subtraia 100; 
l  4. A partir do arquivo criado, desmembre-o em dois. O arquivo já existente, 
de nome Carro, só com a classe Carro sem o método main. E outro arquivo, 
denominado principal, só com o método main; 
l  5. Crie uma classe Figura que possui os seguintes atributos do tipo inteiro: 
base e altura. E possui também o método Area( ) que calcula a área 
multiplicando a base pela altura. Escreva uma classe UsaFigura para: 
instanciar dois objetos, calcular a área de um retângulo e para calcular a 
área de um triângulo. Exiba os valores dos atributos e das áreas. Atribua 
valores à base e a altura dos objetos. 41 
Operador this 
l  Podemos utilizar nomes diferentes para os atributos e para os 
parâmetros, entretanto, isso não favorece a compreensão, na medida que 
alguns nomes de argumentos são bastante esclarecedores do seu 
conteúdo e criar um nome correspondente talvez não seja a melhor 
solução. Porém, razões sintáticas nos fizeram utilizar os sinônimos, pois 
se o argumento sn, por exemplo, fosse chamado sobrenome, teríamos o 
comando de atribuição: 
 
 sobrenome = sobrenome; 
 
l  O que não seria corretamente compreendido pelo compilador. Neste caso 
estamos diante de uma sobrecarga de nome e o compilador resolve isso 
escolhendo a referência mais próxima (a que foi definida por último). 
Portanto, a variável sobrenome referenciada nesse comando não seria o 
atributo da classe e sim o argumento do método (o último definido); 
Operador this 
l  Quando declaramos os argumentos com nomes “parecidos” com os 
atributos da classe, isto pode gerar alguns problemas; 
l  Fazendo da forma abaixo, fica claro que o argumento é uma variável e o 
atributo é outra, como, por exemplo, em: 
 public EmpComissionado (String n, String sn, 
 String cic, double vendas,double comissao) 
 { 
 nome = n; 
 sobrenome = sn; 
 cpf = cic; 
 setTotalVendas (vendas); 
 setTaxaComissao (comissao); 
 } 
Operador this 
l  Soluciona-se isso usando o operador this, que faz referência ao objeto atual 
(objeto corrente ao tempo da execução); 
l  Assim o trecho de programa anterior poderia ser mais elegantemente 
definido assim: 
 public EmpComissionado (String nome, String sobrenome, 
 String cpf, double totalVendas,double taxaComissao){ 
 this.nome = nome; 
 this.sobrenome = sobrenome; 
 this.cpf = cpf; 
 setTotalVendas (totalVendas); 
 setTaxaComissao (taxaComissao); 
 } 
l  O mesmo se aplica aos demais métodos, como, por exemplo, aos métodos 
set dos atributos das classes. 
Criando objetos com o uso 
de construtores 
l  A criação do método configurarCarro foi uma boa idéia para melhorar o encapsulamento 
da classe. Entretanto, ainda não é a melhor forma de iniciar os valores dos atributos. 
Melhor seria utilizarmos um método especial, que chamamos Construtor. O construtor de 
uma classe é um método automaticamente chamado quando instanciamos um objeto 
dessa classe. Em Java, o método construtor tem o mesmo nome da classe e é chamado 
quando usamos o comando new. Reparando bem, no exemplo da classe carro temos: 
new Carro(); o que sugere que estamos chamando um método chamado Carro (o uso 
dos parêntesis é um indicativo disso). Entretanto onde está este método que não foi 
declarado? A resposta é que a linguagem pressupõe que toda classe tem um construtor 
padrão (default), que não possui argumentos e inicia os atributos numéricos com zero e 
os atributos lógicos com false. Entretanto, podemos definir explicitamente o construtor da 
classe, fazendo com que ele seja responsável pela iniciação de atributos da classe com 
valores distintos dos valores padrão. Assim, podemos ter: 
 public Carro() { 
 marca = "Palio"; 
 cor = "azul"; 
 motorEstado = true; 
 rotacaoMotor = 1000; 
 } 
Criando objetos com o uso 
de construtores 
l  Bem, o construtor é um método como os demais e, portanto, também pode receber 
argumentos. Assim, poderíamos melhorar o nosso construtor permitindo que 
recebesse como parâmetros os valores a serem postos inicialmente em alguns 
atributos. Um código possível seria: 
 public Carro(String m, String c) { 
 marca = m; 
 cor = c; 
 motorEstado = true; 
 rotacaoMotor = 1000; 
 } 
l  Uma classe pode possuir mais de um construtor. Eles devem ter o mesmo nome e 
diferenciar-se apenas pelo número de argumentos que recebem. Isto é chamado de 
sobrecarga de construtor. Desta forma, podemos ter diferentes construtores, 
permitindo flexibilizar a criação e a iniciação dos atributos dos objetos em diferentes 
situações que se façam necessárias. 
Criação de Objetos 
 
Escrevendo Construtores: Sobrecarga 
public class Circulo 
{ public double x, y, r; 
 
 Circulo(double x, double y, double r) 
 { this.x = x; this.y = y; this.r = r; } 
 
 Circulo(double r) 
 {x = 0.0; y = 0.0; this.r = r; } 
 
 Circulo() 
 { x = 0.0; y = 0.0; r = 0.0; } 
 // ...o restante da classe... 
} 
47 
Sobrecarga 
l  Podemos criar uma instância da classe Circulo 
usando qualquer um dos construtores: 
 
l  Circulo c = new Circulo( ); 
l  Circulo d = new Circulo(3.0); 
l  Circulo e = new Circulo(1.0, 3.4, 7.5); 
 
OBS: Java automaticamente cria o construtor padrão (sem 
parâmetros) caso nenhum seja definido! 
48 
Encadeamento de Construtores 
public class Circulo 
{ public double x, y, r; 
 Circulo(double x, double y, double r) 
 { this.x = x; this.y = y; this.r = r; } 
 Circulo(double r) 
 { this(0.0, 0.0, r); } 
 Circulo() 
 { this(0.0, 0.0, 0.0); } 
 // ...o restante da classe... 
} 
O apontador this, indica membros da própria instância ou classe. 
49 
Sobrecarga 
l  Permite a criação de métodos polimórficos; 
l  É possível utilizar a sobrecarga com qualquer método; 
l  Métodos são diferenciados pelos parâmetros: 
l  int soma(int a, int b) 
l  int soma(int a) 
l  int soma(double b) 
50 
Sobrecarga 
l  Também existe sobrecarga nos operadores: 
l  1 + 2 
l  3.1 + 4.7 
l  “Concatenação” + “ de ” + “strings” 
l  “A soma é igual a ” + (3 + 4) 
51 
Destruição de Objetos 
l  Em Java, não podemos destruir objetos! 
l  Javautiliza um Coletor de Lixo (Garbage Collector) 
l  O coletor se encarrega de se livrar (liberar memória) 
dos objetos que não são mais necessários no 
programa; 
l  O Garbage Collector é uma Thread de baixa 
prioridade, que é executada sempre que a CPU não 
estiver sendo tão utilizada; 
52 
 
l  Construtor 
l  criação / inicialização 
l  Método que atribui valores default (padrões) 
para os atributos de um objeto. 
l  Destrutor 
l  término 
l  Método que libera o espaço ocupado pelo objeto 
da memória. 
Métodos Especiais 
53 
 
 
Exercício 2 
54 
1.  Crie dois construtores para inicializar os atributos da classe Figura. 
2.  Crie uma classe Livro, que possua atributos para nome, autor, edição, 
editora e ano de publicação. Os atributos devem ser privados e devem 
possuir métodos de acesso. Deve haver um método que imprime os 
atributos correntes do livro. Deve haver um construtor padrão que inicia os 
atributos com o valor “desconhecido” e a seguir imprime uma mensagem de 
saudação com os atributos correntes. Deve haver mais um construtor 
alternativo para instanciar os objetos da classe Livro com os respectivos 
parâmetros correspondentes aos atributos. Adicionalmente, crie um 
programa principal que instancie diferentes livros chamando os diferentes 
construtores. 
 
Exercício 2 
l  3. Crie uma classe Círculo, com membros de dados raio e diâmetro do tipo 
double. Esta classe ainda deve ter um método chamado circunferência() e 
outro área(), alem de dois construtores. Você deve instanciar dois objetos 
(c e d) desta classe Círculo, com dois construtores. O primeiro construtor 
não deve receber nenhum parâmetro e deve inicializar o raio com o valor 1 
e o diâmetro com o valor 2. O segundo construtor deve receber os valores 
2.0 e 4.0 como parâmetros. 
55 
Métodos Get e Set 
l  Getters e Setters são métodos criados para acessar 
atributos de classes com definição private, ou seja, 
atributos privados que somente estes métodos terão 
acesso. Caso os metodos sejam declarados como 
public, toda a aplicação teria acesso, tornando esses 
atributos nada seguros, por isso a importância de 
getters e setters; 
l  Get retorna o valor do membro de dados do objeto e 
Set aplica um valor ao membro de dados de um 
objeto. 
56 
Métodos – get e set 
l  Além de passarmos parâmetros para os métodos de uma classe durante uma 
mensagem, podemos também receber dados dos métodos chamados. Uma forma 
de fazê-lo é definir um valor de retorno para um método chamado. Os campos 
private de uma classe só podem ser manipulados por métodos dessa classe. 
Qualquer objeto de outra classe (um cliente, portanto), que deseje acessar um 
campo private da classe servidora, deve chamar os métodos public que a esta 
ofereça para manipular seus campos private. As classes costumam oferecer 
métodos public para permitir aos clientes da classe configurar (set - atribuir) ou 
obter (get - obter) valores das variáveis private. Os nomes desses métodos não 
precisam começar com set ou get, mas essa convenção de atribuição de nomes é 
altamente recomendada em Java. Por exemplo, podemos criar um método 
getRotacaoMotor que retorne o valor do atributo rotacaoMotor. Assim: 
 int getRotacaoMotor () { 
 return rotacaoMotor; 
 } 
l  Para chamarmos o método, poderíamos usar este código: 
 System.out.println("Rotacao do motor = " + 
 meuCarro. getRotacaoMotor () + " RPM."); 
l  Da mesma forma, caso quiséssemos criar um método setRotacaoMotor que 
configurasse o valor do atributo rotacaoMotor, ele seria assim: 
 int setRotacaoMotor(int r) { 
 rotacaoMotor = r; 
 } 
l  e a atribuição de uma valor à rotação teria, portanto, a seguinte sintaxe: 
 meuCarro.setRotacaoMotor(1000); 
Métodos – get e set 
Exercício 3 
l  Crie métodos set e get para todos os atributos private da classe Carro. 
l  Para a classe Dimensao, criada no exercício da aula passada, crie também 
métodos get e set para os atributos base e altura. 
l  Crie os métodos get e set dos atributos que se fizerem necessários para a classe 
Livro. 
Exercícios 
Exercícios da Lista 6 
60 
Herança 
l  O conceito de herança permite estabelecer uma hierarquia entre as 
classes. É um mecanismo que permite a uma classe herdar as 
operações e os atributos de outra classe. Com o uso da herança, 
quando se escreve uma classe é necessário especificar apenas no 
que ela é diferente da classe-mãe, classe-base ou superclasse. O 
mecanismo da herança dá acesso automático às informações 
contidas na classe base. Através da herança, uma classe possui 
imediatamente toda a funcionalidade de uma classe já existente. A 
classe que herda características da outra é chamada subclasse ou 
classe-filha e a classe que fornece a herança é chamada 
superclasse ou classe-mãe; 
l  A herança é, portanto, o compartilhamento de atributos e operações 
entre classes, baseado em um relacionamento hierárquico do tipo 
pai-filho (ou mãe-filho), em que a classe pai possui definições que 
podem ser utilizadas nas classes filhas. Estas funcionam como uma 
especialização da classe pai (as filhas estendem a sua utilização 
básica da classe pai para outras utilizações mais especializadas).; 
Herança 
 A seguir uma figura ilustrativa do conceito de 
herança: 
 
Herança 
l  Uma superclasse direta é a superclasse a 
p a r t i r d a q u a l a s u b c l a s s e h e r d a 
explicitamente; 
l  Uma superclasse indireta é qualquer 
superclasse acima da superclasse direta; 
l  Desta forma, no exemplo acima, Mamifero é 
uma superclasse direta de SerHumano e 
Animal é uma superclasse indireta de 
SerHumano. 
Herança em Java 
l  Todas as classes, tanto as que são escritas pelo programador quanto 
aquelas da biblioteca de classes do Java, são organizadas em uma 
hierarquia. No topo da hierarquia de classes está a classe Object; 
l  Todas as classes são herdeiras desta superclasse. Object é a classe 
mais geral da hierarquia, ela define o comportamento herdado por 
todas as classes da hierarquia de classes do Java; 
l  Em Java, uma classe pode ter apenas uma superclasse (Java não 
suporta herança múltipla, como a existente em C++, por exemplo), 
mas cada classe pode ter um número ilimitado de subclasses. Se a 
superclasse tiver comportamentos e atributos que sua classe precisa, 
você não precisa redefini-la ou copiar esse código para ter o mesmo 
comportamento e atributos. Sua classe recebe automaticamente as 
características de sua superclasse. Essa superclasse também recebe 
da sua superclasse e assim por diante, formando uma cadeia até o 
inicio da hierarquia. Sua classe é, portanto, uma combinação de 
todos os recursos das classes que estão acima dela na hierarquia, 
assim como de seus próprios recursos. 
Herança em Java 
l  Em Java, indicamos que uma classe herda características de 
outra através da palavra reservada extends; 
l  O código abaixo ilustra isso: 
public class Animal { 
 ... 
} 
public class Mamifero extends Animal { 
 ... 
} 
Herança em Java 
l  Vamos ver o exemplo da classe 
Carro. Poderíamos criar um projeto 
com uma classe mais geral 
chamada Veículo. A figura ao lado 
ilustra como poderíamos estruturar 
o projeto; 
l  Na classe Veículo definiríamos 
a p e n a s c a r a c t e r í s t i c a s o u 
operações comuns a qualquer 
subclasse, tais como: cor, marca, 
etc. Abaixo da classe Veículo, as 
subclasses Carro e Caminhão 
teriam atributos e operações 
específicos de cada uma; 
l  Utilizando a herança é possível 
definir uma característica ou uma 
operação apenas uma vez na 
hierarquia. A partir daí ela é 
reutilizada automaticamente por 
cada subclasse; 
Herança em Java 
l  Quando se cria uma nova instância de uma classe,é criado 
um espaço para cada atributo definido na classe corrente e 
nas superclasses; 
 
l  Os métodos funcionam de modo semelhante: os novos 
objetos têm métodos de acesso a todos os nomes de 
métodos de sua classe e de suas superclasses. Isso é 
determinado dinamicamente, quando um método é utilizado 
em um programa que está em execução. Ao chamar um 
método de um objeto em particular, o interpretador Java 
procurará primeiramente na classe do objeto por esse 
método. Se o método não for encontrado, o interpretador 
procurará na superclasse dessa classe e assim por diante, 
até que a definição do método seja encontrada; 
Herança em Java 
l  Suponhamos, por exemplo, que tenha sido declarada a 
seguinte classe: 
 class Poligono{ 
 int cx, cy; // coordenadas do centro do polígono 
 } 
 
l  Agora suponhamos que pretendamos criar uma classe que 
tenha as dimensões do quadrado, além das coordenadas 
do centro. Basta fazer: 
 class Quadrado extends Polígono { 
 int lado; // Comprimento do lado do quadrado 
 } 
Herança em Java 
l  A classe Quadrado é uma classe derivada da classe Polígono, da 
qual herda todos os atributos e os métodos nela contidos; 
l  Um problema com herança é que uma subclasse pode herdar 
métodos que ela não necessita ou que não deveria ter. Mesmo 
quando um método é adequado a uma subclasse, essa subclasse 
precisa freqüentemente de uma versão personalizada de um método; 
l  Nesses casos, a subclasse pode sobrescrever (redefinir) o método da 
superclasse com uma implementação mais adequada; 
l  Observações sobre acessibilidade na estrutura de herança: 
l  Todos os membros de superclasse public e protected mantêm seu 
modificador de acesso quando se tornam membros da subclasse; 
l  Os métodos de subclasse podem referir-se a membros public e 
protected herdados da superclasse simplesmente utilizando os 
nomes dos membros. Quando um método de subclasse 
sobrescrever um método de superclasse, o método da 
superclasse pode ser acessado a partir da subclasse precedendo 
o nome do método da superclasse com a palavra-chave super e o 
separador (.); 
Herança em Java 
l  P a r a o b s e r v a r m o s u m 
r e l a c i o n a m e n t o e n t r e 
superclasse e subclasse, 
utilizaremos uma hierarquia 
de herança que contém tipos 
de empregados em um 
a p l i c a t i v o d e f o l h a d e 
pagamento; 
l  Na empresa, os empregados 
comiss ionados recebem 
apenas uma porcentagem 
(comissão) de suas vendas, 
enquanto que os empregados 
fixos comissionados recebem 
um salário base mais a 
comissão; 
Herança em Java 
l  Vamos inicialmente criar a superclasse EmpComissionado em um 
arquivo de mesmo nome da classe, portanto, 
 
EmpComissionado.java. 
//Classe Empregado Comissionado 
public class EmpComissionado{ 
 private String nome; 
 private String sobreNome; 
 private String cpf; 
 private double totalVendas; 
 private double taxaComissao; 
 
 // Construtor com 5 argumentos 
 public EmpComissionado (String nome, String sobreNome, 
 String cpf, double totalVendas,double taxaComissao) 
 { 
 setNome(nome); 
 setSobrenome(sobreNome); 
 setCpf(cpf); 
 setTotalVendas(totalVendas); 
 setTaxaComissao(taxaComissao); 
 } 
 
Herança em Java 
 public void setNome(String nome){ 
 this.nome = nome; 
 } 
 public String getNome(){ 
 return nome; 
 } 
 public void setSobrenome(String sobreNome){ 
 this.sobreNome = sobreNome; 
 } 
 public String getSobrenome(){ 
 return sobreNome; 
 } 
 public void setCpf(String cpf){ 
 this.cpf = cpf; 
 } 
 public String getCpf(){ 
 return cpf; 
 } 
Herança em Java 
public void setTotalVendas(double totalVendas){ 
 this.totalVendas = (totalVendas < 0.0) ? 0.0 : totalVendas; 
 } 
 public double getTotalVendas (){ 
 return totalVendas; 
 } 
 public void setTaxaComissao(double taxaComissao){ 
 this.taxaComissao = (taxaComissao < 0.0) ? 0.0 : taxaComissao; 
 } 
 public double getTaxaComissao(){ 
 return taxaComissao; 
 } 
 
 // Calcula o salario 
 public double salario(){ 
 return getTaxaComissao() * getTotalVendas(); 
 } 
} // fim da classe Empregado Comissionado 
Herança em Java 
l  A seguir vamos, criar a subclasse EmpFixoComissionado, que 
herda todos os atributos e métodos da superclasse 
EmpComissionado; 
l  Observe que a subclasse chama alguns métodos da 
superclasse, a começar pelo próprio construtor desta (lembre-
se de colocar o código abaixo em um outro arquivo com o 
mesmo nome da classe). 
 
//Classe Empregado com salário base mais comissão 
public class EmpFixoComissionado extends EmpComissionado{ 
 
 private double salarioBase; // atributo exclusivo 
 // construtor da classe 
 public EmpFixoComissionado(String nome, String sobreNome, String cpf, double 
totalVendas, double taxaComissao, double salarioBase){ 
 // chama construtor da superclasse 
 super(nome,sobreNome,cpf,totalVendas,taxaComissao); 
 // chamada a método da própria classe 
 setSalarioBase(salarioBase); 
 } // termino do construtor da classe 
Herança em Java 
 public void setSalarioBase(double salarioBase){ 
 this.salarioBase = (salarioBase < 0.0) ? 0.0 : salarioBase; 
 } 
 
 public double getSalarioBase() { 
 return salarioBase; 
 } 
 // calcula o salário 
 public double salario(){ 
 return getSalarioBase() + super.salario(); 
 } 
} // fim da classe Empregado Fixo Comissionado 
Herança em Java 
l  Finalmente, vamos fazer uma aplicação que use as classes 
criadas (edite essa aplicação de teste em um terceiro arquivo, 
que deve se chamar Principal.java): 
// Testando a classe Empregado fixo com comissão 
public class Principal{ 
 // início do método main 
 public static void main(String args[]) { 
 
 // Instancia objeto da classe EmpComissionado 
 EmpComissionado EmpCom = new EmpComissionado("Ana","Alves","987654321-01",30000,0.03); 
 
 // Instancia objeto da classe EmpFixoComissionado 
 EmpFixoComissionado EmpFixoCom = new EmpFixoComissionado("Roberto","Silveira", 
 "123456789-10",20000,0.02,300); 
 
 // obtém os dados do Empregado Comissionado 
 System.out.println("Dados do Empregado Comissionado:\n"); 
 System.out.printf ("%s %s \n", "Nome: ", EmpCom.getNome() ); 
 System.out.printf ("%s %s \n", "Sobrenome: ", EmpCom.getSobrenome() ); 
 System.out.printf ("%s %s \n", "CPF: ", EmpCom.getCpf() ); 
 System.out.printf ("%s %.2f \n", "Vendas: ", EmpCom.getTotalVendas() ); 
 System.out.printf ("%s %.2f \n", "Comissao: ", EmpCom.getTaxaComissao() ); 
 System.out.printf ("%s %.2f \n", "Salario total: ", EmpCom.salario() ); 
Herança em Java 
// obtém os dados do Empregado Fixo Comissionado 
 System.out.println("\n\nDados do Empregado Fixo Comissionado:\n"); 
 System.out.printf ("%s %s \n", "Nome: ", EmpFixoCom.getNome() ); 
 System.out.printf ("%s %s \n", "Sobrenome: ", EmpFixoCom.getSobrenome() ); 
 System.out.printf ("%s %s \n", "CPF: ", EmpFixoCom.getCpf() ); 
 System.out.printf ("%s %.2f \n", "Vendas: ", EmpFixoCom.getTotalVendas() ); 
 System.out.printf ("%s %.2f \n", "Comissao: ", EmpFixoCom.getTaxaComissao() ); 
 System.out.printf ("%s %.2f \n", "Salario total: ", EmpFixoCom.salario() ); 
 System.out.printf ("%s %.2f \n", "Salario base: ", EmpFixoCom.getSalarioBase() ); 
 } // fim do método main 
} // fim da classe Principal 
Exercício 4 
78 
•  Criar a classe Cadastro para executar as instâncias Cliente (da classe 
Registro Cliente) e a instância Fornecedor (da classe Registro 
Fornecedor). Os dados devem ser informado através dos construtores. 
Exercício 5 
79 
1.  Altere a subclasse RegistroCliente adicionado 
atributos para local de trabalhoe telefone de 
contato; 
2.  Altere a subclasse RegistroFornecedor 
adicionando atributos para forma de pagamento, 
inscrição estadual e representante comercial; 
3.  Crie uma nova subclasse denominada 
RegistroTransportadora com os mesmos 
atributos da subclasse RegistroFornecedor e 
adicione-a à classe Cadastro.java 
Package (pacote) 
l  No desenvolvimento de pequenas atividades ou 
aplicações Java, é viável manter o código e suas 
classes no diretório corrente. No entanto, para grandes 
aplicações é preciso organizar as classes de maneira a:
 1. evitar problemas com nomes duplicados de classes; 
 2. localizar o código da classe de forma eficiente; 
l  Em Java, a solução para esse problema está na 
organização de classes e interfaces em pacotes 
(package); 
80 
Package (pacote) 
l  Um pacote ou package em Java nada mais é do que 
um conjunto de classes; 
l  Usualmente, são colocadas em um package classes 
relacionadas, construídas com um propósito comum; 
l  Assim, sob certos aspectos, os packages reproduzem 
a idéia das bibliotecas de código (libraries e unit’s), 
de outras linguagens de programação; 
81 
Pacotes 
l  Agrupam um conjunto de classes: 
l  grupo de classes relacionadas e, possivelmente, 
cooperantes; 
l  o pacote de uma classe é definido pela palavra-chave 
package; 
 
package geometrico; 
public class Circulo { ... } 
l  O arquivo que contém a classe (Circulo.java) deve estar 
no diretório geometrico. 
82 
Pacotes 
l  As classes que estão no mesmo pacote podem ser 
utilizadas diretamente no código fonte. 
package geometrico; 
public class Teste 
{ public static void main(String[] args) 
 { Circulo c = new Circulo(); 
 } 
} 
83 
Pacotes 
l  Para usar as classes de outros pacotes, deve-se indicar 
onde elas estão: 
package exemplo; 
import geometrico.Circulo; 
public class Teste 
{ public static void main(String[] args) 
 { Circulo c = new Circulo(); 
 } 
} 
84 
Pacotes 
l  Para usar as classes de outros pacotes, deve-se indicar 
onde elas estão: 
package exemplo; 
import geometrico.*; 
public class Teste 
{ public static void main(String[] args) 
 { Circulo c = new Circulo(); 
 Retangulo r = new Retangulo(); 
 } 
} 
pode-se indicar todas as 
classes de um pacote 
85 
Pacotes 
l  Pacotes podem conter outros pacotes: 
l  java.lang 
l  java.io 
l  company.library.graphic 
86 
Fim do Mistério 
l  Agora podemos entender melhor a instrução: 
System.out.println(“Um String aqui!”); 
classe definida 
em java.lang 
variável de classe 
do tipo PrintStream 
Método de instância 
da classe PrintStream 
Todas as classes que estão no pacote java.lang são 
automaticamente importadas. 
87