Como vimos anteriormente, subclasses podem redefinir (sobrepor) um método de sua superclasse.

Transcrição

1 Métodos e Classes Abstratas Como vimos anteriormente, subclasses podem redefinir (sobrepor) um método de sua superclasse. Para indicar que um método de uma classe deve necessariamente ser redefinido em cada uma de suas subclasses devemos usar o modificador abstract. Uma classe que contém um ou mais métodos abstratos deve ser declarada explicitamente como abstrata. Essa classe, no entanto, pode ter construtores e métodos concretos (não-abstratos). ELFS 171

2 Métodos e Classes Abstratas Se uma classe é declarada como abstract não podem ser criados objetos desta classe. Se uma subclasse é derivada de uma superclasse que contém um método abstrato e se esse método abstrato não for redefinido na subclasse, esse método permanece abstract na subclasse. Com isso, a subclasse deverá ser declarada explicitamente como abstract. Declarar um método como abstrato é uma forma de obrigar o programador a redefinir esse método em todas as subclasses para as quais se deseja criar objetos. Como um método abstrato deve ser redefinido nas subclasses, na superclasse ele não precisa ter implementação alguma. ELFS 172

3 // Classe abstrata Empregado public abstract class Empregado private String nome; private String familia; Empregado.java Como a classe contém um método abstrato, ela deve ser declarada como abstrata. public Empregado(String n, String f) nome = n; familia = f; public String getnome() return nome; public String getfamilia() return familia; public String tostring() return nome + ' ' + familia; public abstract double ganha(); Método abstrato. Deve ser implementado na subclasse. ELFS 173

4 Vamos imaginar a seguinte hierarquia de classes: Empregado Chefe PorComissao PorItem PorHora onde Chefe, PorComissao, PorItem e PorHora são classes finais. Todas essas subclasses vão precisar redefinir o método ganha(). Como se tratam de tipos diferentes de empregado, cada um ganha de uma forma: Chefe: salário fixo e predefinido; PorComissao: valor fixo + comissão * vendas; PorItem: valor por produção * quantidade produzida; PorHora: valor por hora * total de horas trabalhadas. Declarando o método como abstrato na superclasse garante-se que nas 4 subclasses haverá a implementação do método ganha() para cada tipo de empregado (do contrário, objetos destas classes não poderão ser criados). ELFS 174

5 // Classe final Chefe, derivada de Empregado public final class Chefe extends Empregado private double salario; public Chefe(String n, String f, double s) super(n,f); setsalario(s); public void setsalario( double s ) salario = (s > 0? s : 0.0); public double ganha() return salario; public String tostring() return "Chefe: " + super.tostring(); Implementação do método abstrato da superclasse. Chefe.java ELFS 175

6 public final class PorComissao extends Empregado private double salario; private double comissao; // comissao por item vendido private int vendas; // numero de itens vendidos public PorComissao(String n, String f, double s, double c, int v) super(n,f); setsalario(s); setcomissao(c); setvendas(v); public void setsalario(double s) salario = (s > 0? s : 0.0); public void setcomissao(double c) comissao = (c > 0? c : 0.0); public void setvendas(int v) vendas = (v > 0? v : 0); public double ganha() return salario + comissao*vendas; public String tostring() return "Por comissao: " + super.tostring(); PorComissao.java Implementação do método abstrato da superclasse. ELFS 176

7 public final class PorItem extends Empregado private double producao; // salario por producao private int quantidade; // quantidade produzida PorItem.java public PorItem(String n, String f, double p, int q) super(n,f); setproducao(p); setquantidade(q); public void setproducao(double p) producao = (p > 0? p : 0.0); public void setquantidade(int q) quantidade = (q > 0? q : 0); public double ganha() return producao*quantidade; Implementação do método abstrato da superclasse. public String tostring() return "Por item: " + super.tostring(); ELFS 177

8 public final class PorHora extends Empregado private double valor; // salario por hora private double horas; // horas trabalhadas (300 horas no máximo) public PorHora(String n, String f, double v, double h) super(n,f); setvalor(v); sethoras(h); public void setvalor(double v) valor = (v > 0? v : 0.0); public void sethoras(double h) horas = (h >= 0 && h <= 300? h : 0.0); public double ganha() return valor*horas; Implementação do método abstrato da superclasse. PorHora.java public String tostring() return "Por hora: " + super.tostring(); ELFS 178

