www.tiexpert.

net – O ponto de encontro do estudante de TI

Classes Abstratas e Métodos Abstratos
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).
Como classes abstratas são modelos de classes, então, não podem ser instanciadas diretamente com o
new, elas sempre devem ser herdadas por classes concretas.
Outro fato importante de classes abstratas é que elas podem conter ou não métodos abstratos, que tem a
mesma definição da assinatura de método encontrada em interfaces. Ou seja, uma classe abstrata pode
implementar ou não um método.
Os métodos abstratos definidos em uma classe abstrata devem obrigatoriamente ser implementados em
uma classe concreta. Mas se uma classe abstrata herdar outra classe abstrata, a classe que herda não
precisa implementar os métodos abstratos.
Para criarmos uma classe ou método abstrato usamos a palavra-chave abstract.
Para demonstrar, usaremos uma classe abstrata chamada Eletrodomestico, que servirá de modelo para
todos os objetos que possam ser eletrodomésticos.
package classeAbstrata;

public abstract class Eletrodomestico {

private boolean ligado;
private int voltagem;

// métodos abstratos //
/*
* não possuem corpo, da mesma forma que
* as assinaturas de método de uma interface
*/
public abstract void ligar();
public abstract void desligar();

// método construtor //
/*
* Classes Abstratas também podem ter métodos construtores,
* porém, não podem ser usados para instanciar um objeto diretamente
*/
public Eletrodomestico(boolean ligado, int voltagem) {
this.ligado = ligado;
this.voltagem = voltagem;
}

// métodos concretos
/*
* Uma classe abstrata pode possuir métodos não abstratos
*/
public void setVoltagem(int voltagem) {
this.voltagem = voltagem;
}

public int getVoltagem() {

return this.voltagem;
}

public void setLigado(boolean ligado) {

this.ligado = ligado;
}

http://www.tiexpert.net/ver.php?page=172 Página 1
 www.tiexpert.net – O ponto de encontro do estudante de TI

public boolean isLigado() {

return ligado;
}
}

Como podemos observar, criamos um modelo de classe que compreende a uma gama enorme de outros
objetos.
Agora, qualquer objeto que derivar desse modelo deve ter sua voltagem especificada e dizer se está ligado
ou não.
Então, vamos criar outras duas classes que herdam as características da classe abstrata (modelo).
A primeira é a classe TV:
package classeAbstrata;

public class TV extends Eletrodomestico {

private int tamanho;
private int canal;
private int volume;

public TV(int tamanho, int voltagem) {

super (false, voltagem); // construtor classe abstrata
this.tamanho = tamanho;
this.canal = 0;
this.volume = 0;
}

/* implementação dos métodos abstratos */

public void desligar() {
super.setLigado(false);
setCanal(0);
setVolume(0);
}

public void ligar() {

super.setLigado(true);
setCanal(3);
setVolume(25);
}

// abaixo teríamos todos os métodos construtores get e set...

E essa é a classe Radio.

package classeAbstrata;

public class Radio extends Eletrodomestico {

public static final short AM = 1;
public static final short FM = 2;
private int banda;
private float sintonia;
private int volume;

public Radio(int voltagem) {

super(false, voltagem);
setBanda(Radio.FM);
setSintonia(0);
setVolume(0);
}

http://www.tiexpert.net/ver.php?page=172 Página 2
 www.tiexpert.net – O ponto de encontro do estudante de TI
/* implementação dos métodos abstratos */
public void desligar() {
super.setLigado(false);
setSintonia(0);
setVolume(0);
}

public void ligar() {

super.setLigado(true);
setSintonia(88.1f);
setVolume(25);
}

// abaixo teríamos todos os métodos construtores get e set...

Pronto, como podemos ver, temos duas classes totalmente diferentes que tem como base o mesmo modelo.
Também é perceptível o fato de que em ambas as classes, os métodos abstratos ligar() e desligar() foram
implementados, porém, não há a implementação dos outros métodos como setVoltagem() ou isLigado().
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.
A boa combinação de heranças e implementações de classes abstratas e interfaces proporciona uma forma
robusta de criação de softwares e uma ótima alternativa para heranças múltiplas comumente usadas em
C++.
Abaixo está uma classe que testa a funcionalidade dessas classes.
package classeAbstrata;

public class Main {

public static void main(String[] args) {

TV tv1 = new TV(29, 110);
Radio radio1 = new Radio(110);

/*
* chamando os métodos abstratos implementados
* dentro de cada classe (TV e Radio)
*/
tv1.ligar();
radio1.ligar();

System.out.print("Neste momento a TV está ");

System.out.println(tv1.isLigado() ? "ligada" : "desligada");
System.out.print("e o Rádio está ");
System.out.println(radio1.isLigado() ? "ligado." : "desligado.");
}
}

Autor: Denys William Xavier

Este artigo está sob Licença Creative Commons
Para ver uma cópia desta licença, visite http://creativecommons.org/licenses/by-nc-sa/2.5/br/
ou envie uma carta para Creative Commons, 171 Second Street, Suite 300, San Francisco, California 94105, USA.

http://www.tiexpert.net/ver.php?page=172 Página 3