Interfaces

Definição
• Uma interface pode definir uma série de
métodos, mas nunca conter implementação
deles
• Ela só expõe o que o objeto deve fazer, e
não como ele faz, nem o que ele tem.
Ex.:
public class GRUPO{
public int Codigo;
public String Descricao;
public GRUPO(int C, String D) {
Codigo = C;
Descricao = D;
}
}
interface InterfaceGrupo{
void Listar();
}
Interface
• No momento em que uma classe implementa uma
interface, ela precisa escrever os métodos pedidos pela
interface (muito parecido com o efeito de herdar
métodos abstratos, aliás, métodos de uma interface são
sempre públicos e abstratos).
• Para implementar usamos a palavra
chave implements na classe:
class SubGrupo1 extends Grupo implements InterfaceGrupo{
private double Peso;
public void Listar() // Implementação do método definido na
{ // interface
System.out.println(“Código:”+Codigo);
System.out.println(“Descrição:”+Descricao);
System.out.println(“Peso:”+Peso);
}
}
Classes Abstratas
Definição
• Classes abstratas tem uma função importante na
orientação a objeto em Java.
• De forma objetiva, uma classe abstrata serve
apenas como modelo para uma classe concreta
(classe que comumente usamos).
• Por serem modelos de classes, elas não podem ser
instanciadas diretamente com o new, e só poderão
ser utilizadas como superclasses herdadas por
classes concretas.
Definição
• Outro fato importante de classes abstratas é que
elas podem conter ou não métodos abstratos, que
têm a mesma definição da assinatura de método
encontrada em interfaces.
• Os métodos abstratos definidos em uma classe
abstrata devem obrigatoriamente ser
implementados em uma classe concreta. Mas se
uma classe abstrata herdar de outra classe
abstrata, a classe que herda não precisa
implementar os métodos abstratos.
Definição
• Para criarmos uma classe ou método abstrato
usamos a palavra-chave abstract.
• Para demonstrar, usaremos uma classe abstrata
chamada GRUPO, que servirá de modelo para
objetos.
Exemplo
public abstract class GRUPO{
private int Codigo;
private String Descricao;
// métodos abstratos não possuem corpo, da mesma forma que
// as assinaturas de método de uma interface
public abstract void Listar();
//Classes Abstratas também podem ter métodos construtores,
//porém, não podem ser usados para instanciar um objeto
//diretamente
public GRUPO(int C, String D) {
Codigo = C;
Descricao = D;
}
Exemplo
// métodos concretos
//Uma classe abstrata pode possuir métodos não abstratos
public void setCodigo(int C) {
Codigo = C;
}
public int getCodigo() {
return Codigo;
}
public void setDescricao(String D) {
Descricao = D;
}
public String getDescricao() {
return Descricao;
}
}
Continuando, vamos criar uma classe de nome
SUBGRUPO1 como subclasse da classe abstrata
GRUPO
public class SUBGRUPO1 extends GRUPO{
private double Peso;
public SUBGRUPO1(int C, String D, double P) {
super (C,D); // construtor classe abstrata
Preco = P;
}
/* implementação do métodos abstrato */
public void Listar() {
System.out.println(“Código:”+Codigo);
System.out.println(“Descrição:”+Descricao);
System.out.println(“Peso:”+Peso);
}
}
Classe com o nome SUBGRUPO2 como subclasse da
classe abstrata GRUPO
public class SUBGRUPO2 extends GRUPO{
private double Volume;
public SUBGRUPO1(int C, String D, double V) {
super (C,D); // construtor classe abstrata
Volume = V;
}
/* implementação do métodos abstrato */
public void Listar() {
System.out.println(“Código:”+Codigo);
System.out.println(“Descrição:”+Descricao);
System.out.println(“Volume:”+Volume);
}
}
Conclusão
• Como podemos ver, as classes SUBGRUPO1 e
SUBGRUPO2 têm como base a classe abstrata GRUPO.
• O método abstrato Listar() teve implementações diferentes (e
obrigatórias) para cada uma das subclasses.
• As classes abstratas servem de base para codificação de
uma classe inteira, diferentemente das interfaces que
são apenas assinaturas dos métodos.
• Sumarizando, quando temos que definir variáveis,
constantes, regras, e pequenas ações definidas devemos
usar classes abstratas. Mas, se formos apenas criar a
forma como objetos devem realizar determinadas ações
(métodos) devemos optar por interfaces.
Modificadores
Modificadores
• Os modificadores de classes e métodos são:
• public: deixará visível a classe ou um membro dela para
todas as outras classes, subclasses e pacotes do projeto
Java.
• private: deixará visível o atributo apenas para a classe
em que este atributo se encontra.
• protected: deixará visível o atributo para todas as outras
classes e subclasses que pertencem ao mesmo pacote. A
principal diferença é que apenas as classes do mesmo
pacote tem acesso ao membro. O pacote da subclasse
não tem acesso ao membro.
• Sem modificador: a linguagem Java permite acesso aos
membros apenas ao pacote em que ele se encontra.
 Exemplo e Resumo
public class MinhaClasse { //classe public
private int inteiro; //atributo inteiro private
protected float decimal; //atributo float protected
boolean ativado; //atributo booleano package-private
}
Modificador Classe Pacote Subclasse Globalmente
Public sim sim sim sim
Protected sim sim sim não
Sem sim, se estiver
modificador sim sim no mesmo não
(Padrão) pacote
private sim não não não