9 import java.text.decimalformat; TestaClasseAbstrata.java public class TestaClasseAbstrata public static void main( String args[] ) Empregado e; // variável de referência da superclasse String sai = ""; DecimalFormat df = new DecimalFormat("0.00"); Chefe c = new Chefe("Joao","Silva", ); PorComissao pc = new PorComissao("Maria","Souza",400.00,3.00,150); PorItem pi = new PorItem("Pedro","Cabral",2.50,200); PorHora ph = new PorHora("Marta","Ferreira",13.75,40.50); sai += c.tostring() + " ganha $" + df.format(c.ganha()) + "\n"; sai += pc.tostring() + " ganha $" + df.format(pc.ganha()) + "\n"; sai += pi.tostring() + " ganha $" + df.format(pi.ganha()) + "\n"; sai += ph.tostring() + " ganha $" + df.format(ph.ganha()) + "\n"; System.out.println(sai); Chefe: Joao Silva ganha $3000,00 Por comissao: Maria Souza ganha $850,00 Por item: Pedro Cabral ganha $500,00 Por hora: Marta Ferreira ganha $556,88 ELFS 179

10 Interfaces Classes abstratas contém métodos abstratos (pelo menos um) mas podem conter atributos e métodos concretos. Interfaces são classes abstratas que contêm apenas métodos abstratos. Portanto, em uma interface não existe implementação alguma. A definição de uma interface é feita pela palavra-chave interface. Para utilizar uma interface, uma classe deve especificar que implementa (implements) a interface e a classe deve definir cada método da interface respeitando o número de argumentos e o tipo de retorno especificado na interface. Se a classe deixar de implementar algum método da interface, a classe se torna abstrata. Diversas classes, sem nenhum relacionamento, podem se relacionar com uma mesma interface, assim como uma classe pode implementar mais de uma interface. Automovel Veiculo Caminhao Companhia Se Veiculo é uma interface e Companhia é uma sub-interface de Veiculo, a classe Caminhao pode implementar as duas interfaces (note que isso não seria permitido se Veiculo e Companhia fossem classes, pois haveria herança múltipla). Note que Companhia e Automovel não têm relacionamento algum, mas se relacionam com a mesma interface (Veiculo). ELFS 180

11 A principal utilização de interfaces está em declarar métodos que uma ou mais classes devem necessariamente implementar. Como a interface não apresenta o código dos métodos, ela pode ser utilizada para apresentar a interface pública de uma classe sem revelar sua implementação. Como diferentes classes, sem nenhum relacionamento, podem implementar uma mesma interface pode-se capturar similaridades entre classes sem definir um relacionamento explícito entre elas. Através de interfaces se pode simular herança múltipla: uma mesma classe pode implementar diferentes interfaces. Outra utilização é na definição de objetos public static final (constantes). Exemplo: Constantes.java public interface Constantes public static final int UM = 1; public static final int DOIS = 2; public static final int TRES = 3; Note que, como não há métodos declarados nessa interface, uma classe que implementa essa interface não é obrigada a fornecer implementação alguma. As classes que implementam a interface Constantes podem utilizar as constantes UM, DOIS e TRES em qualquer lugar na definição da classe. Uma classe pode até utilizar essas constantes importando a interface e então referenciando as constantes como: Constantes.UM, Constantes.DOIS e Constantes.TRES. ELFS 181

12 Exemplo: Hierarquia de formas geométricas com interfaces. Desejamos que todas as classes que implementam formas geométricas disponham dos métodos getnome(), getarea() e getvolume(). Forma.java public interface Forma public String getnome(); public double getarea(); public double getvolume(); Construir a hierarquia: Forma Ponto Circulo Cilindro public class UsaFormas UsaFormas.java public static void mostra(forma f) System.out.println(f.getNome() + ": " + f.tostring() + "\narea = " + f.getarea() + "\nvolume = " + f.getvolume()); public static void main(string args[]) Ponto p = new Ponto(7, 11); // x, y Circulo c = new Circulo(3.5, 22, 8); // r, x, y Cilindro d = new Cilindro(10, 3.3, 10, 10); // h, r, x, y mostra(p); mostra(c); mostra(d); ELFS 182

13 Exercícios: 1. Modifique a classe abstrata Empregado incluindo o campo privado datanascimento e um método público concreto adicionarbonus(), que acrescenta $100,00 ao salário de cada empregado que faz aniversário no mês. Criar uma classe FolhaPagamento, que lê dados referentes ao conjunto de empregados de uma empresa e mostra a folha de pagamento da empresa. 2. Escrever as classes Ponto, Circulo e Cilindro que implementam a interface Forma. Executar a classe UsaFormas para verificar se as classes foram implementadas corretamente. 3. Criar uma interface MeuHorario com métodos gethora(), getminuto(), getsegundo(), sethora(), setminuto(), setsegundo(), tostring(). Criar uma classe Horario que implementa essa interface. Criar uma classe UsaHorario que lê uma dada quantidade de segundos, cria e mostra um objeto da classe Horario referente ao dado lido. Por exemplo: segundos = 08:20: Criar uma interface MinhaData com métodos getdia(), getmes(), getano() e mostrardata(). Criar uma classe Data que implementa essa interface. A classe Data deve incluir também métodos set para tratamento dos dados referentes aos campo privados da classe: dia, mes, ano. Suponha que um ano tem sempre 365 dias. ELFS 183