Introdução a Classes e Objetos

Prévia do material em texto

Introdução a classes e 
objetos
Prof. Marcelo Roberto Zorzan
Profa. Rachel Reis
Aula de Hoje
� Herança
Problema
� Considere uma empresa que tenha tipos de
empregados no aplicativo de folha de pagamento
� Um empregado tem nome, sobrenome, SSN, taxa
de comissão e venda brutade comissão e venda bruta
� Os empregados comissionados recebem uma
porcentagem de suas vendas
� Os empregados comissionados com saláriobase
recebem um salário-base mais a porcentagem de
suas vendas
Problema
// Métodos get/set
� É uma forma de reutilização de software na
qual uma nova classe é criada, absorvendo
membros de uma classe existente e
Herança
membros de uma classe existente e
aprimorada com capacidades novas ou
modificadas
� O programador pode designar que uma nova
classe (subclasse) herde membros de uma
classe existente (superclasse)
� Em outras palavras:
� Herança é o compartilhamento de atributos e
operações entre classes baseadas num
relacionamento hierárquico do tipo “Pai-Filho”, ou
Herança
relacionamento hierárquico do tipo “Pai-Filho”, ou
seja, a classe pai contém definições que podem
ser utilizadas nas classes definidas como filho.
� A classe Pai é conhecida como superclasse e as 
classes Filho são chamadas de subclasses.
� Herança Simples: uma classe é derivada de uma 
superclasse
Herança
� Herança múltipla: uma classe é derivada de 
mais de uma superclasse
� O Java NÃO permite herança múltipla
� Os membros private de uma superclasse não são
herdados pelas suas subclasses
� Os membros protected de uma superclasse
Membros protected
� Os membros protected de uma superclasse
podem ser acessados:
1) por membros da própria superclasse
2) por membros da sublcasse
3) por membros da classe no mesmo pacote
� Os métodos da subclasse podem referir-se a
membros public e protected herdados da
superclasse simplesmente utilizando os nomes do
membro
Exemplo de Herança
Veiculo superclasse
� Todos os carros são veículos, mas nem todos 
os veículos são carros.
Carro Aviao subclasses
Representação sem Herança
Veiculo
- cor
- marca
+ getCor;
+ getMarca;+ getMarca;
+ setCor
+ setMarcaCarro
- cor
- marca
- numeroMarcha
+ getCor;
+ getMarca;
+ setCor
+ setMarca
+ getNumeroMarcha
+ setNumeroMarcha
Aviao
- cor
- marca
- tipoDeAsas
+ getCor;
+ getMarca;
+ setCor
+ setMarca
+ getTipoAsas
+ setTipoAsas
Representação com Herança
Veiculo
# cor
# marca
+ getCor
+ getMarca
+ setCor+ setCor
+ setMarca
Carro
- marcaPneus
+ getMarcaPneus
+ setMarcaPneus
Aviao
- tipoDeAsas
+ getTipoAsas
+ setTipoAsas
� Os atributos da classe Veiculo devem usar o modificador 
de acesso protected para que as classes Carro e Avião 
possam herdá-los
Atributos da superclasse -
protected
1. public class Veiculo
2. { 
3. protected String cor;
4. protected String marca;
5. ...
19. }
� É melhor
– declarar os atributos do tipo protected
– ou declarar do tipo private usando os métodos get 
Pensar!
– ou declarar do tipo private usando os métodos get 
e set
� Herdar os atributos e os métodos da super-classe.
� Definir novos atributos e métodos.
� Modificar um método definido na super-classe.
Herança permite ... 
� Modificar um método definido na super-classe.
� Que um método da subclasse utilize um método da super-
classe. 
� Economizar linhas de código (reuso).
* Observação:
Um subclasse “herda” atributos e métodos de suas
superclasse e os utiliza como se fossem declarados dentro da
própria classe.
� Quando utilizar Herança?
� Regra: realizar a pergunta “É um?”
� Exemplos:
� Cavalo é um Animal ?
Herança = “É um” 
� Cavalo é um Animal ?
� Alface é um Vegetal?
� Gorgonzola é um Queijo? 
� Carro é um Veículo?
� Nem todo relacionamento de classe é um relacionamento 
de herança
� Existe o relacionamento “Tem um” em que as classes têm 
membros que são referências a objetos de outras classes
Outros exemplos de Herança
Pagamento
PagamentoEmCheque PagamentoEmCartao PagamentoEmDinheiroPagamentoEmCheque PagamentoEmCartao PagamentoEmDinheiro
Fruta
Fruta AmarelaFruta Vermelha
Morango Melancia Banana Maracuja
� Em Java todas as classes herdam da classe 
Object.
Herança em Java
Object
� Assim podemos dizer que 
� Cavalo é um Object
� Alface é um Object
� Gorgonzola é um Object
� Carro é um Object
Veiculo
Carro
� Uma classe pode ser declarada como uma 
subclasse de outra classe usando-se a palavra-
chave extends.
� Exemplo
Herança em Java
Object� Exemplo
public class Veiculo extends Object{
...
}
public class Carro extends Veiculo{
...
}
public class Aviao extends Veiculo{
...
}
- Carro é uma subclasse de Veiculo 
- Veiculo é uma superclasse de Carro
Veiculo
Carro Aviao
Object
Construtores em Subclasse 
Herança
� Construtores NÃO são herdados em subclasses
Construtores em Subclasse 
Herança
� Instanciar um objeto da subclasse inicia uma 
cadeia de chamadas de construtorcadeia de chamadas de construtor
� O construtor da subclasse, antes de realizar suas 
tarefas, invoca o construtor de sua superclasse
� Explícita (via super)
� Implicitamente (chamando construtor-padrão)
� A palavra chave super é sempre usada pelo
construtor das subclasses para chamar o construtor da
superclasse.
Palavra chave super
� Construtores de superclasses só podem ser
chamados de dentro de construtores de subclasses
(primeira linha de código)
� O acesso ao construtor da superclasse é útil para
aumentar a reutilização de código
public class Veiculo{ 
protected String cor;
protected String marca;
public Veiculo(String cor, String marca){ 
setCor(cor);
setMarca(marca);
}
}
Esse código compila?
public class Bicicleta extends Veiculo{
private boolean temCesta;
public Bicicleta(boolean temCesta,String cor,String marca)
{ 
setCor(cor);
setMarca(marca);
setTemCesta(temCesta);
}
}
Esse código compila?
public class Veiculo{ 
protected String cor;
protected String marca;
public Veiculo(String cor, String marca){ 
setCor(cor);
setMarca(marca);
}
}
Construtor da subclasse sempre chama o construtor da superclasse
public class Bicicleta extends Veiculo{
private boolean temCesta;
public Bicicleta(boolean temCesta,String cor,String marca)
{ 
setCor(corC);
setMarca(marcaC);
setTemCesta(temCesta);
}
}
Construtor da subclasse sempre chama o construtor da superclasse
Como???
public class Bicicleta extends Veiculo{
public class Veiculo{ 
protected String cor;
protected String marca;
public Veiculo(String cor, String marca){ 
setCor(cor);
setMarca(marca);
}
}
Na superclasse não
foi definido o construtor
Veiculo(){}
public class Bicicleta extends Veiculo{
private boolean temCesta;
public Bicicleta(boolean temCesta,String cor,String marca)
{ 
super(); //Ele procura pelo construtor Veiculo()
setCor(cor);
setMarca(marca);
setTemCesta(temCesta);
}
}
public class Veiculo{ 
protected String cor;
protected String marca;
public Veiculo(String cor, String marca){ 
setCor(cor);
setMarca(marca);
}
}
Que princípio da OO esse código está violando?
public class Bicicleta extends Veiculo{
private boolean temCesta;
public Bicicleta(boolean temCesta,String cor,String marca)
{ 
setCor(cor);
setMarca(marca);
setTemCesta(temCesta);
}
}
class Veiculo{ 
protected String cor;
protected String marca;
public Veiculo(String cor, String marca){ 
this.cor = cor;
this.marca = marca;
}
}
Código duplicadoPrincípio de reutilização de código.
public class Veiculo{ 
protected String cor;
protected String marca;
public Veiculo(String cor, String marca){ 
setCor(cor);
setMarca(marca);
}
}
class Bicicleta extends Veiculo{
private boolean temCestinha;
public Bicicleta(boolean temCesta,String cor,String marca)
{ 
this.cor = cor;
this.marca = marca;
this.temCesta = temCesta;
}
}
Princípio de reutilização de código.
class Bicicleta extends Veiculo{
private boolean temCestinha;
public Bicicleta(boolean temCesta,String cor,String marca)
{ 
setCor(cor);
setMarca(marca);
setTemCesta(temCesta);
}
}
class Veiculo{ 
protectedString cor;
protected String marca;
public Veiculo(String cor, String marca){ 
this.cor = cor;
this.marca = marca;
}
}
Usando a palavra chave super
Agora não é preciso mais 
declarar o construtor Veiculo()
public class Veiculo{ 
protected String cor;
protected String marca;
public Veiculo(String cor, String marca){ 
setCor(cor);
setMarca(marca);
}
}
A subclasse chama o 
construtor da superclasse 
para inicializar os atributos 
cor e marca.
class Bicicleta extends Veiculo{
private boolean temCesta;
public Bicicleta(boolean temCesta,String cor,String marca)
{ 
super(cor, marca);
this.temCesta = temCesta;
}
}
class Bicicleta extends Veiculo{
private boolean temCesta;
public Bicicleta(boolean temCesta,String cor,String marca)
{ 
super(cor, marca);
setTemCesta(temCesta);
}
}
� A palavra chave super permite também que uma
subclasse acesse os atributos ou métodos da
superclasse
Palavra chave super
class Superclass Super
{
public void metodo(int p) {
//Aqui tem um código que quero manter
}
}
public class Sub extends Super
{
public void metodo(int p){
super.metodo(p);
//Aqui adiciono mais funcionalidades para o código
}
}
� Para acessar um método da superclasse que também foi 
definido na subclasse : 
super.nomeDoMetodo(lista_de_parametros)
Palavra chave super
Veiculo
# cor# cor
# marca
Carro
- marcaPneus
+quantoCusta
+quantoCusta
� O método quantoCusta da classe
Carro sobrepõe o método com a
mesma assinatura que foi herdado
de Veiculo
� Para usar o método quantoCusta da
superclasse a seguinte chamada
deve ser feita: super.quantoCusta()
� Um classe filha (subclasse) pode fornecer uma outra
implementação para um método herdado, caracterizando
uma sobreposição (overriding) do método.
Sobreposição de métodos 
(override)
� Exemplo: Pai
imprime() :void
Filha
imprime() :void
class Pai {
public void teste() {
System.out.println(“Método da classe Pai”);
}
}
class Filha extends Pai{ Filha.java
Sobreposição de métodos
Pai.java
class Filha extends Pai{
}
class Principal {
public static void main(String args()) {
Pai p = new Pai(); // Cria um objeto do tipo Pai
Filha f = new Filha (); // Cria um objeto do tipo filha
p. teste(); // Executa o método teste da classe Pai
f.teste(); // Executa o método teste da classe Pai
}
}
Filha.java
Principal.java
class Pai {
public void teste() {
System.out.println(“Método da classe Pai”);
}
}
class Filha extends Pai{
public void teste() {
System.out.println(“Método da classe Filha”);
Pai.java
Filha.java
Sobreposição de métodos
System.out.println(“Método da classe Filha”);
}
}
class Principal {
public static void main(String args()) {
Pai p = new Pai(); // Cria um objeto do tipo Pai
Filha f = new Filha (); // Cria um objeto do tipo Filha
p. teste(); // Executa o método teste da classe Pai
f.teste(); // Executa o método teste da classe Filha
}
}
Principal.java
� Regras para redefinição de métodos:
� O nome do método tem que ser o mesmo
� A lista de parâmetros tem que ser exatamente a mesma
� O tipo de retorno tem que ser o mesmo
O nível de acesso (protected, public, etc) não pode ser
Sobreposição de métodos 
(override)
� O nível de acesso (protected, public, etc) não pode ser
mais restrito que o do método redefinido.
� Exemplos inválidos de redefinição de método para:
� private void calcular ( ) { } 
� public void calcular (int valor) { }
� public int calcular ( ) { }
public void calcular ( ){ }
� Exercício: implementar as seguintes classes:
Funcionario
-numeroMatricula: int
-nomeFuncionario: String-nomeFuncionario: String
FuncionarioMensalista
-salarioMensal: double
FuncionarioHorista
-valorHora: double
-horasTrabalhadas: int
+ imprimeDados(): void
+ imprimeDados(): void
+ imprimeDados(): void
Exercício 
� Crie uma classe Principal
� Defina o método main
� Crie um objeto da classe Funcionario
� Chame o método imprimeDados()� Chame o método imprimeDados()
� Crie um objeto da classe FuncionarioHorista
� Chame o método imprimeDados().